Quiet Time

DNA를 보자

기독교2018. 4. 9. 09:02
어떤 한 꼬마에게 한 아저씨가 물었다 얘 하나님이 있다는 증거 하나만 단 하나라도  보여주면 너에게 오백원을 줄테니 증명해보렴 그러자 그 꼬마가 대답했다 아저씨가 저에게 하나님이 없다는 단 하나의 증거만 보여주면 1000원을 드릴게요

아주 작은 곳 빽빽히 하나님의 손이 미치지 않은 곳이 없다

밤하늘의 수많은 별에서 부터 계절의 변화와 내 세포속 DNA 와 분자와 원자속 원자 핵과 전자들 쿼크와 중성자
짚신벌레와 봄에 피는 꽃과 풀과 나뭇잎과 밀물과 썰물 더율때 부는 바람과 벚꽃과 가을 단풍과 달이 차고 기우는 것과 우주에서 본 푸른 지구와 지구의 자전주기와 자전각도 4계절과 대기의 순환과  철새들의 이동과 개미의 더듬이와 파리의 발과 소의 위와 금속들의 전기적 성질과 수많은 화학물질의 분자구조와 촉매와 반응하는 성질 몸속 백혈구와 대식세포의 면역작용과 폐포의 산소와 이산화탄소의 교환과 이 모든 것들이 저절로 이루어졌다고 할 수 있을까 눈에 보이지 않는 작은 세포들 조차 이리도 복잡하고 놀라운데 어미노산의 우연한 결합으로 이런것들이 턴생했다고 할 수 있을까 길을 지나다 이보다 훨씬 단순한 건물을 보고도 누군가 지었겠거니 하지 오랜시간이 흘러 재료들이 우연히 결합하여 지어졌다고 하지 않는다

DNA
컴퓨터로 프로그래밍하는
나는 하나님의 놀라운 프로그래밍을 본다
DNA의 4가지아미노산은 2종류씩끼리만 결합하여 이것을 0과 1로 나타낼 수 있다 그러면 컴퓨터의 2진법으로 dna코드를 나열 할 수 있고 하나님의 코드는 무려 750MB라고 한다 이것이 평면에 n극s극으로 저장시킨게 아니라 이중나선구조로 23쌍이 우리 세포 하나하나에 담겨있다 용량이 어마어마하다  어떻게 계산해야 할지 모르겠다

세포하나하나에 그 크신 하나님의 사랑 바다를 먹물삼고 하늘을 두루마기로 삼아도 다 쓰지 못한다

'기독교' 카테고리의 다른 글

진동? 말씀?  (0) 2018.04.09
겸손은 또한 자존감이다.  (0) 2018.04.02
아담의 선악과  (0) 2018.04.02

겸손은 자존감과 반대 되는 말처럼 들릴 수 있다.

 

하지만 진정한 겸손은 높은 자존감을 불러온다. 

 

겸손의 최고는 무엇일까 

 

목사님들은 장례식을 많이 경험한다 장례식장은 참 지혜로운 자리라고 생각한다.

 

몇년전 친할머니가 돌아가시고 작년에는 외할아버지께서 돌아가셨다. 

 

그 인생이 한줌의 뼛가루로 변한다. 남은게 아무것도 없다. 

 

한 동안 슬퍼하며 기억되다가 눈에 점점 보이지 않으면 잊혀지고 시간이 점점흐르면 그를 기억했던 사람들은 적어질 것이고 

 

존재의 흔적도 찾을 수 없을 것이다. 

 

어떤 분이 하신 명언 생각난다. 옥한흠 목사님이 하신것 같다.

 

사람은 평생 죽지 않을 것처럼 살다가 한번도 살아본적 없는 것처럼 죽는다. 

 

(목사님의 목사리 톤이 생각나는것 같으니 옥한흠 목사님이 맞는것 같다)

"사람이 죽음을 한번도 생각해 보지 않고 살다가 그 사람이 죽으면 도대체가 그 흔적을 찾아 볼 수가 없어요! 도대체가 마치 어디에도 존재해본적이 없는 사람처럼돼요" (내맘대로 기억을 통해 재구성) 

 

그래서 겸손의 최고는 내가 죽을 것을 항상 인지하고 사는 것이다.

인생은 유한하고 누구나 죽는다. 

우리 인생은 모두 저주 받아서 결국엔 죽는다.

 

우리가 분노에 가득차서 누군가를 저주할때 "너 죽는다." 자주 말한다. 

 

최고의 저주는 죽음이다 죽음보다 더 큰 저주는 없다 

 

그런데 그런 저주를 할 필요가 없다 이미 인생들이 저주를 받아서 누구나 죽는다.

 

이것을 항상 인지하고 살면 참 겸손해진다. 

 

인생은 짧고 우리는 유한한 존재고 언젠가 죽는다. 

 

그렇다고 염세적으로 되라는 것이 아니다 공부도 일도 아무것도 필요없다는 것이 아니다. 

 

 

결론은

이 겸손, 즉 유한한 인생에서 우린 모두 죽을 것을 아는 것을 항상 인지하고 산다면 누구와 비교로 인한 비교의식과 열등감이 사라진다. 이 겸손에서 높은 자존감이 생긴다 . 하나님께서 각자 맡긴 것이 다르다 태어난 곳도 다르고 환경도 다르고 시작이 다르니 끝도 다른 것이다.

유한한 세상에서 남과 비교할 필요도 없다 많이 가질 필요도 없다. 

그저 겸손한 마음으로 하나님께서 주신 사명 맡은 일 모두 열심히 하는 것이다.

가난이 오히려 복이다 가난하지 않으면 하나님께 의지할 필요가 없어질 것이다 

돈 걱정없이 사는 사람들이 얼마나 될까.

 

하나님께 엎드려 빌지 않으면 하루를 버틸 수 없는 인생이 오히려 복될 수 있다. 

 

온갖수단으로 돈을 모으고 하나님의 복이라 이렇게 하면 너희들도 복을 받을 수 있다며 

 

서울을 하나님께 바친 분은 지금 아늑한 방에 홀로 계신다. 

 

+ 가난한 유산 


너희들에게 
내가 
죽어서 
남길 유산은 
부동산도 아니고 
그 흔한 
금은 보화들도 아니고 
묵묵히 가난 속에도 함께하신 
그분의 음성이 담긴 
귀중한 성경책이요
(심홍섭·시인, 1960-)

 

 

(그래도 돈 많이 벌고 싶다.)

 

 

 

 

 

 

 

 

 

 

 

 

 

 

'기독교' 카테고리의 다른 글

진동? 말씀?  (0) 2018.04.09
DNA를 보자  (0) 2018.04.09
아담의 선악과  (0) 2018.04.02

아담의 선악과

기독교2018. 4. 2. 23:05

아담은 하와가 준 선악과를 먹었다. 


아담이 정령 죽을 줄 모르고 먹었을까 


아담은 그 많은 동물들의 이름을 짓고 기억하는 아주 똑똑한 인류의 첫번째 사람이다.


한 사람의 이름을 짓는것도 무척이나 어렵다 


내가 나온 군대 23사단 삼척의 등대교회 군목사님은 자기 딸의 이름을 3년 동안이나 생각하고 지었다고 하셨다.(이름 : 채령)


아담은 단번에 그 많은 동물들의 이름을 지었다(그리고 외웠다) 엄청난 통찰력과 지혜 있는 사람이었다. 


그는 하나님이 정령죽으리라 한 말을 사실로 알았고 믿었을 것이다. 


기억해보자 아담은 하나님께서 만드신 그 여자를 보고 내 살중의 살이요 뼈중의 뼈라고 했다 이 말은 진심이다.


아담은 하와를 자신중의 자신이라고 생각했고 정말 그렇게 생각했다. 


그래서 정령 죽을 줄 알면서 그 열매를 같이 먹은 것이다. 

'기독교' 카테고리의 다른 글

진동? 말씀?  (0) 2018.04.09
DNA를 보자  (0) 2018.04.09
겸손은 또한 자존감이다.  (0) 2018.04.02

docker couchbase

Tips2018. 2. 13. 01:36

윈도우용 docker 설치 그리고 실행



docker run -d --name db -p 8091-8094:8091-8094 -p 11210:11210 couchbase


barplot( d[c(1:7),],names.arg=colnames(t(d)
주제 : 한국인 신체 데이터로 다양한 분석을 하고 시각화 해보자 !
엔트로피와 결정트리 그리기 
궁금증1 . 남자와 여자를 구분할 때 가장 큰 영향을 미치는 속성 무엇일까?

install.packages('FSelector')
library(FSelector)
install.packages("doBy")
library(doBy)

k<- read.csv('kbody3.csv',header=T)
k<- na.omit(k)
normalize <- function(x) {
 return((x - min(x)) / (max(x) - min(x)))
}
norm <- as.data.frame(lapply(k [,c(2:18)], normalize))
norm <- cbind(k [,c(1,19,20)], norm)
colnames(norm)

IG <- information.gain(gender~., norm[,-4]) #성별 컬럼을 뺀다. 
a<- data.frame(IG)
install.packages("doBy")
library(doBy)
d<-orderBy(~-attr_importance,a)
barplot( d[c(1:7),],names.arg=colnames(t(d))[c(1:7)])


결정트리를 그려보자 
tree1 <- rpart(gender~. , data= norm, control=rpart.control(minsplit=2) )

plot(tree1, compress = T , uniform = T , margin=0.1)

text(tree1, use.n = T , col = "blue")

궁금증2 . 나이에 가장 큰 영향을 미치는 컬럼이 키로 나왔다. 

이상하게 여겨져 키와 나이로 plot그래프를 그리니 
10대 이하 성장기인 연령의 키까지 포함되어 그래프가 아래와 같이 나오는것 같았다. 

20세 이상의 사람들만 추려서 나이에 가장 영향을 받는 속성 다시 뽑아보자 
e <- k[k$age >= 20 ,]
IG <- information.gain(age~., e) 
library(doBy)
d<-orderBy(~-attr_importance,a)
barplot( d[c(1:7),],names.arg=colnames(t(d))[c(1:7)])

20대 이상만 걸러내도 키가 가장 큰 영향을 미친다. 
plot으로 그려보면 



나이가 어려질 수록 평균키가 증가하는 경향을 볼 수 있다. 


IG <- information.gain(Basic_metabolism~., norm) #성별 컬럼을 뺀다. 
a<- data.frame(IG)
install.packages("doBy")
library(doBy)
d<-orderBy(~-attr_importance,a)
barplot( d[c(1:7),],names.arg=colnames(t(d))[c(1:7)])

기초 대사량과 관련이 깊은 속성은 ?


각 속성들로 남자와 여자를 구분하는 방법은 다양한 알고리즘으로 시도해보자 ! 
신경망, svm, knn  


신경망으로 !~
norm <- as.data.frame(norm)
quater3 <- sample(nrow(norm),round(0.75 * nrow(norm)))
k_train <- norm[quater3,]
nrow(k_train)
k_test <- norm[-quater3,]
nrow(k_test)

n <- colnames(k_train)

# energy_output ~ temperature + exhaust_vacuum + … 를 변수 f 에 집어넣기
f <- as.formula(paste("gender ~", paste(n[!n %in% "gender"], collapse = " + ")))

quater3 <- sample(nrow(norm),round(0.75 * nrow(norm)))
k_train <- norm[quater3,]
nrow(k_train)
k_test <- norm[-quater3,]
nrow(k_test)

model <- neuralnet(formula = f,  data = k_train, hidden= c(3,3))

model_results <- compute(model , k_test[-1])
predicted <- model_results$net.result
cor[predicted,k_test$gender]

model_results <- compute(model , k_test[-1])
predicted <- model_results$net.result

plot(model)


cor(predicted,k_test$gender)

 svm으로!
install.packages("kernlab")
library(kernlab)

ksvm <- ksvm(gender~ ., data = k_train, kernel = "rbfdot")
pred <- predict(ksvm , k_test)
agreement <- round(pred) == k_test $gender
table(agreement )

prop.table(table(agreement))




knn으로 ~
install.packages("class")
library(class)
pred <- knn(train = k_train, test = k_test, cl = k_train$gender, k=21)
library(gmodels)

CrossTable(x = k_test$gender, y = pred ,  prop.chisq=FALSE)


100% 분류! 






 

■ apriori 알고리즘
  1. apriori 알고리즘 이무엇인지?
  2. apriori 알고리즘 실습 1 ( 맥주와 기저귀)
  3. apriori 알고리즘 실습 2 (상가 건물 데이터)
  4. apriori 알고리즘 실습 3 ( 책 : 야채와 우유 데이터) 
■ 1.apriori 알고리즘이 무엇인지?

맥주와 기저귀와의 관계를 알아낸 대표적인 기계학습 방법

시리얼 ----------------> 우유 

쉽게 말해 이 규칙은 시리얼을 사면 우유도 함께 구매한다는 것을 알아내는 알고리즘 

  • apriori 알고리즘 공식(p312)
                count(x)  <- x 아이템의 거래건수
support(x) = ---------------
     ↑              N  <- 데이터베이스의 전체 거래 건수
아이템 x에 대한 지지도 
                              support(x,y)           
     confidence (x -> y) = ----------------
                              support(x) 

연관 관계의 계산은 아이템들의 출현 빈도를 이용하여 계산을 하게 된다.

신뢰도(기저귀 ---> 맥주) ? 항목 기저귀를 포함하는 건수에서 기저귀와 맥주를 모두
                         포함하는 건수의 비를 구한다.

     다시 말하면 ?
         
     아이템 기저귀가 출현될 때 또 다른 아이템 맥주가 포함되어있을 경우의 조건부 확률

지지도(우유 ---> 시리얼) : 우유와 시리얼을 동시에 구매할 확률
신뢰도(우유 ---> 시리얼) : 우유를 구매할때 시리얼도 같이 구매할 확률

예 : 90%의 사람이 시리얼 구매할 때 우유를 같이 구매한다.
     라는 연관 규칙을 발견하려 한다. 
 
  거래번호        구매물품          (p311)
     1          우유, 버터,시리얼
     2          우유, 시리얼
     3          우유, 빵
     4          버터, 맥주, 오징어

문제232. 전체 아이템에서 우유와 시리얼이 동시에 출현할 확률은? 
 
2/4 

문제233. 우유를 샀을때 시리얼 살 조건부 확률

2/3 

문제234. 이와는 반대로 시리얼을 샀을때 우유를 동시에 구매할 확률

100% 

이를 간단히 표현하면 다음과 같다 

우유 ---> 시리얼( 50%, 66%)
시리얼 --> 우유 (50%, 100%)

시리얼을 샀을때 우유를 사게되는 지지도는 50%이고 신뢰도는 100% 이다.

우리가 찾고자 하는 연관 규칙은 지지도와 신뢰도가 둘다 최소한도보다 
높은것이다. 

보통은 최소 지지도를 정하여 그 이하는 모두 버리고 그중에 신뢰도가 어느정도 높은것들만 가져오는 
방법을 쓴다. 

x와 y라는 항목의 조합의 수도 너무나도 다양하기 때문에 모든 경우의 수를 다 계산한다면 시간이 오래 걸린다.

최소 지지도 이상의 데이터를 찾는다 어떻게 하면 찾을 수 있는지 연습해보자 

       거래번호        아이템
          1          A C D
          2          B C E
          3          A B C E 
          4          B E 

문제235. 위으 각각의 아이템에 대해서 지지도를 산정해보시오! 
     원래 지지도는 "구매건수/전체구매건수" 로 계산 할 수 있지만
     여기서는 단순하게 아이템의 갯수로 처리하시오 

아이템   지지도 
  A     2          
  B     3
  C     3
  D     1
  E     3

문제236. 이것에 대해서 지지도가1이상인것만 추출하여 다시 정리하시오 

아이템   지지도 
  A     2          
  B     3
  C     3
  E     3

문제237. 이제 아이템들간의 연관규칙을 알아야하므로 다시 아이템들간의      
     조합으로 재구성하고 지지도를 다시 구하시오 

아이템 목록     지지도          거래번호   아이템 
A  B          1                   1    A C D
A  C          2                   2    B C E
A  E          1                   3    A B C E
B  C          2                   4    B E
B  E          3
C  E          2

그리고 지지도가 1인것은 제외한다.

아이템 목록     지지도
A  C          2
B  C          2
B  E          3
C  E          2 

문제238. 이제 각각의 아이템 목록에서 첫번째 아이템을 기준으로 
          동일한것을 찾아보시오!

B 가 발생하면 이 B에 대해서 각각의 두번재 키를 조합한다. 
B 에 대해서 C, E가 조합된다.

아이템 목록      지지도
B C E           2

             처음상태 -------------------------------------> 발견된 연관규칙 
       거래번호        아이템                             아이템 목록    지지도 
          1          A C D                              B C E           2
          2          B C E
          3          A B C E 
          4          B E 


문제239. 맥주와 기저귀 판매 목록 데이터를 가지고 
        기저귀를 사면 맥주를 산다라는 연관규칙을 발견하시오 !
 

 


x <- data.frame(

beer=c(0,1,1,1,0),

bread=c(1,1,0,1,1),

cola=c(0,0,1,0,1),

diapers=c(0,1,1,1,1),

eggs=c(0,1,0,0,0),

milk=c(1,0,1,1,1) )


install.packages("arules")
library(arules) 

trans <- as.matrix(x, "Transaction")
trans


rules1 <- apriori(trans, parameter = list(supp=0.2, conf=0.6, target="rules"))
rules1

inspect(sort(rules1))


                            지지도  신뢰도
5  {beer}    => {diapers}     0.6  1.0000000 1.2500000
6  {diapers} => {beer}        0.6  0.7500000 1.2500000
7  {milk}    => {bread}       0.6  0.7500000 0.9375000
8  {bread}   => {milk}        0.6  0.7500000 0.9375000

문제240. 건물 상가에 서로 연관이 있는 업종은 무엇인가?
          (병원 ---> 약국) data 게시판에 건물 상가 데이터 
 
install.packages("arules")
library(arules)

build<- read.csv('building.csv', header= T)

build[is.na(build)]<- 0
build <- build[-1]
trans <- as.matrix(build, "Transaction")

rules1 <- apriori(trans, parameter = list(supp=0.2, conf=0.6, target="rules"))
rules1
inspect(sort(rules1))

   lhs                 rhs              support confidence     lift
1  {일반음식점}     => {패밀리레스토랑}    0.40  1.0000000 2.222222
2  {패밀리레스토랑} => {일반음식점}        0.40  0.8888889 2.222222
3  {약국}           => {휴대폰매장}        0.25  1.0000000 3.333333
4  {휴대폰매장}     => {약국}              0.25  0.8333333 3.333333
5  {약국}           => {병원}              0.25  1.0000000 3.333333
6  {병원}           => {약국}              0.25  0.8333333 3.333333
7  {휴대폰매장}     => {병원}              0.25  0.8333333 2.777778

결론 :  일반 음식점과 패밀리 레스토랑이 같은 건물에 있는 경향이 높고 약국과 병원, 휴대폰 판매점이 같은 건물에 있는 경향이 있다.

문제241. 보습학원이 있는 건물에는 어떤 업종의 매장이 있는지 알아내시오 (연관이 높은지 알아내시오 ) 

30 {보습학원,    은행}       => {카페}              0.20  1.0000000 4.000000
31 {카페,    보습학원}       => {은행}              0.20  1.0000000 5.000000

보습학원 있으면 아주 높은 확률로 그 건물에 은행이나 카페가 있네여 ! 

  1. apriori 알고리즘 실습 3 (책: 야채와 우유 데이터 ) 
[ 경원형 발표 ]
groceries <- read.transactions("groceries.csv",sep=",")

groceries


summary(groceries)
# 9835행은 저장된 거래와 169개 열은 사람들의 장바구니에 있을 수 있는 169개 제품에 대한 속성이다.
# 매트릭스의 각 칸은 거래에서 구매한 제품이면 1, 그렇지 않으면 0이 된다.
# 밀도값 0.02609146은 매트릭스에서 0이 아닌 칸의 비율을 뜻한다.
# 9835 * 169 = 1,662,115개가 매트릭스에 있기 때문에 상점의 영업시간동안
# 총 1662115 * 0.02609146 = 43,367개의 제품이 거래됏음을 계산 할 수 있다.
# 평균 한번의 거래에서 43367 / 9835 = 4.409개의 다른 제품이 구매됏다.
# whole milk 의 2513 / 9835 = 0.2555이기 때문에 거래의 25.6%에서 whole milk가 나타난다.
# whole milk 말고도 나머지도 일반적인 제품이다.
# element (itemset/transaction) length distribution를 보면
# 2159 거래는 하나의 제품을 포함하고 있고 1개 거래가 32개 제품을 포함한다.
# mean이 4.409로 43367 / 9835 = 4.409 이 계산과 맞아 떨어진다.

# 희소 매트릭스의 내용을 보기 위해 벡터 연산의 조합과 inspect() 함수를 사용한다.

# 첫 5개의 거래를 볼수 있다.
# csv 파일과 같다
inspect(groceries[1:5])

# itemFrequency() 함수는 제품이 포함한 거래의 비율을 볼 수 있게 한다.
# 예를 들어 식료품 데이터 3개 제품에 대해 지지도 레벨(support level)을 볼 수 있다.
itemFrequency(groceries[,1:3])

# 데이터에서 적어도 0.1(10%)의 지지도 이상인 8개 제품을 보여준다.
itemFrequencyPlot(groceries , support=0.1)

# groceries 데이터에서 상위 20개 제품에 대한 다이어그램이다.
itemFrequencyPlot(groceries, topN=20)


image(groceries[1:5])

# 100개의 행과 169개의 열로 구성된 매트릭스 다이어그램을 생성한다.
image(sample(groceries,100))

## 3단계 : 데이터로 모델 훈련
apriori(groceries)

# 하루에 두번씩(약 60번) 구매되는 제품이라면 지지도 레벨을 계산하는데 쓸 수 있다.
# 총 9835에서 60은 0.006이기 때문에 지지도를 0.006으로 한다.
# 결과에 포함되기 위해서 적어도 25% 정확도의 규칙을 뜻하는 0.25인 신뢰도 경계 값으로 시작한다.
# 두 제품보다 적게 포함되는 규칙을 제거하기 위한 minlen을 2로 설정한다.
groceryrules <- apriori(groceries, parameter=list(support = 0.006, confidence=0.25, minlen=2))
# 463개의 연관 규칙을 포함하고 있다. 규칙이 사용할 만한지 결정하기 위해 좀 더 살펴봐야 한다.
groceryrules

## 4단계: 모델 성능 평가

# rule length distribution 이부분을 살펴보면
# 150개의 규칙이 2개의 제품을 갖고 있는 반면, 297개의 규칙은 3개, 16개의 규칙은 4개 제품을 가지고 있다
# 세번째 열인 리프트(lift)는 지금까지 고려하지 않은 메트릭이다. 다른 물품을 구매한 것을 고려해
# 전형적인 구매 비율과 상대적으로 물푸이 얼마나 구매됏는지 측정한다. 이는 다음 식으로 정의 된다.
#                confidence(X->Y)
# lift(X->Y) = -------------------
#                 support(Y)
# mining info 부분은 얼마나 규칙을 선택할 수 있는지 알려준다.
# 9835건의 거래를 포함한 groceries 데이터는 최소 지지도인 0.006과 최소 신뢰도인 0.25로 규칙을 만든것을 확인할 수 있다.
summary(groceryrules)

# lhs는 규칙을 작동시키기 위해 충족해야할 조건이고 rhs는 충족된 조건의 결과로 예상되는 값이다.
# 첫번째 규칙은 소비자가 potted plants(화분 식물)을 사면 whole milk(전유)도 산다는 의미이다
# 약 0.007의 지지도와 0.4의 신뢰도를 가지고 있고 이 규칙은 약 0.7%의 거래를 이룬다.
inspect(groceryrules[1:3])

## 5단계 : 모델 성능 향상
# 리프트 통계를 따르는  최상상의 5개 규칙은 다음과 같다.
# 리프트가 3.956477인 첫번째 규칙은 허브를 산 구매자는 일반적으로 근채류 구매가 4배에 가깝다고 나온다.
# 두번째 규칙은 딸기를 구매한 소비자는 일반 소비자보다 3배 더 많이 거품크림을 구매한다.
inspect(sort(groceryrules,by="lift")[1:5])

# subset() 함수는 거래,제품,규칙의 부분집합을 찾는 기법을 제공한다.
# 딸기 홍보광고를 만들기 위해서 딸기가 포함된 규칙을 저장한다.
berryrules <- subset(groceryrules,items %in% "berries")
inspect(berryrules)

# 장바구니 분석 결과를 공유하기 위해 write함수로 csv파일에 저장할 수 있다.
write(groceryrules, file="groceryrules.csv",sep=",", quote=TRUE, row.names=FALSE)

# 규칙을 데이터 프레임으로 변환하는것이 편리하다. as() 함수를 이용해서 만들수 있다.
groceryrules_df <- as(groceryrules, "data.frame")
# 수치가 가장 높은 순으로 정렬
install.packages("doBy")
library(doBy)
head(orderBy(~-lift,groceryrules_df))
head(orderBy(~-support,groceryrules_df))
head(orderBy(~-confidence,groceryrules_df))
str(groceryrules_df)




문제242. (점심시간 문제) 다음 데이터에서 가장 연관성이 높은 항목을 찾으시오

x <- data.frame(
  영화=c(0,1,1,1,0,1,1,1,0,1,1,1,1),
  오징어=c(1,0,1,1,1,1,0,0,0,1,0,0,1),
  맥주=c(0,0,1,0,1,0,0,0,1,1,0,0,1),
  음료=c(1,1,0,1,1,0,0,1,0,0,1,1,0),
  스낵=c(0,1,0,0,0,0,0,0,0,1,1,0,0),
  팝콘=c(0,1,1,1,1,1,1,1,0,1,1,0,1))

trans <- as.matrix(x, "Transaction")
trans


rules1 <- apriori(trans, parameter = list(supp=0.2, conf=0.6, target="rules"))
rules1

inspect(sort(rules1))


> inspect(sort(rules1))
   lhs         rhs        support confidence      lift
1  {}       => {영화}   0.7692308  0.7692308 1.0000000
2  {}       => {팝콘}   0.7692308  0.7692308 1.0000000
3  {영화}   => {팝콘}   0.6923077  0.9000000 1.1700000
4  {팝콘}   => {영화}   0.6923077  0.9000000 1.1700000
5  {오징어} => {팝콘}   0.4615385  0.8571429 1.1142857
6  {팝콘}   => {오징어} 0.4615385  0.6000000 1.1142857
7  {음료}   => {영화}   0.3846154  0.7142857 0.9285714




x <- data.frame(
  영화=c(0,1,1,1,0,1,1,1,0,1,1,1,1),
  오징어=c(1,0,1,1,1,1,0,0,0,1,0,0,1),
  맥주=c(0,0,1,0,1,0,0,0,1,1,0,0,1),
  음료=c(1,1,0,1,1,0,0,1,0,0,1,1,0),
  스낵=c(0,1,0,0,0,0,0,0,0,1,1,0,0),
  팝콘=c(0,1,1,1,1,1,1,1,0,1,1,0,1))

trans <- as.matrix(x, "Transaction")
trans
rules1 <- apriori(trans, parameter = list(supp=0.2, conf=0.6, target="rules"))
a <- as(rules1, "data.frame")
head(orderBy(~-lift,a))














 

▣ R 를 활용한 기계학습 7장. 블랙박스 기법 : 신경망과 서포트 벡터 머신 신경망 (p286)

■  서포트 벡터 머신이란(Support Vector Machine: SVM)?
서포트 벡터 머신이란 간단히 말해 이진 분류기이다. 
 SVM 목적은 초평면(hyperplane) 기준으로 한쪽 면으로 동일한 데이터가 놓이게 평평한 경계를 만드는 것이다.



 
  • 초평면 (hyperplane)?
SVM 보통 범주 값을 유사한 데이터들로 그룹짓기 위해 초평면(hyperplane )이라는 경계를 사용하는데

hyperplane은 n-1차원의 subspace를 의미하는 것이며, 3차원의 경우 hyperplane은 2차원의 면이 되고, 2차원의 경우는 hyperplane은 1차원의 선이된다








 ■  Kernel Tricks 기법: 선형분리가 불가능한 데이터나
비선형 data들을 차원 높여서 분리하는 방법

이렇게 1차원 데이터를 2차원으로 높이게 되면 분리가 가능하다.

그림을 보면 왼쪽 평면에 있는 sample들이 오른쪽과 같이 변형되었는데, 이것은 sample들이 있는 공간을 kernel 함수를 이용하여 공간을 3차원 공간으로 변형시켜주었기 때문이다. 그런 다음 3차원 공간에서 hyperplane을 이용하면 cancer와 normal 샘플들을 좀 더 쉽게 구별할 수 있게 된다.
 



 
왼쪽 그림에서는 대각선 방향의 직선이 최대 여백 초평면(Maximum Margin Hyperplane) 해당한다. 그리고 직선과 가장 가까운 분류에 속한 점들을 서포트 벡터 라고한다.























■  실습1 : 붓꽃 데이터 분류--- 1. Data set : 기본제공(iris)
data(iris)
install.packages("ggplot2")
library(ggplot2)
gplot(Petal.Length, Petal.Width, data=iris, color = Species) #실제 데이터를 확인
library(e1071)
s<-sample(150,100)       # 1 ~ 150 까지 중복되지 않는 랜덤수를 100개 생성
col<- c("Petal.Length", "Petal.Width", "Species")    # 컬럼명 지정 꽃잎 길이 , 꽃잎 폭, 종류
iris_train <- iris[s,col]      # 랜덤으로 뽑은 100개의 트레이닝 셋
iris_test <- iris[-s,col]       # 나머지 테스트 셋

# 리니어 커널방식으로 트레이닝 셋을 종류별로 모델링한다.
iris_svm <- svm(Species ~. , data=iris_train, cost=1,kernel ="linear")
plot(iris_svm, iris_train[,col])

# svm로 훈련된 모델과 테스트데이터로 결과예측
p<- predict(iris_svm,iris_test[,col],type="class")
plot(p)
table(p, iris_test[,3])
mean( p == iris_test[,3])







■  실습2 : 광학식 문자 인식 ---- 1. Data set : letterdata.csv
# 각 글자모양의 속성들을 수치화 한 데이터
# 데이터 읽기와 구조
letters <- read.csv("letterdata.csv")
str(letters)

# 훈련 데이터와 테스터 데이터 구분
letters_train <- letters[1:16000, ]
letters_test  <- letters[16001:20000, ]
## 3단계 : 데이터로 모델 훈련 ----
# 단순 선형 SVM을 훈련으로 시작
install.packages(“kernlab”)
library(kernlab)
letter_classifier <- ksvm(letter ~ ., data = letters_train, kernel = "vanilladot")
# 모델에 대한 기본 정보 확인
letter_classifier


## 4단계 : 모델 성능 평가 ----
# 테스트 데이터셋에 대한 예측
letter_predictions <- predict(letter_classifier, letters_test)

head(letter_predictions)

table(letter_predictions, letters_test$letter)

# 일치/불일치 예측을 표시하는 TRUE/FALSE 벡터 생성
agreement <- letter_predictions == letters_test$letter
table(agreement)
prop.table(table(agreement))

## 5단계 : 커널을 바꿔서 모델 성능을 향상시켜보자 ----
## 가우시안 RBF 커널을 사용
##  RBF ? 링크 -> [Radial Basis Function(방사 기저 함수)]
letter_classifier_rbf <- ksvm(letter ~ ., data = letters_train, kernel = "rbfdot")
letter_predictions_rbf <- predict(letter_classifier_rbf, letters_test)

agreement_rbf <- letter_predictions_rbf == letters_test$letter
table(agreement_rbf)
prop.table(table(agreement_rbf))
prop.table(table(agreement))


향상 됐음!

■  실습3 : 산불데이터 forestfires.csv
install.packages("dplyr")
install.packages("kernlab")
install.packages("ROCR")
install.packages("caret")
install.packages("e1071")
library(dplyr)
library(kernlab)
library(ROCR)
library(caret)
library(e1071)

mydata <- read.csv('forestfires.csv',header =T)
hist(mydata$area)
rug(mydata$area)

# area값들을 분석하기 쉽게 변경 log값을 씌워서 y컬럼으로 추가한다.
mydata <- mutate(mydata, y = log(area + 1))

normalise <- function(x) {  #정규화함수
  return((x - min(x)) / (max(x) - min(x))) }
 
#분석할 값들을 정규화한다.
mydata$temp <- normalise(mydata$temp)
mydata$rain <- normalise(mydata$rain)
mydata$RH <- normalise(mydata$RH)
mydata$wind <- normalise(mydata$wind)

#산불 넓이가 5헥타르 이상인 것을 large 아니면 small로 놓고 분석한다.
mydata$size <- factor(ifelse(mydata$y< 2, 1, 0),
                       labels = c("large", "small"))
#tail(mydata[, c("size", "area")]) 
train <- sample(x = nrow(mydata), size = 400, replace = FALSE)
# 각 커널 방식 비교
# polydot커널 방식으로 svm
m.poly <- ksvm(size ~ temp + RH + wind + rain,
          data = mydata[train, ],
          kernel = "polydot", C = 1)

pred <- predict(m.poly, newdata = mydata[-train, ], type = "response")
 
table(pred, mydata[-train, "size"])
mean(pred == mydata[-train, "size"])


# tanhdot 커널 방식으로 svm
m.tan <- ksvm(size ~ temp + RH + wind + rain,
          data = mydata[train, ],
          kernel = "tanhdot", C = 1)

pred <- predict(m.tan, newdata = mydata[-train, ], type = "response")
 
table(pred, mydata[-train, "size"])
mean(pred == mydata[-train, "size"])


# rbfdot 커널 방식으로 svm
m.rad <- ksvm(size ~ temp + RH + wind + rain,
          data = mydata[train, ],
          kernel = "rbfdot", C = 1)
pred <- predict(m.rad, newdata = mydata[-train, ], type = "response")
 
table(pred, mydata[-train, "size"])
mean(pred == mydata[-train, "size"])

공부한 내용을 정리한 블로그 입니다.



ㅁ■ 객체와 클래스 (가장 중요한 단원) 

  • 9장 목차
  1. 객체와 클래스
  2. 클래스의 정의
  3. __init__() 메소드를 이용한 초기화작ㅇ업
  4. self에 대한 이해 
  5. 정적 메소드와 클래스 메소드 
  6. 클래스 내부에게만 ㅇ려려있는 프라이빗 멤버
  7. 상속
  8. 오버라이딩
  9. __call()__ 메소드 
  10. for문으로 순회를 할 히 있는 객체 만들기 
  11. 추상기반 클래스 
■ 9.1 객체와 클래스
객체(object) = 속성(attribute) + 기능 
    자동차          ↑            ↑
               자동차 색깔  전진, 후진,좌회전,우회전
               바퀴의 크기

코드로 구현을 하면 ? 

객체      =      변수      +      함수 

예제 :
class Car
     def __init__(self):
          self.color =0xFF0000 # 자동차의 색
          self.whell_size = 16
          self.displacement = 2000 # 엔진 배기량 


     def forward(self) : # 전진하는 기능
          pass
     def backward(self) : # 후진하는 기능
          pass
     def turn_right(self): # 우회전 하는 기능 
          pass

     def turn_left(self): #좌회전 하는 기능
          pass

if __name__ == '__main__' : # 메인 모듈일때만 아래의 스크립트를 실행해라

     my_car = Car() # 클래스를 가지고 인스턴스화 하는 코드
                    # Car() 클래스로 my_car라는 객체를 생성했다. 

     print('0x{:02X}'.format(my_car.color))
     print(my_car.whell_size))
     print(my_car.displacement)

     my_car.forward()                    # my_car 의 메소드(기능) 를 호출 
     my_car.backward()
     my_car.turn_left()
     my_car.turn_right()

■ 9.2. 클래스의 정의 


     클래스(자료형) ----> 객체(변수) 

     위의 클래스는 자료형이고 아직 객체가 되지 않았다
                    붕어빵 틀     붕어빵 (인스턴스, 실체라고 얘기함) 
                    (속성: 붕어빵 색
                           붕어빵 앙금(팥, 슈크림)

                     기능: 왼쪽으로 가라 오른쪽으로 가라 
     my_car = Car()           # Car() 클래스에 의해서 my_car라는 객체가 생성됨 인스턴스화 됨


객체 = 속성 + 기능 
      (변수)  (함수)
 
  • 코드 설명 :
     
    def __init__(self): 

1. __init__ ? 객체가 생성될때 호출되는 메소드로서 객체의 초기화를 담당한다
2.self      ? 메소드의 첫번째 매개변수로 객체 자신임을 나타냄 
3.my_car = Car() ? car() 생성자는 car 클래스의 인스턴스를 생성하여 반환한다. 
   ↑         
 인스턴스    생성자
   (실체)    (설계도)


■ 9.3 __init__() 메소드를 이용한 초기화 

클래스의 생성자가 호출이되면 내부적으로 두개의 메소드가 호출된다.
  1. __new__()   : 클래스의 인스턴스를 만드는 역할 ( 내부적으로 자동으로 호출된다.)
  2. __init__()  : 객체가 생성될  대 객체를 초기화하는 역할 
  • 만약 __init__() 메소드를 클래스 생성할 때 지정안하며 ㄴ어떻게 되는지 테스트 

1.__init__() 메소드를 지정 안 했을때

class ClassVar:
     text_list = [] # 클래스의 정의 싷점에서 바로 메모리에 할당됨 
     
     def add(self,text):
          self.text_list.append(text) 

     def print_list(self):
          print(self.text_list)

if __name__ == '__main__':
     a = ClassVar()

ㅁ■ 객체와 클래스 (가장 중요한 단원) 

  • 9장 목차
  1. 객체와 클래스
  2. 클래스의 정의
  3. __init__() 메소드를 이용한 초기화작ㅇ업
  4. self에 대한 이해 
  5. 정적 메소드와 클래스 메소드 
  6. 클래스 내부에게만 ㅇ려려있는 프라이빗 멤버
  7. 상속
  8. 오버라이딩
  9. __call()__ 메소드 
  10. for문으로 순회를 할 히 있는 객체 만들기 
  11. 추상기반 클래스 


9.4 self 에 대한 이해 
" 클래스에서 사용하는 최도 매개변수인데 self는 자기 자신을 가리킨다"

9.5 정적 메소드와 클래스 메소드 
1.인스턴스 메소드   : 로봇의 팔이 잘 작동하는지 로봇을 만들어노혹 작동해 보면 확이하는 메소드
2.클래스(정적) 메소드 : 로봇의 팔이 잘 작동하느니즈이 확인을 로봇을 만들지 않고 어떻게 하면 로봇팔이 움진인다는                     프로그램 코드를 실행히셬 확인하는 메소드 



class Calculator:
    @staticmethod
    def plus(a, b):
        return a+b

    @staticmethod
    def minus(a, b):
        return a-b

    @staticmethod
    def multiply(a, b):
        return a*b

    @staticmethod        
    def divide(a, b):
        return a/b
        
if __name__ == '__main__':        
    print("{0} + {1} = {2}".format(7, 4, Calculator.plus(7, 4)))
    print("{0} - {1} = {2}".format(7, 4, Calculator.minus(7, 4)))
    print("{0} * {1} = {2}".format(7, 4, Calculator.multiply(7, 4)))
    print("{0} / {1} = {2}".format(7, 4, Calculator.divide(7, 4)))



■ 어제 배웠던 내용 복습

   1. 클래스 와 객체
   (붕어빵틀)  (붕어빵)

      객체의 구성요소 2가지
      1. 속성(변수)
      2. 기능(함수)



   class gorilla   class pingpong
   속성: 고릴라 색깔   공과 판의 색깔, 위치
   기능: 고릴라 기능   좌로 이동, 우로 이동
   gorilla() = gorilla() -----> 생성자   pingpoing = pingpoing()

   2. 객체를 초기화 해주기 위해서 필요한 키워드, 메소드?

         self, __init__


■ 9.6 클래스 내부에게만 열려있는 프라이빗 멤버(pg200)

* 파이썬에서 사용하는 멤버 2가지

   1. public member : 클래스 안에서든 밖에서든 접근 가능 한 멤버

     예: 접두사가 두개의 밑줄이고 접미사도 두개의 밑줄이면
   __number__

   2. private member : 클래스 안에서만 접근 가능한 멤버
            클래스의 사생활을 지켜줘야할 때 요긴하게 사용됨

     예: 접두사가 두개의 밑줄이고 접미사는 없거나 하나의 밑줄

   __number
   __number_



6. 클래스 내부에게만 열려있는 프라이빗 멤버
      ○ 파이썬에서 사용하는 멤버 2가지
         i. public member - 클래스 안에서든 밖에서든 접근 가능한 멤버
            □ 접두사가 두개의 밑줄이고 접미사도 두개의 밑줄이면 퍼블릭 멤버, __number__

         ii. private member - 클래스 안에서만 접근 가능한 멤버, 클래스의 사생활을 지켜줘야할 때 요긴함
            □ 접두사가 두개의 밑줄이고 접미사는 없거나 하나의 밑줄, __number_ / __number

   • 예제 - 퍼블릭 멤버로 사용했을 경우

           class yourclass:
               pass

           class myclass:
               def __init__(self):
                   self.message = "Hello"

               def some_method(self):
                   print(self.message)

           obj = myclass()
           obj.some_method()  #메소드를 실행했기 때문에 출력이 된 것, 객체명.기능 --> 실행
           print(obj.message)  #따로 message라는 변수의 내용을 출력, print해서 본 것


   • 예제 - 프라이빗 멤버로 사용했을 경우

           class yourclass:
               pass

           class myclass:
               def __init__(self):
                   self.message = "Hello"
                   self.__private = "private"

               def some_method(self):
                   print(self.message)
                   print(self.__private)

           obj = myclass()
           obj.some_method()
           print(obj.message)
           print(obj.__private)  #프라이빗이라서 에러가 난다.

9.7 상속

   • 상속 : 클래스들끼리 유산(기능) 을 물려주는 것
      클래스  ---------------------------------> 클래스
      부모                  유산(기능)                자식  으로 물려주는 것

   • 상속을 받게 되면 자식 클래스에 부모 기능을 코딩하지 않아도 됨.
      학습시키는 클래스(짝꿍) --------------------------> 나는 핑퐁게임 클래스만 만들고 나머지는 상속 받아서 사용

   • 예제1
      class father :
def base_method(self) :


클래스 부모 ------------------- 클래스 자식 상속

상속을 받게되면 부모의 기능을 굳이 자식 클래스에 코딩하지 않아도 된다.


학습 시키는 클래스 (짝꿍) -------------------------> 나는 핑퐁게임 클래스 
                          머신러닝 기능 유산

예제 1 : 

class father 
     def base_mothod(self) :
          print("hello")

class child(father):
     pass

father = father()

father.base_method()

child = child() 
child.base_method()


예제2. __init__ 메소드를 가지고 실행하는데 부모와는 틀리게 자식에message라는 속성이 없어서 상속을 시키고 싶을때?


class father:
     def __init__(self):
          print("hello~~")
          self.message="Good Morning"

class child(father):
     def __init__(self):
          print("hello~~ I am child")

child = child()
print(child.message) <==========애기는 굿모닝 못하네여





class father:
     def __init__(self):
          print("hello~~")
          self.message="Good Morning"

class child(father):
     def __init__(self):
          father.__init__(self) # 파이썬은 암묵적인 것을 싫어하고 명시적인것을 좋아한다.
          프로그래머가 명시적으로 클래스의 초기화 메소드를 호출해주길 원함
          print("hello~~ I am child")

child = child()
print(child.message)

■ super()

child = child() 
print(child.message)

super() 는 부모클래스의 객체 역할을 하는 내장 함수.
사실상 super() 함수의 반환값을 상위객체로 지정한다 다른 클래스로 교체되거나 수정되어도 파생클래스가
받는 영향을 최소화 할 수 있다. 

class father:
     def __init__(self):
          print("hello~~")
          self.message="Good Morning"

class child(father):
     def __init__(self):
          #father.__init__(self)
          super.__init__()

          print("hello~~ I am child")

child = child()
print(child.message)

■ 다중상속

다중 상속이란 두개 이상의 클래스를 상속 받는것을 말한다
이 경우에는 두 클래스의 모든 속성을 물려받게된다
이는 하나의 자식 클래스가 두개 이상의 부모 클래스를 가지는 것이라고 할 수 있다. 


          father1            father2
               ↘              ↙
                    child
예제 1:

class father1:
     def func(self):
          print("지식")

class father2:
     def func(self):
          print("지혜")

class child(father1,father2):
     def childfunc(self):
father1.func(self)
father2.func(self)

objectchild = child()
objectchild.childfunc()
objectchild.func() # 결과 : 지식 (물려 받은 순서 우선순위 출력 father1 의 지식이 출력된다.)

■ 그런데 둘다 출력하기 싫고 하나만 출력하고 싶어서 

                 grandfather 

                          

          father1            father2

                ↘           ↙

                 grandchild



예제 : 
class grandfather:
     def __init__ (self):
          print("튼튼한 두팔")

class father1(grandfather):
     def __init__ (self):
          grandfather.__init__(self)
          print("지식")

class father1(grandfather):
     def __init__ (self):
          grandfather.__init__(self)
          print("지혜")

class grandchild(father1, father2):
     def __init__(self):
          father1.__init__(self)
          father2.__init__(self)
          print("난 행복해")

grandchild = grandchild()
결과 :
튼튼한 두팔
지식
튼튼한 두팔
지혜
난 행복해

다이아몬드 상속을 받았더니 그만 팔이 4개가 되어부럿당!

문제166. (점심시간 문제) 다시 팔이 2개가 되게 하시오 

class grandfather:
     def __init__ (self):
          print("튼튼한 두팔")

class father1(grandfather):
     def __init__ (self):
          super().__init__()
          print("지식")

class father2(grandfather):
     def __init__ (self):
          super().__init__()
          print("지혜")

class grandchild(father1, father2):
     def __init__(self):
          super().__init__()
          print("난 행복해")

grandchild = grandchild()




6     클래스내부에게만 열려잇느 프라이빗 멤버
7     상속
8     오버라이딩
9     __call()__메소드
10    for 문으로 순회를 하룻 잇는 객체 만들기
11    추상 기반 클래스

9.6 오버라이딩

~ 보다 우선한다는 뜻이다
부모로 부터 상속받은 메소드를 다시 Override(재정의) 하겠다.

예제: 
class grandfather:
     def __init__(self):
          print("튼튼한 두팔")
class father2(grandfather):
     def __init__(self):
          print("지혜")

father2 = father2()
지혜도 주요지만 건강도 물려받고싶다면
class grandfather:
     def __init__(self):
          print("튼튼한 두팔")
class father2(grandfather):
     def __init__(self):
          super().__init__()
          print("지혜")

father2 = father2()

■ super() 에 대해서?
1.super()를 이용하면 부모클래스의 멤버에 접근을 할 수 있따.
2.super()를 이용하면 부모 클래스 명이 변경되어도 일일이 코드를 고치는 수고를 줄일 수 있다.
3.super()를 이요함녀 죽음의 다이아몬드 상속을 피할 수 있다. 

aa■ 9.6 데코레이터 사용법 
데코레이터의 사전적 의미? 꾸미다
데코레이터는 함 수를 꾸며주는 함수 
데코레이터는 함수의 능력을 확장 시켜준다. 
 
어떤 동작을 수행하기 전에 @ 로 시작하는 키워드를 사용해서 수행한다.

  • 데코레이터의 중요한 2가지 기능
  • 1. 함수를 강력하게 해준다.
  • 2. 공통적으로 사용하는 코드를 쉽게 관리하기 위해서 사용한다


  • 파이썬 함수의 4가지 특징
  • 1. 변수에 할당 할 수 있다.
  • 2. 다른 함수내에서 정의 될 수 있다. 
  • 3. 함수의 인자(매개변수)값으로 전달될 수 있다.
  • 4. 함수의 반환값이 될 수 있다. 


  1. 함수를 !!!  변수에 할당!!!!

def greet(name):
     return "Hello {} ".format(name) 

greet_someone = greet # 함수를 변수에 할당
print(greet_someone("scott")) 

  1. 다른 함수내에서 정의 할수 있어!!!!!
def greet(name):
    def greet_message():
       return 'Hello'
    return "{}  {}".format(greet_message(),name)

print(greet("scott"))

  1. 함수의 인자값으로 전달 될 수 있다!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
예: 
def greet(name):
     return "Hello {}".format(name)

def change_name_greet(func):
     name = "king"
      return func(name)

print( change_name_greet(greet))


  1. 함수의 반환값이 될 수 있다.


def greet (name):
     return "Hello {}".format(name)

 def uppercase (func):
     def wrapper(name):
          result = func(name)
          return result.upper()
     return wrapper

new_greet = uppercase(greet) ("scott")
print(new_greet)
print(new_greet("scott"))
문제167. 이름을 입력하고 함수를 실행하면
          해당하는 사원들의 직업이 소문자로 출력되는 함수를 생성하시오 !

함수1. 이름을 입력했을때 직업이 출력되는 함수 (find_job)
함수2. 문자를 입력했을때 소문자로 출력하는 함수 (lower_case)



def find_job(name):
    import pandas as pd
    emp = pd.DataFrame.from_csv("d:/data/emp.csv")
    job = emp[['job']][emp['ename'] == name].values[0][0]

    return job


def lowercase(func):
    def wrapper(name):
        result = func(name)
        return result.lower()

    return wrapper



new_find_job = lowercase(find_job)

print(new_find_job('SCOTT'))



■ 데코레이터 표현법을 보기전에 먼저 데코레이터와 같은
역할을 하는 함수를 생성

class greet(object):
    current_user = None
    def set_name(self,name): # current_user 라는 변수인 속성은 선언
        if name =='admin': #name 에 admin 이라는 문자를 담고
            self.current_user = name
        else:                  #admin 이 아니라면 권한이 없다는 에러를
            raise Exception("권한이 없네요") #발생시키는 함수

    def get_greeting(self,name): #name 이라는 매개변수에 admin 이
        if name == 'admin':  # 입력이 됬다면
            return "Hello {}".format(self.current_user)

                    #Hello 와 current_user 를 리턴하는
                    #함수


실행방법:

greet = greet()
greet.set_name('admin')
print(greet.get_greeting('admin'))

'Error cuz of object is not callable'

greet = greet()
greet.set_name('scott')
print(greet.get_greeting('scott')) # scott 은 안되거든?

문제168.어드민만 헬로 출력되게하라 

class greet(object):          # current_user 라는 변수인 속성을 선언

     current_user = None     # name에 admin이라는 문자가 들어오면
     def set_naem(self,name):     #current_user 에 admin 이라는 문자를 담고
          if name == 'admin':
               self.currnet_user = name
          else:                #admin이 아니라면 권한이 없다는 에러를 발생시킴
               raise Exception("권한이 없네요")

     def get_greeting(self,name):     # name이라는 매개변수에 admin이 입력되면
          if name == 'admin':
               return "Hello {}".format(self.current_user)
                                       # Hello와 current_user를 리턴하는 함수 
                                       

실행방법 :
greet = greet()
greet.set_name('admin')
print(greet.get_greeting('admin') )


위의 코드에서 중복되는 부분 즉 admin이 맞는지 확인하는 공통적인 코드를 하나의 함수로 만들어서 따로 떼어낼 수 있을 것 같다.



def is_admin(user_name):
     if user_name != 'admin':
          raise Exception("권한이 없다니까요 ")

class greet(object):
     current_user = None
     def set_name(self,name):
         is_admin(name)
         self.current_user = name

     def get_greeting(self,name):
         is_admin(name)
         return "Hello {}".format(self.current_user)

greet = greet()
greet.set_name('admin')
print(greet.get_greeting('admin') )
문제169. 이름을 넣어서 함수를 실행하면 해당 사원의 월급이 출력되게 함수를 생성하는데
     KING 만 월급을 볼 수 있게 하고 KING이 아닌 다른 사원들은 권한이 없다면서 볼 수 없게 에러가 나게 하시오 !

import pandas as pd
def is_admin(user_name):
     if user_name != 'KING' and :
          raise Exception("권한이 없다니까요 ")

class find_sal(object):
     current_user = None
     def set_name(self,name):
         is_admin(name)
         self.current_user = name

     def get_sal(self,name):
         is_admin(name)
         emp = pd.DataFrame.from_csv("d:/data/emp.csv")
         sal= emp[['sal']][emp['ename'] == name].values[0][0]
         return sal

find_sal  = find_sal ()
find_sal.set_name('KING')
print(find_sal.get_sal('KING') )

문제170.위에 is_admin(name) 이라는 함수를 사용해서 코드가 더 좋아졌다 하지만 데코레이터를 이용하면 함수가 더 
     좋아진다. 데코레이터를 써서 구현하시오 

def is_admin(func):
  def wrapper(*arg,**kwargs): # *arg 리스트의 가변 매개변수
                              # **kwargs 딕셔너리 가변 매개변수
    if kwargs.get('name') != 'admin':
        raise Exception("권한이 없다니까요 ")
    return func(*arg,**kwargs)
  return wrapper

class greet(object):
     current_user = None
     @is_admin
     def set_name(self,name):
         self.current_user = name

     @is_admin
     def get_greeting(self,name):
         return "Hello {}".format(self.current_user)

greet = greet()
greet.set_name(name='admin')
print(greet.get_greeting(name='admin') )

문제171. 문제169 코드를 데코레이터 함수를 이용해서 더 좋게 개선시키시오



import pandas as pd
def is_admin(func ):
  def wrapper(*arg,**kwargs): # *arg 리스트의 가변 매개변수
                              # **kwargs 딕셔너리 가변 매개변수
    if kwargs.get('name') != 'KING' :
        raise Exception("권한이 없다니까요 ")
    return func(*arg,**kwargs)
    if arg[1] == 'SCOTT' :
        raise Exception("스콧이당!")
    return func(*arg,**kwargs)
  return wrapper

class find_sal(object):
     current_user = None
     @is_admin
     def set_name(self,name):
         self.current_user = name

     def get_sal(self,name):
         emp = pd.DataFrame.from_csv("d:/data/emp.csv")
         sal= emp[['sal']][emp['ename'] == name].values[0][0]
         return sal

find_sal  = find_sal ()
find_sal.set_name(name = 'KING')
print(find_sal.get_sal(name = 'KING') )



import pandas as pd
def is_admin(func ):
  def wrapper(*arg,**kwargs): # *arg 리스트의 가변 매개변수
                              # **kwargs 딕셔너리 가변 매개변수
    if arg[1] == 'SCOTT' :
        raise Exception("스콧이당!")
    return func(*arg,**kwargs)
    if kwargs.get('name') != 'KING' :
        raise Exception("권한이 없다니까요 ")
    return func(*arg,**kwargs)
  return wrapper

class find_sal(object):
     current_user = None
     @is_admin
     def set_name(self,name):
         self.current_user = name

     @is_admin
     def get_sal(self,name):
         emp = pd.DataFrame.from_csv("d:/data/emp.csv")
         sal= emp[['sal']][emp['ename'] == name].values[0][0]
         return sal
find_sal  = find_sal ()
find_sal.set_name(name = 'KING')
print(find_sal.get_sal('SCOTT') )


객체와 클래스 (가장 중요한 단원) 


■ 어제 배운내용 복습
1. 클래스 멤버 2가지
                    -- public member
                    -- private member
2. 상속
     - 상속이 필요한 이유? 코드를 간결하게 하기위해서
       객체 지향언어를 제대로 활용하는 방법(object -oriented )
          1팀 : 로폿팔 클래스
          2팀 : 로봇다리 클래스
          3팀 : 로봇 몸체 클래스
          4팀 : 로봇 두뇌(인공신경망) 클래스 
          로봇팔에 버그가 있어 개선하는데 다리까지 영향을 끼친다 안돼!
          ==> 결국 유지보수 비용을 줄일수 있다.
          파이썬 (코어) 개발
          파이썬 개발자 중급 400 ~ 600 

  • 객체 (인스턴스)? 리스트 , 튜플, 딕셔너리 처럼 데이터를 다루기 위한 논리적 집합
                              ↓                                 ↓
                데이터를 어떤 형식으로 저장할 건가?    속성(변수)에 데이터를 넣고     
                                                   기능(함수)로 데이터를 다루는 역할


3만건의 영어 단어장 ----- 겨울왕국 스크립트 리스트 --->
       리스트                리스트                  full table scan 
                                                    (100초)

       딕셔너리              딕셔너리                index scan
       key:value            key:value               (1초)

  • 클래스란? 변수 + 기능 으로 구성된 논리적 집합 ! 
     인스턴스? 클래스(설계도) 를 실체화 한것

문제172. gun이라는 인스턴스를 생성하기 위해서 gun() 클래스를 생성하시오
     gun = gun()    # 총 설계도로 총을 실체화 시킴
     gun.charge(10) # 총알 10발 충전
     gun.shoot(3) 
       탕
       탕
       탕 
     7발 남았습니다. 

     gun.print() # 현재 총알이 얼마나 남았습니다. 
     7발 남았습니다. 

class gun:
    def __init__(self):
        self.bu =0
    def print(self):
        print('{} 발 남았습니다.'.format(self.bu))

    def charge(self,n):
        self.bu += n

    def shoot(self,a):
        for i in range(a):
            if self.bu > 0 :
                self.bu -= 1
                print ('탕 !')
            elif self.bu == 0 :
                print('총알이 없습니다')
                break

        print(self) 

gun = gun()    # 총 설계도로 총을 실체화 시킴
gun.charge(10) # 총알 10발 충전
gun.shoot(4)
gun.print()

예제2. 클래스를 사용하는 이유? 

class employee(object) 
  pass

emp_1 = employee()
emp_2 = employee()

예제2. 클래스를 사용하는 이유?

- 딕셔너리를 사용하는 경우

student = {'name': '김인호', 'year':2,'class':3,'student_id':35}

print('{}, {}학년 {}반 {}번'.format(student['name'],student['year'],student['class'],student['student_id']) )

- 클래스를 사용하는 경우 

class student(object):
     def __init__(self,name,year,class_num,student_id):
          self.name = name
          self.year = year
          self.class_num = class_num
          self.student_id = student_id

     def introduce_myself(self):
          return '{}, {}학년 {}반 {}번'.format(self.name, self.year, self.class_num,self.student_id)

student = student('김인호',2,3,35)

print (student.introduce_myself())


문제173. 위의 student 클래스를 다시 실행하는데 self 빼고해라

TypeError: introduce_myself() takes 0 positional arguments but 1 was given

introduce_myself()라는 메소드는 인자값을 안받게 만들어줘놓고 왜 하나를 줬느냐

인스턴스의 메소드를 호출하면 인스턴스 자기 자신인 self가 첫번째 인자로 자동으로 전달되기 때문이다.

def introduce_ myself():  # <-- self가 없습니다.

파이썬에서는 인스턴스의 메소드를 호출함녀 인스턴스 자기자신인 self가 첫번재 인자로 자동으로 전달되므로 
반드시

def introduce_myself(self)  # <=== self를 넣어줘야 한다. 

문제173. 자기 자신이 인스턴스의 메소드에 인자로 전달된다는 것이 어떤것인지 인스턴스를 통하지 않고
바로 클래스 introduce_myself를 직접 호출해서 확인하시오 

class student(object):
     def __init__(self,name,year,class_num,student_id):
          self.name = name
          self.year = year
          self.class_num = class_num
          self.student_id = student_id

     def static introduce_myself(self):
          return '{}, {}학년 {}반 {}번'.format(self.name, self.year,

self.class_num,self.student_id)

student1 = student('김인호',2,3,35)

print (student.introduce_myself())


■  self 를 왜 강조하느냐?

파이썬은 객체함수를 나타낼때 무조건 def(self,x,y)
이렇게 self를 첫번째 인자로 넣어야한다.
자바나 c++에서는 this 를 명시 안해도 되나 파이썬은 강제입니다.
 
■ static method ?
(정적 메소드 ) 

 - self를 매개변수로 받지 않는 메소드
 - 여러 인스터스가 공유해서 사용하는 메소드

  

class gun:
    def __init__(self):
        self.bu =0
    def print(self):
        print('{} 발 남았습니다.'.format(self.bu))

    def charge(self,n):
        self.bu += n

    def shoot(self,a):
        for i in range(a):
            if self.bu > 0 :
                self.bu -= 1
                print ('탕 !')
            elif self.bu == 0 :
                print('총알이 없습니다')
                break

        print(self) 

gun1 = gun()   
gun1.charge(10)
gun1.shoot(4)
gun1.print()

gun2 = gun()   
gun2.charge(10)
gun2.shoot(4)
gun2.print()

설명: gun1 총과 gun2총은 서로 다른 총입니다.
     같은 설계도를 사용했지만 별개의 총이다.
     별개의 총이 맞는지 확인해본다.
print(gun1)
print(gun2)
<__main__.gun object at 0x000000000C497828>
<__main__.gun object at 0x000000000C525D30>

print(gun1.__class__)
print(gun2.__class__)
<class '__main__.gun'>
<class '__main__.gun'>
 
 둘은 다른 메모리 주소값을 가지고 있어서 
같은 클래스를 쓰는 서로 별개의 오브젝트라는 것을 확인함

문제174. gun class 의 메소드들을 static method들로 변경해서 다시 총을 쏘시오 


class gun:

    bu = 0
    @staticmethod
    def charge(n):
        gun.bu += n

    @staticmethod
    def shoot(a):
        for i in range(a):
            if gun.bu > 0 :
                gun.bu -= 1
                print ('탕 !')
            elif gun.bu == 0 :
                print('총알이 없습니다')
                break

    @staticmethod
    def print():
        print('{} 발 남았습니다.'.format(gun.bu))

gun1 = gun()
gun1.charge(10)
gun1.shoot(3)
gun1.print()

gun2 = gun()
gun2.shoot(7)
gun2.print()
결과 :
탕 !
탕 !
탕 !
7 발 남았습니다.
탕 !
탕 !
탕 !
탕 !
탕 !
탕 !
탕 !
0 발 남았습니다.

문제175. static method로 선언한 클래스를 이용해서 인스턴스화한 두개의 총의 쏘는 메소드(shoot) 이 서로 같은 메모리를 쓰는지 다른 메모리를 쓰는지 확인하시오 


  • 9장 목차
  1. 객체와 클래스
  2. 클래스의 정의
  3. __init__() 메소드를 이용한 초기화작ㅇ업
  4. self에 대한 이해 
  5. 정적 메소드와 클래스 메소드 
  6. 클래스 내부에게만 ㅇ려려있는 프라이빗 멤버
  7. 상속
  8. 오버라이딩
  9. __call()__ 메소드 
  10. for문으로 순회를 할 히 있는 객체 만들기 
  11. 추상기반 클래스 


■9.10 마법의 __call__ 메소드

예제:
class sample(object):
     def __init__(self):
          print("전 생성하면 바로 생성이 돼요")

sample = sample()

설명: __init__ 메소드는 인스턴스를 생성하면 바로 실행이 된ㄷ.

예제2 :
class sampel2(object):
     def __call__(self):
          print("인스턴스에 괄호를 붙이면 제가 실행돼요")

sample2 = sample2()
sample()

클래스의 인스턴스를 함수처럼 호출하기 위해서 
클래스의 __call__ 이란느 매직 메소드를 정의했다
이 원리를 이용해서 클래스를 데코레이터로 구현할 수 있다
어제 우리가 데코레이터로 구현한건 클래스가 아니라 함수였다.

■ 클래스를 데코레이터로 구현하는 예제

from functools import wraps

class onlyadmin(obejct):               # 함수에 들어가는 매개변수의 문자열을 받아서
     def __init__(self,func):          # 대문자로 변환해줌
          self.func= func

     def __call__(self,*args,**kwargs):
          name = kwargs.get('name').upper()
          self.func(name)

def greet(name):
     print("Hello {}".format(name) )

greet(name = 'Scott')
결과 : Hello Scott

문제176. 위의 onlyadmin 데코레이터를 활용해서 find_job이라는 함수를 강력하게 하시오 ! 
find_job(name= 'scott')

당신의 직업은 ANALYST 입니다.



from functools import wraps
import pandas as pd

class OnlyAdmin(object):
    def __init__(self, func):  # 대문자로 변환해주며 함수를 실행해주는 클래스
        self.func = func

    def __call__(self, *args, **kwargs):
        name = kwargs.get('name').upper()
        return self.func(name)

@OnlyAdmin
def find_job(name):

    emp = pd.DataFrame.from_csv('d:/data/emp.csv')

    job = emp[['job']][emp['ename'] == name].values[0][0]
    return job


find_job(name='SCOTT')



  • 9장 목차
  1. 객체와 클래스
  2. 클래스의 정의
  3. __init__() 메소드를 이용한 초기화작ㅇ업
  4. self에 대한 이해 
  5. 정적 메소드와 클래스 메소드 
  6. 클래스 내부에게만 ㅇ려려있는 프라이빗 멤버
  7. 상속
  8. 오버라이딩
  9. __call()__ 메소드 
  10. for문으로 순회를 할 히 있는 객체 만들기 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  11. 추상기반 클래스 

■ 9.11 for 문으로 순회를 할 수 잇는 객체 만들기

Iterator 는 next() 메소드로 데이터를 순차적으로 호출하는 object이다. 

예제 :
for i in range(5) :
     print(i) 

우리가 당연하게 사용했던 위와 같은 for 문은 사실 range() 로 생성된 list 가 iterable 하기 때문에 순차적으로
member 들을 불러서 사용이 가능했던 것이다.

x = [1,2,3]
next(x)


■ 9.12 추상 기반 클래스 

상속일나 클래스의 재사용을 높임으로써
  1. 코드의 반복을 줄이고
  2. 유지보수 비용을 낮추는데 큰 역할을 한다

이러한 상속과 함께 객체지향(object-oriendted) 프로그램의 가장 중요한 특징중 하나가 다형성이다

다형성이란 클래스에 선언된 메서드가 상속 받은 클래스에서 같은 이름으로 
오버라이딩 되어 여러 형태로 동작함을 의미한다. 
예 :                동물 

               메소드 : 짓는다 (비어있는 메소드)
               ↙                        ↘
          고양이                         개

     짖는다 메소드 : 야옹               짖는다 메소드 : 멍멍 



                    동물   <--- 아직 덜 구체화된 상태 --> 그래서 객체화 시키기에는
                ↙          ↘
               고양이        개 <---- 구체화 된 상태

동물 넌 너무 추상적이야 그러니 너는 객체를 만들지마
!

그래서 추상 클래는 상속을 위해서 필요하긴 하지만 개체화해서는 안되는 클래스

추상 클래스는 추상 메소드가 있는 클래스를 말한다
추상 메소드는 바디(내용)가 없는 메소드이다.

추상 클래스를 상속 받는 자식 클래스에서 반드시 지켜줘야 할 사항은 ?

추상 클래스내에는 추상 메소드와 일반 메소드들이 있을 텐데 
그중에 추상 메소드는 반드시 가져와서 오버라이드 해야한다.

예제: 

from abc import ABCMeta, abstractmethod # 파이썬은 추상 클래스를 제공하지 않아서 import받아야한다.


class animal(object):

__metaclss__ = ABCMeta # 추상 클래스로 선언
@abstractmethod # 추상 메소드 선언
def bark(self):
     pass # 비어있는 메소드, 상속받는 자식들이 반드시 구현해야 하는 중요한 메서드

class cat(animal):

def __init__(self):
     self.sound = '야옹'


def bark(self):
     return self.sound


class dog (animal) :

def __init__(self):
     self.sound = '멍멍'
def bark(self) :
     return self.sound

cat = cat()

dog = dog()


print(cat.bark())

print(dog.bark())




문제177. 음료(beverage) 라는 추상클래스 생성하고
          아메리카노(americano)와 카페라떼 (caffelatte) 클래스를
          자식 클래스로 생성하시오 
          
          추상 클래스를  통해서 반드시 구현해야 하는 데메소드는 음료 가격임 












'PYTHON' 카테고리의 다른 글

English stopword , 영어 불용어  (0) 2018.09.18
gcp를 이용해서 jupyter notebook / jupyter lab 서버 만들기  (0) 2018.08.27
8장. 모듈  (0) 2017.09.10
7장. 함수  (0) 2017.09.10
6장. if 문과 loop문 (p126)  (0) 2017.09.10

8장. 모듈

PYTHON2017. 9. 10. 00:43
8장 모듈
- 모듈이란?
- import 사용법
- 모듈 찾는방법
■8장 목차

  1. 모듈이란. ?          : 함수 생성한 것들을 모아놓은 스크립트
  2. import사용법         : 다른 모듈내의 코드에 접근 가능하게 하는 명령어
  3. 모듈찾는방법         : sys.path의 내용을 출력해서 파이썬이 어떻게 모듈을 탐색해 나가는지 확인
  4. 메인모듈과 하위모듈  : 오늘 부터 !배울 내용
  5. 패키지
  6. __init__.py
  7. site - package

■ 8.4 메인 모듈과 하위 모듈 (p 171) 

               파이썬 문법 + 중요한 알고리즘 20가지는 외워버려야 한다.

  1. 코드를 어떻게 만드느냐? 함수 생성, 함수 생성을 한 것을 모아 놓은 모듈
  2. 코드를 어떻게 실행하느냐 ? 메인 모듈 ( 최상위 수준으로 실행되는 스크립트 ) 
                                             예 : 실뭉치의 끝

  • _name_ (내장 전역변수) 를 이용하면 지금 쓰고있느 모듈이 메인 모듈인지 하위 모듈인지 확인할 수 있다.

     메인 모듈: _name_ ---> main 이라고 나오고
     하위 모듈: _name_ ---> 모듈명으로 나온다

예제 : top_level.py 란느 이름으로 저장하고 실행

print('name : {0} '.format(__name__) )

결과 : name : __name__

예제2: sub.py 라는 이름으로저장하고 실행
print("beginning of sub.py...")
print('name : {0}'.format(__name__) ) 
print("end of sub.py...")

먼저 실행하면 결과가 어떻게 나오는가 ?


■ 8.5 패키지 
패키지란 ? 모듈을 모아놓은 디렉토리를 말한다 ( 모듈 꾸러미)

모듈일나? 실행할 함수들을 모아놓은 스크립트

글너데 평범한 디렉토리가 파이썬의 패키ㅣㅈ로 인정 바등려며 ㄴ

__ini__.py 라는 파일이 그 디렉토리 안에 있어야 한다. 

예 : d\python <--- 퍀키지로 인정을 받으려면 ?

__init__.py   <------- 비어있는 문서
calculator.py   <------ 모듈


■ 8.6 _ini_.py 에 대해 (p 175) 

_init_.py 는 보통 비워둡니다 . 이 파일을 손대는 경우는 __all__ 이라는 변수를 조정할 때이다.

__all__ 변수? 패키지로 부터 반입할 모듈의 목록을 정의하기 위해 사용한다

즉 어제 from  패키지 import * 라고 했는데 

이 * 가 패키지 내에 모든 모듈들을 반입하겠다 라는 뜻인데

그 모든 모듈들이 뭐가 있는지 파이썬이 알려며 _ini_.py에 __all__ 변수에 
아래와 같이 명시를 해줘야 한다. 

예: __all__ =['plus_module','minus_module','multiply_modue','divide_module']

  • 실습 : 
  1. d:\python 폴더 아래에 4개의 모듈을 만들어서 저장한다. 
-- plus_module.py로 아래의 스크립트를 저장 


def plus(a,b):
     return a+b

-- minus_module.py로 아래의 스크립트를 저장

def minus(a,b):
     return a-b

-- multiply_module.py로 아래의 스크립트를 저장

def multiply(a,b):
     return a*b

  1. d:\python 폴더 아래에 _ini_.py에 아래의 내용을 저장
__all__ =['plus_module','minus_module','multiply_moduㅣe']
  1. d:\python 폴더의 상위 디렉토리에 cal_test.py라는 이름으로 아래의 스크립트를 저장하고 실행

from python import *

print ( calculator.plus(10,5))
print ( calculator.minus(10,5))


■8.7 site - package 에 대해서 

 site - package 란 파있너 기본 라이브러리 패키지외에 추가적인 패키지를 설치하는 디렉토리이다.

 site - package 디렉토리에 여러가지 소프트웨어가 사용할 공통 모듈을 넣어두면 ㅁ루리적안장소에 구애받지 않고 모듈에  접근하여 반입할 수 있다.

import sys

sys.path
C:\ProgramData\Anaconda30\Lib\site-packages
문제 163. d:\my_loc2라는 디렉토리를 만들고 cal_test.Py 스크립트를 가져다 두고 실행해보세요 

'PYTHON' 카테고리의 다른 글

gcp를 이용해서 jupyter notebook / jupyter lab 서버 만들기  (0) 2018.08.27
9장. 객체와 클래스 (가장 중요한 단원)  (0) 2017.09.10
7장. 함수  (0) 2017.09.10
6장. if 문과 loop문 (p126)  (0) 2017.09.10
1-5장  (0) 2017.09.10