헬스쟁이 프로그래머

python의 내장함수를 사용할때 매우 유용하다.

def plus_on(arr):
    return arr+1

a=[1,2,3]

#정의한 함수 사용
print(list(map(plus_on,a)))
출력 : [2,3,4]

#함수 없이 람다 사용
print(list(map(lambda x: x + 2, a)))
출력 : [3,4,5]

#간단한 람다 표현식
plus_two = lamnda x: x+2
print(plus_two(1))
출력 : 3

#1x3 행렬 만들기
a=[0] * 3
print(a)
#출력 : [0,0,0]

#3x3 행렬 만들기
b = [[0] * 3 for  _ in range(3)]]
print(b)
#출력 : [[0,0,0],[0,0,0],[0,0,0]]

#3x3 행렬 특정 위치 값 수정 하기
b[1][0] = 2
print(b)
#출력 : [[0,0,0],[2,0,0],[0,0,0]]

#3x3 행렬 출력하기
for x in b:
	print(x)
#출력
[0,0,0]
[2,0,0]
[0,0,0]

for x in b:
	for value in x:
    	print(value, end=' ')
    print()
#출력
0 0 0
2 0 0
0 0 0 

그래프 알고리즘 다룰때 자주 사용한다.

2차원 배열 데이터 처리는 알아두면 매우 유용!

TrainData <X, Y>

Traindata set X 

Traindata set Y

1등

2등

DNN Model (Logistic Regression)

  - Node 구성

- Hidden Layer Activate Function

    ReLU

  - Output Layer Activate Function

     설명 : sigmoid를 통해 output의 결과값을 0~1사이의 값,

             즉 확률로 표현한다.

              ex 0.0  -> 0%

                  0.5  -> 50%

                  1.0  -> 100% 

 - Loss Function

    BCE(Binary Cross Entropy Error)

    설명 : BCE function은 0~1사이의 결과값을 모두 고려한 Loss를 뽑을 수 있다.

            따라서 OutputLayer에는 sigmoid function 또는 softmax function 등 Output vector값이

            정규화되어 있어야 한다. 물론 Pytorch에서는 Sigmoid function + BCE loss function

            을 제공하는 Function이 있으며,

            나는 설계한 아웃풋 레이어에서 이미 Sigmoid가 포함되어있기 때문에 BCE function만 썼다. 

  - Optimization Method

   SGD(Stochastic Gradient Descent)

Code

 - DNN Model   

#Neual Netrok nn.Module 상속 
class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.l1 = nn.Linear(8,16)
        self.l2 = nn.Linear(16,32)
        self.l3 = nn.Linear(32,64)          
        self.l4 = nn.Linear(64,32)
        self.l5 = nn.Linear(32,16)
        
    def forward(self, x):
        
        x = x.float()
        h1 = F.relu(self.l1(x))
        h2 = F.relu(self.l2(h1))
        h3 = F.relu(self.l3(h2))   
        h4 = F.relu(self.l4(h3))   
        h5 = F.sigmoid(self.l5(h4))    
       
        return h5

 - Train function

#학습 함수    
def train(epochcount, train_loader, validation_loader, aryofLoss, nShowInterval):
       
    running_loss = 0.0        
    
    #traind_loader로 부터 데이터를 랜덤으로 가져온다.          
    for i, data in enumerate(train_loader):
    
    	#i : trn_loader index, data : set <inputs, labes>         
        inputs, labels = data  
        
         #모델 훈련 모드로 전환
        model.train(True)
        
        #최적화 함수 초기화
        optimizer.zero_grad()
           
        #모델 유추 시작
        output = model(inputs)
        
        #추론 결과 손실 값 취득                
        #오차 output, labels 
        test_loss = criterion(output, labels.float())
                              
        #오차 역전파
        test_loss.backward()
        optimizer.step()
                                   
        #오차 값 표기
        lossValue = test_loss.item()
        running_loss += lossValue
        
        
        #nShowInterval번 순회시 누적 train loss 상태 보여주고, Validation 체크 하기
        if i % nShowInterval == (nShowInterval - 1):    # print every 2000 mini-batches
            aryoftempLoss = []
            print('[%d, %5d] loss: %.3f' %(epochcount + 1, i + 1, running_loss / nShowInterval))
            aryoftempLoss.append(running_loss/nShowInterval)
            aryofLoss.append(artoftempLoss)
            running_loss = 0.0
            validationRunning_loss= 0.0
            
            #validation 체크 구간
            for valindex, valdata in enumerate(validation_loader):
                validationinputs, validationlabels = valdata 
                
                #모델 테스트 모드로 전환
                model.train(False)                               
                validationoutput = model(validationinputs) 
        
                #오차 output, labels 
                validationloss = criterion(validationoutput, validationlabels.float())
                          
                validationlossValue = validationloss.item()
                validationRunning_loss += validationlossValue
            
            #validation loss 저장
            validationTempLoss = []
            validationSize = len(validation_loader)
            validationRunning_loss /= validationSize
            validationTempLoss.append(validationRunning_loss)
            aryofValidationLoss.append(validationTempLoss)
            print('Validationloss: %.3f' %(validationRunning_loss))               

 - Test function

#테스트 함수    
def test(log_interval, model, test_loader, aryofModelInfo):
    
    #모델 테스트 모드로 전환
    model.eval()
    
    #Test loss 수집용
    test_loss = 0
    
    #correct rate 수집용
    correct = 0
    
    with torch.no_grad():
        for data, target in test_loader:
                      
            #추론 시작
            output = model(data)
                        
            #오차 output, labels 
            test_loss += criterion(output, target.float())
                       
            target1 = target[0][0:8]
            target2 = target[0][8:16]
            
            output1 = output[0][0:8]
            output2 = output[0][8:16]
            
            #추론 결과 직접 비교
            if torch.max(target1,0)[1] == torch.max(output1,0)[1] and torch.max(target2,0)[1] == torch.max(output2,0)[1]:
                correct += 1

    
    #추론 결과 평균 수집
    test_loss /= len(test_loader.dataset)

    #추론 결과 보여줌
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format
          (test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))
    
    aryOfTempInfo = []
    aryOfTempInfo.append(test_loss.item())
    aryOfTempInfo.append(correct)
    aryOfTempInfo.append(100. * correct / len(test_loader.dataset))
    aryofModelInfo.append(artOfTempInfo)
   

 - Save Model

modelPath = "./model"
createFolder(modelPath)   
MakeCSVFile(modelPath, "ModelLossInfo.csv", ["Loss"], aryofLoss)
MakeCSVFile(modelPath, "ModelValidationLossInfo.csv", ["Validation Loss"], aryofValidationLoss)
MakeCSVFile(modelPath, "ModelSpec.csv",["Average Loss","Correct","Accracy"],aryofModelInfo)
torch.save(model, modelPath + '/model.pt')    

Simulation

개인적인 의견

 두 번째로 모델링 한 DNN Model이다. 간단한 1등 찾기 모델은 쉽게 구현했으나, Classification 분야에서 Multi Classification 분야로 활용하는 부분을 구현하기 위해 Output layer의 활성화 함수 그리고 Loss function을 선정하는 부분이 제일 힘들었다. Loss function은 10분쯤 생각해봐야 하는 공식이다. 어찌 보면 당연한 공식이지만 왜 당연한지 생각해 봐야 한다. 그리고 생각보다 걱정했던 오버 피팅 문제는 없었다. 왜 없었을까..? 서적에서 참고 했을때는 모델의 복잡도와 데이터의 수의 관계에 따라 오버피팅 문제가 생길 수 있다고 했는데 흠.. 아직 이런 부분은 센스가 부족한 것 같다.

추가로 공부해야 할 부분 : Chain rule, Backpropagation, Bias & Variance, Optimization issue

1. 원하는 인덱스 범위 출력하기

a = list(range(0,10)) # list생성 [0,1,2,3,4,5,6,7,8,9]
print(a[:3])	      # list 0 ~ 2 인덱스 출력
print(a[1:3])         # list 1 ~ 2 인덱스 출력

2. 반복문 활용 방법

a = list(range(0,10)) # list생성 [0,1,2,3,4,5,6,7,8,9]

for i in range(len(a)):# i는 0~9까지 순환
	print(a[i])
    
for i in a:            # i에게 값 타입 반환 value
	print(i)
    
for i in enumerate(a): # i에게 튜플 타입 반환 (index, value)
    print(i)
    
for index, value in enumerate(a): # index에게 a의 index 반환, value에게 a의 value값 반환
    print(index, value)
    
isOver = all(11>x for x in a)    # list a의 값이 모두 11을 넘기지 못하므로 True 반환
isUnder = all(11<x for x in a)    # list a의 값이 모두 11을 넘기지 못하므로 False 반환

3. 값 변경

a = list(range(0,10)) # list생성 [0,1,2,3,4,5,6,7,8,9]

a[0] = 2              # list변경 [2,1,2,3,4,5,6,7,8,9]

1. 선언

a = list()				# list 생성
b = []					# list 생성
c = [1,2,3]				# 1~10까지의 list 생성
d = list(range(1,11)) 			# 1~10까지의 list 생성

2. 인덱스 접근

a = [1,2]	#list 1~2 생성
print(a[1]) # 2 출력

3. list 끼리 더하기

a = [1,3]	#list 1,3 생성
b = [3,5]   #list 3,5 생성
c = a + b   #list 1,3,3,5 생성

4. list 값 추가 및 제거

a = []	#list 생성

a.append(6) 	# list에 추가 6 저장, list 상태 : 6
a.append(7) 	# list에 추가 7 저장, list 상태 : 6, 7
a.append(8) 	# list에 추가 8 저장, list 상태 : 6, 7, 8
a.append(9) 	# list에 추가 9 저장, list 상태 : 6, 7, 8, 9

a.insert(1,2)	# list 1번 인덱스에 2추가 저장, list 상태 : 6, 2, 7, 8, 9

a.pop()			# list 가장 마지막 인덱스 삭제, list 상태 : 6, 2, 7, 8
a.pop(2)		# list 가장 2번째 인덱스 삭제, list 상태 : 6, 2, 8

a.remove(6)		# list에서 데이터 6 삭제, list 상태 : 2, 8

locateValue = a.index(8) # list에서 데이터가 8인 인덱스 출력, locateValue에 1 저장

a.clear()	#모든 데이터 삭제

5. list 값 통계

a = list(range(1,11))	#list 생성, 1~10 저장

sumvalue = sum(a) #list a에 저장되어있는 1~10까지의 합 저장
maxvalue = max(a)  #list a에 저장되어있는 1~10까지의 최대값 저장
minvalue = min(a)  #list a에 저장되어있는 1~10까지의 최소값 저장

6. list  셔플, 정렬

import random as r #랜덤함수 필요

a = list(range(1,11))	# list 생성, 1~10 저장

r.shuffle(a)		# list a 셔플
a.sort()		# list a 오름차순 정렬
a.sort(reverse=True)	# list a 내림차순 정렬

1. 대문자 변환

msg = "Hello"

#문자열 모두 대문자 출력
print(msg.upper())

2. 소문자 변환

msg = "Hello"

#문자열 모두 소문자 출력
print(msg.lower())

3. 특정 문자 또는 문자열 찾기

msg = "Hello"

#문자의 인덱스 출력
print(msg.find('e'))

#문자열의 시작 인덱스 출력
print(msg.find("el"))

4. 특정 문자 갯수 찾기

msg = "Hello"

#문자열에 문자가 포함한 갯수 출력
print(msg.count('e'))

#문자열에 문자열이 포함한 갯수 출력
print(msg.count("el"))

5. 문자열 자르기

msg = "Hello"

#문자열 자르기 0번 인덱스에서 시작하는 2번 인덱스 이전까지 문자열 출력
print(msg[:2]) 

#문자열 자르기 1번 인덱스에서 시작하는 2번 인덱스 이전까지 문자열 출력
print(msg[1:2])

6. 문자열 길이

msg = "Hello"

#문자열 길이 출력
print(len(msg)) 

7. 문자열 순회 하기

msg = "Hello"

for i in msg:
	print(i) # "Hello 출력"
    
for i in range(len(msg)):
	print(msg[i]) # "Hello 출력"

8. 대문자 또는 소문자 인지 확인하기

msg = "Hello"

for x in msg:
	#대문자 체크
	if x.isupper():
    	print(x)
        
    #소문자 체크
    if x.islower():
        print(x)

9. 알파뱃인 경우 확인하기 (한글도 알파뱃으로 취급함)

msg = "H1e2l3lo123"

for i in msg:
	if i.isalpha():
    	print(i) #Hello 출력                         

10. 해당 문자의 아스키 코드 출력

msg = "Hello"

print(ord(msg[0]))                    

11. 아스키 코드를 문자열로 출력

msg = 65

print(chr(msg))                    

12. 문자열 왼쪽, 가운데, 오른쪽 정렬

s = 'abc'#문자열
n = 7 #문자열 총 길이

print(s.ljust(n)) # >>abc
print(s.center(n))# >>  abc   
print(s.rjust(n)) # >>    abc

"""
반복문을 이용한 문제풀이
 1) 1부터 N까지 홀수출력하기
 2) 1부터 N까지 합 구하기
 3) N의 약수출력하기
"""
n = int(input("-->"))
listofn = []
sum = 0

//1번, 2번문제 동시에 수행
for i in range(1,n+1):
    sum += i
    if i%2!=0:
        print(i)

print("합계 -> " + str(sum))

decreaseN = n
devider = 2

//3번 문제 수행
//감소하는 decreaseN이 1이 아닐때까지 수행 또는 devider가 입력 변수 n의 1/2값 보다 크면 종료
//devider를 1씩 증가하면서 입력 변수 n과 나누고 몪이 0이면 소인수 추가
//devider를 1씩 증가하면서 입력 변수 n과 나누고 몪이 0이 아니면 devider 1 증가
while decreaseN!=1:
    if devider > n/2:
        break
        
    if decreaseN % devider == 0:
        decreaseN /= devider
        listofn.append(devider)
    else:
        devider+=1

print(listofn)