[ Essay - Technology, Essay - Intuition ] Chat GTP시대의 도래와 생각하는 방식에 대해

이미지
올해도 드디어 끝이 보이는 듯 싶다. 최근에 회사의 망년회를 끝내고 이래저래 회식이 늘어나는 듯 하다. 지금 시점에서는 개인적인 스케쥴도 마무리 되었기 때문에 이제는 여유롭게 연말을 즐기며 올해를 마무리 하려고 한다. 비교적 최근에 이사한 곳 근처의 스타벅스가 대학 병원 안에 있고 근처에 공원이 있어서 그런지 개를 대리고 산책하는 노인이나  아이를 동반한 가족이 눈에 띄게 보인다. 꽤나 좋은 곳으로 이사한듯 하다. 개인적으로는 올해 드디어 미루고 미루었던 이직을 하였고  그 이후에 비약적인 성장을 이루었으니  분명 안좋은 일도 있었지만 만족할 수 있는 해를 보내지 않았나 싶다. 내가 도달하려고 하는 곳으로 가려면 아직 갈길이 멀지만  궤도에 오른 것만으로도 큰 성과라면 큰 성과 일 것 이다. 어쨋든 이직하고 많은 일들을 맡게 되었는데 그 과정에서 나는 의도적으로 Chat GTP를 활용하고자 하였고 몇 가지 직감을 얻게 되었는데  이 중 한 가지를 글로 작성하려고 한다. 따라서 올해의 마무리 글은 Chat GTP에 대한 이야기로 마무리 하려고 한다. 서론 불과 약 10년전 IT업계는 원하던 원치 않던간에  한번의 큰 패러다임의 변화를 맞이해야만 했다 바로 아이폰의 등장에 따른 스마트폰의 시대의 도래와  이에 따른 IT업계의 패러다임 변화가 그것이다. 내 기억으로는 아주 격변의 시대였던 걸로 기억하는데 왜냐하면 게임은 물론이고 웹과 백신을 비롯한 모든 솔루션의 변화가 이루어졌다. 이 뿐만 아니라 가볍고 한손의 들어오는 이 디바이스는  그 당시에는 조금 비싸다는 인식이 있었지만  감추려고 해도 감출 수 없는 뛰어난 유용성으로 회의론을 금세 종식시켰고 이에 대한 결과로 어린아이 부터 노인 까지 작은 컴퓨터를 가지게 되었고 이는 당연하게도 IT업계의 전체적인 호황을 가져다주었다.  그리고 질서는 다시 한번 재정렬되었다. 이러한 패러다임의 변화의 증거로 언어 또한 변하게 되었는데...

[ Neural Network, Python ] Python에서 뉴런 네트워크는 어떻게 표현되는가? : 최적화와 라이브러리를 이용한 구현, 클래스 구현


앞선 글에서 
가벼운 이론에 대한 설명,
그리고 단층 퍼셉트론(SLP)와 다층 퍼셉트론(MLP)에 대한 설명과
원시적인 코드 작성 까지 이야기를 나누었다.

다음으로 코드를 조금 정리할 필요가 있다.

왜냐하면, 프로그래밍 특성상
같은 데이터를 담을 변수를 일일이 선언하는 것은
나중에 코드를 수정할 때 시간을 잡아먹는 원인이 되기도 하며,
버그를 낳을 수 있는 리스크 또한 증가하게 된다.

따라서 특히 가중치(Weight) 부분은 손을 볼 필요가 있다.

코드 최적화


사실 최적화라고 해봤자 
그리 대단한 것은 아니다.

단순히 같은 속성을 가지고 있는 데이터들을 
하나의 변수로 묶을 뿐이다.

최적화 할 코드는 이전 포스팅에서 다루었던
다층 퍼셉트론의 예제 코드이다.

해당 코드는 아래와 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
inputs = [315.5]
 
weights11 = [0.30.4-0.7]
weights12 = [0.5-0.33-0.26]
weights13 = [-0.26-0.570.57]
weights14 = [0.7-0.220.43]
 
weights21 = [0.5-0.3-0.20.4]
weights22 = [0.33-0.33-0.340.2]
 
bias1 = 2
 
bias2 = 3
 
h_node = [inputs[0]*weights11[0+ inputs[1]*weights11[1+ inputs[2]*weights11[2]  + bias1,
            inputs[0]*weights12[0+ inputs[1]*weights12[1+ inputs[2]*weights12[2+ bias1,
            inputs[0]*weights13[0+ inputs[1]*weights13[1+ inputs[2]*weights13[2+ bias1,
            inputs[0]*weights14[0+ inputs[1]*weights14[1+ inputs[2]*weights14[2+ bias1]
 
outputs = [h_node[0]*weights21[0+ h_node[1]*weights21[1+ h_node[2]*weights21[2+ h_node[3]*weights21[3+ bias2,
            h_node[0]*weights22[0+ h_node[1]*weights22[1+ h_node[2]*weights22[2+ h_node[3]*weights22[3+ bias2]
 
print(outputs)
cs

나는 위의 코드를 다층 퍼셉트론 아키텍처의 
원형 그대로 최적화 하려고 한다.

최대한 설계 그대로 한다면 
아래와 같은 코드가 나올 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
inputs = [315.5]
 
weights1 = [[0.30.4-0.7],
        [0.5-0.33-0.26],
        [-0.26-0.570.57],
        [0.7-0.220.43]]
 
weights2 = [[0.5-0.3-0.20.4],
            [0.33-0.33-0.340.2]]
 
bias1 = 2
bias2 = 3
 
h_node = [inputs[0]*weights1[0][0+ inputs[1]*weights1[0][1+ inputs[2]*weights1[0][2]  + bias1,
            inputs[0]*weights1[1][0+ inputs[1]*weights1[1][1+ inputs[2]*weights1[1][2+ bias1,
            inputs[0]*weights1[2][0+ inputs[1]*weights1[2][1+ inputs[2]*weights1[2][2+ bias1,
            inputs[0]*weights1[3][0+ inputs[1]*weights1[3][1+ inputs[2]*weights1[3][2+ bias1]
 
outputs = [h_node[0]*weights2[0][0+ h_node[1]*weights2[0][1+ h_node[2]*weights2[0][2+ h_node[3]*weights2[0][3+ bias2,
            h_node[0]*weights2[1][0+ h_node[1]*weights2[1][1+ h_node[2]*weights2[1][2+ h_node[3]*weights2[1][3+ bias2]
 
print(outputs)
cs

나머지 코드는 그대로 가져가고,
원래 W1,W2였던 가중치(Weight) 값들을 하나로 묶었다.

물론 여기서 bias(편향)의 값들도 
하나로 묶어서 리스트 형태로 저장할 수도 있으나, 
위에서도 언급했다시피 나는 
설계 그대로의 최적화를 목표로 했었기 때문에
그대로 두었다.

위의 코드를 실행한다면 아래와 같은 결과가 나온다.


하지만, 이런 방식의 코딩 방식은 매우 불편하다.

왜냐하면,
만약에 Input과 Output의 요소들의 갯수가 
적어지거나 많아질 경우 h_node와 outputs 변수들의 코드를 
모두 수정해야하기 때문이다.

물론 지금의 코드의 경우 매우 간단한 
아키텍처를 구현했기 때문에 조금 귀찮을 정도이지만
일반적으로 사용되어지는 딥 러닝이나 다른 머신 러닝의 경우는 
매우 많은 노드들이 사용되어지기 때문에 
이런 코딩 방식은 매우 부적절하고 
프로젝트 입장에서 보면 퍼포먼스가 매우 떨어진다.

희망적이게도 Python에는 이미 
이에 대한 라이브러리가 존재한다.

바로 numpy라는 라이브러리이다.

Numpy 라이브러리를 이용한 코드 최적화


위에서 코드 최적화를 진행한 바가 있다.

Numpy를 이용하면,
여기서 한 단계 더 최적화를 한 단계 더 진행할 수 있다.

어떻게 본다면 
몇 단계는 더 진행할 수 있다고 볼 수 있을지는 모르겠다.

왜냐하면 매개변수만 정해주면,
매개변수를 내부를 보고 API가 가변적으로 
자동으로 맞춰주기 때문이다.

numpydot이라는 메소드가 이 역할을 완벽히 수행해준다.

numpy를 이용한다면 아래와 같이 최적화가 가능하다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np
 
inputs = [315.5]
 
weights1 = [[0.30.4-0.7],
        [0.5-0.33-0.26],
        [-0.26-0.570.57],
        [0.7-0.220.43]]
 
weights2 = [[0.5-0.3-0.20.4],
            [0.33-0.33-0.340.2]]
 
bias1 = 2
bias2 = 3
 
h_node = np.dot(weights1,inputs) + bias1
 
outputs = np.dot(weights2,h_node) + bias2
 
print(outputs)
cs

위의 코드에서 보이는바와 같이 
h_node와 outputs의 코드가 1줄로 간결하게 표현되는 것을 볼 수 있다.

즉, dot이라는 메소드가 정확히 노드 계산을 가변적으로 
매우 편리하게 해준다는 것을 확인할 수 있다.

이전 최적화 코드와 
dot메소드를 이용해 최적화 코드를 실행하면 아래와 같은 결과 값이 나온다.


위와 같은 결과 같이 나온다.

클래스로 구현한 다층 퍼셉트론 


위의 코드를 클래스로 구현해
하나의 레이어 별 객체로 가지고 있을 수 있다면 
비록 작은 프로그램이지만 
좀 더 훌륭한 프로그램이 될 수 있을 것이며,
    
Python으로 구현하는 의미가 있을 것 이다.

여러가지 방법이 있을 수 있겠으나 
나의 코드는 아래와 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import numpy as np
 
#랜덤 값 시드 생성
np.random.seed(0)
 
input_data = [315.5]
 
class Layer_Dense:
    def __init__(self, n_inputs, n_neurons):
        #randn : 0으로 중심으로한 가우스 분포를 무작위 생성
        #실제 randn 함수는 1을 초과한 값을 출력하기 때문에 0.10을 곱함
        self.weights = 0.10 * np.random.randn(n_inputs, n_neurons)
        #뉴런 수만 큼 0값을 가지는 편향 생성
        self.biases = np.zeros((1, n_neurons))
    def forward(self, inputs):
        #순방향 전파 수식을 표현
        self.output = np.dot(inputs, self.weights) + self.biases
 
#입력이 3개, 출력 노드가 4개인 레이어 객체 생성
hidden_layer = Layer_Dense(3,4)
#입력이 4개, 출력 노드가 2개인 레이어 객체 생성
output_layer = Layer_Dense(4,2)
 
#히든 레이어의 노드 값 계산
hidden_layer.forward(input_data)
#히든 레이어의 노드 값을 기반으로 출력 값 산출
output_layer.forward(hidden_layer.output)
print(output_layer.output)
cs

Layer_Dense라는 클래스를 생성해


Layer_Dense라는 클래스를 생성해
매개변수로 입력 데이터의 수와 출력할 노드의 수를 받아
생성자에 이를 통해 가중치 값들을 무작위로 얻고,
편향을 0로 초기화 했다. 


또한 해당 레이어의 순방향 전파를 계산하기 위한 
수식도 메소드로 구현 했다.

앞서 구현한 것과 동일한 코드이다.


앞에서 설계한 아키텍처와 같이

3개의 노드를 가지는 입력 레이어와
4개의 노드를 가지는 히든 레이어
마지막으로 2개의 노드를 가지는 출력 레이어가 되도록 
히든 레이어와 출력 레이어를 객체로 만들었다.


그 다음 입력 레이어의 값으로 
히든 레이어의 값을 산출하고,

산출한 히든 레이어의 값으로
이 프로그램으로 얻고자하는 
출력 레이어의 값을 산출 할 수 있다.

코드를 실행해보면 아래와 같은 결과 값이 나온다.


물론 가중치 값은 numpy에서 제공하는 
무작위 값을 얻을 수 있는 메소드를 사용했기 때문에

매번 값은 다를 수 있다.

마치며


지금 까지 해서 간단한 코드 최적화와 
Numpy 라이브러리를 이용해 간단한 다층 퍼셉트론 구현에 대한 
이야기를 해보았다.

퍼셉트론의 계산식은 노드 수에 따라 
히든 레이어의 개수에 따라 달라질 수 있기 때문에
일일이 코딩하는 것이 매우 번거로우나 
(유지・보수면에서 봐도 마찬가지이다.)

Python의 Numpy 라이브러리가 
이를 가변적으로 대응해주기 때문에 
단 한 줄로 코드를 작성할 수 있게 되었다. 

물론 이걸로 완성된 것은 전혀 아니다.

여기에 활성화 함수를 추가해야 하고,
역전파 또한 구현되어야만 한다. 



이 블로그의 인기 게시물

[ Web ] 웹 애플리케이션 아키텍처 (Web Application Architecture)

[ Web ] 서버 사이드(Sever Side) ? 클라이언트 사이드(Client Side)? 1 [서론, 클라이언트 사이드(Client Side)]

[ Web ] 웹 애플리케이션 서버 아키텍처의 정의 및 유형 ( Define and Types of Web Application Server Architecture )