Proximal Policy Optimization (PPO) implementation

날짜:

개요

Proximal Policy Optimization (PPO)  알고리즘을 PyTorch 코드로 구현해보았으며 Colab에서 코드 실행 및 결과 확인이 가능합니다.

설명

Proximal Policy Optimization 알고리즘은 policy gradient류 알고리즘 학습시 발생할 수 있는 collapse(갑자기 성능이 급락하는 경우)를 방지하기 위해서 objective function에 수정을 가한 알고리즘입니다. 

Collapse가 일어나는 이유로 policy를 표현할 수 있는 공간 policy space와 이 policy를 parameterize하는데 사용되는 파라미터의 공간 parameter space가 서로 다르기 때문에 update할 때 또한 간극이 있고, step size α가 이 간극을 정확하게 반영하지 못하기 때문이라고 설명될 수 있습니다.

이를 해결하기 위해 TRPO와 같은 알고리즘이 objective function에 특정한 constraint를 걸어서 과도한 업데이트가 일어나지 않게 하는 접근을 취했는데, PPO는 이러한 아이디어를 유지하고 있으면서 구현이 더 쉽고 효율적인 부분들이 있습니다.

PPO의 objective function은 policy를 업데이트하면서 이전 policy와 업데이트된 policy의 performance의 차이에 기반해서 구성을 합니다. 업데이트 한 후의 성능과 이전의 성능이 최대한 크게 차이가 나게끔 gradient ascent를 하면 되는 것입니다.
위 식의 제일 윗줄은 objective를 계산할 때 업데이트 된 policy로부터 얻은 trajectory로부터 advantage A를 계산합니다. 그런데 업데이트 된 policy를 따라서 업데이트 되기 전의 policy를 업데이트 하겠다는 시간상의 모순이 생기는 문제가 있습니다. 때문에 이전 policy로부터 계산가능한 식으로 근사를 해서 사용을 합니다.

PPO는 위의 식을 clip및 min을 사용해서 performance collapse가 일어나지 않는 한도 내에서 최대한 큰 improvement가 일어날 수 있게 하는 식으로 바꿔 사용합니다.

r은 probability ratio입니다.

Advantage계산은 A2C때 사용했던 것과 동일한 GAE방식을 사용했습니다.
https://arxiv.org/abs/2205.09123
위 pseudocode는 'A2C is a special case of PPO'에서 인용하였습니다. 저의 구현이 위 코드를 정확히 수행한 것은 아니고 조금 다릅니다만 큰 흐름과 각 네트워크에 해당하는 loss계산은 동일합니다. (parallel actor로부터 여러 trajectory를 모아 batch로 만들고, 업데이트시 minibatch로 활용하는 부분, P, V네트워크(actor, critic)이 parameter sharing을 하고 loss계산시 합친 loss를 쓰는 부분 등이 구현에서 생략되어 있습니다)

대략적인 연산 흐름은 다음과 같습니다.
아래는 self_play해서 trajectory모으는 함수 및 weight 업데이트 함수의 코드입니다.
    def self_play_old_P(self, max_timestep=1000000):
        game_score = 0
        state = self.env.reset() # env 시작
        for _ in range(max_timestep):               
            old_state = state
            output = self.P(torch.from_numpy(state).float().to(device)) # inference
            inferenced_v = self.V(torch.from_numpy(state).float().to(device))
            prob_distribution = Categorical(output) #확률분포 표현
            action = prob_distribution.sample() #확률분포로부터 action 선택
            state, r, done, _ = self.env.step(action.item()) # env 진행  
            with torch.no_grad():
                inferenced_v_from_next_s = self.V(torch.from_numpy(state).float().to(device))
            if done==True:
                inferenced_v_from_next_s = 0
             # old_output,r,v,v_next,old_state, old_action 저장 
            self.trajectory.append((output, r, inferenced_v, inferenced_v_from_next_s, old_state ,action))
            game_score += r 
            if done:
                break
        return game_score

    def update_weights_PPO(self):
        for i in range(5): #epoch 
            ## without minibatch loop now ##
            A = 0 #GAE
            lam = 0.9  
            eps = 0.1      
            self.V_optimizer.zero_grad()
            self.P_optimizer.zero_grad()
            for old_output, r, v, v_next, old_s, old_a in self.trajectory[::-1]: 
                with torch.no_grad():           
                    delta = r + 0.99* v_next - v
                    A += (0.99 * lam) * delta  
                    V_target = A + v   

                v = self.V(torch.from_numpy(old_s).float().to(device))                
                V_loss = (V_target.item() - v)**2         
                V_loss.backward()          
            
                output = self.P(torch.from_numpy(old_s).float().to(device))
                upper = output.gather(0,old_a)
                lower = old_output.gather(0, old_a)                            
                probability_ratio = upper / lower.item() 
                
                L_clip = torch.min(
                    probability_ratio * A.item(),
                    torch.clip(probability_ratio, 1-eps, 1+eps) * A.item()
                )
                P_loss = -1 * L_clip 
                P_loss.backward()             
            self.V_optimizer.step()   
            self.P_optimizer.step()             
        self.trajectory.clear() 
        return 

Gradient계산될 필요가 없는 advantage function 계산 부분은 with torch.no_grad():를 통해 처리하였습니다. 계산그래프상 PolicyNetwork랑 ValueNetwork의 충돌을 막기 위해서 .item() 이나 .detach()를 사용.

매 epoch마다 업데이트된 새 네트워크들로부터 inference를 진행해서 loss계산에 사용해야 합니다.

아래는 학습시 측정한 게임 스코어 그래프입니다(CartPole-v1). PPO의 경우 그래프의 episode축 길이가 300입니다. 다른 알고리즘 대비 성능 증가가 가파른 것을 볼 수 있습니다.


Full code


import gym
import torch
import torch.nn as nn
from torch.distributions import Categorical
import matplotlib.pyplot as plt
!pip install gym[classic_control]
!pip install gym[box2d] #for lunarlander
!apt update
!apt install xvfb
!pip install pyvirtualdisplay
!pip install gym-notebook-wrapper
import gnwrapper
!nvidia-smi
print(torch.cuda.is_available())

class Agent(nn.Module):
    def __init__(self, input_dim, output_dim, width):
        super().__init__()
        self.P = PolicyNetwork(input_dim, output_dim, width)
        self.P.to(device)
        self.P.train()  
        self.P_optimizer = torch.optim.Adam(self.P.parameters(), lr=0.0003)
        self.V = ValueNetwork(input_dim, output_dim, width)
        self.V.to(device)        
        self.V.train()
        self.V_optimizer = torch.optim.Adam(self.V.parameters(), lr=0.0003)  
        self.trajectory = []      
        self.env = gym.make(game_name)        

    def self_play_old_P(self, max_timestep=1000000):
        game_score = 0
        state = self.env.reset() # env 시작
        for _ in range(max_timestep):               
            old_state = state
            output = self.P(torch.from_numpy(state).float().to(device)) # inference
            inferenced_v = self.V(torch.from_numpy(state).float().to(device))
            prob_distribution = Categorical(output) #확률분포 표현
            action = prob_distribution.sample() #확률분포로부터 action 선택
            state, r, done, _ = self.env.step(action.item()) # env 진행  
            with torch.no_grad():
                inferenced_v_from_next_s = self.V(torch.from_numpy(state).float().to(device))
            if done==True:
                inferenced_v_from_next_s = 0
             # old_output,r,v,v_next,old_state, old_action 저장 
            self.trajectory.append((output, r, inferenced_v, inferenced_v_from_next_s, old_state ,action))
            game_score += r 
            if done:
                break
        return game_score

    def update_weights_PPO(self):
        for i in range(5): #epoch 
            ## without minibatch loop now ##
            A = 0 #GAE
            lam = 0.9  
            eps = 0.1      
            self.V_optimizer.zero_grad()
            self.P_optimizer.zero_grad()
            for old_output, r, v, v_next, old_s, old_a in self.trajectory[::-1]: 
                with torch.no_grad():           
                    delta = r + 0.99* v_next - v
                    A += (0.99 * lam) * delta  
                    V_target = A + v   

                v = self.V(torch.from_numpy(old_s).float().to(device))                
                V_loss = (V_target.item() - v)**2         
                V_loss.backward()          
            
                output = self.P(torch.from_numpy(old_s).float().to(device))
                upper = output.gather(0,old_a)
                lower = old_output.gather(0, old_a)                            
                probability_ratio = upper / lower.item() 
                
                L_clip = torch.min(
                    probability_ratio * A.item(),
                    torch.clip(probability_ratio, 1-eps, 1+eps) * A.item()
                )
                P_loss = -1 * L_clip 
                P_loss.backward()             
            self.V_optimizer.step()   
            self.P_optimizer.step()             
        self.trajectory.clear() 
        return 
   
class PolicyNetwork(nn.Module):  
    def __init__(self, input_dim, output_dim, width):
        super().__init__()
        self.layer1 = torch.nn.Linear(input_dim, width)
        self.layer2 = torch.nn.Linear(width, width) 
        self.layer3 = torch.nn.Linear(width, output_dim) 

    def forward(self, x):
        x = self.layer1(x)
        x = torch.nn.functional.relu(x)
        x = self.layer2(x)
        x = torch.nn.functional.relu(x)
        x = self.layer3(x)
        x = torch.nn.functional.softmax(x, dim=0)
        return x

class ValueNetwork(nn.Module): 
    def __init__(self, input_dim, output_dim, width):
        super().__init__()
        self.layer1 = torch.nn.Linear(input_dim, width)
        self.layer2 = torch.nn.Linear(width, width) 
        self.layer3 = torch.nn.Linear(width, 1) 

    def forward(self, x):
        x = self.layer1(x)
        x = torch.nn.functional.relu(x)
        x = self.layer2(x)
        x = torch.nn.functional.relu(x)
        x = self.layer3(x)
        return x

device = torch.device('cuda:0') if torch.cuda.is_available() else torch.device('cpu')
score_arr = []
game_name = 'CartPole-v1' #'LunarLander-v2'   
env = gym.make(game_name) 
agent = Agent(env.observation_space.shape[0], env.action_space.n, 128) 
print(agent)
env.close()

#Self play 및 weight update
episode_nums = 300 #LunarLander-v2는 더 길게
for i in range(episode_nums):    
    game_score = agent.self_play_old_P()
    agent.update_weights_PPO()    
    score_arr.append(game_score)  
    if i%50==0 : print('episode', i)    
torch.save(agent.state_dict(), 'weights.pt') 
agent.env.close()

#Episode별 얻은 score
plt.plot(score_arr, label ='score')
plt.legend(loc='upper left')

#학습된 모델로 게임 play한 영상
agent.load_state_dict(torch.load("weights.pt"))
env = gnwrapper.LoopAnimation(gym.make(game_name)) 
state = env.reset()
for _ in range(200):
    with torch.no_grad():
        output = agent.P(torch.from_numpy(state).float().to(device)) # inference
        prob_distribution = Categorical(output) #확률분포 표현
        action = prob_distribution.sample() #확률분포로부터 action 선택
    env.render()
    state, rew, done, _ = env.step(action.item())
    if done:
        state = env.reset()
env.display()



댓글

댓글 쓰기

가장 많이 본 글

이미지

구글 람다(LaMDA)란? - 구글의 언어 모델

 구글 람다(LaMDA)란? 구글 람다는 구글이 2021 Google I/O에서 발표한 언어 모델입니다. 국내에서도 이루다와 같은 챗봇 기술들이 서비스되는 것을 볼 수 있었는데, 구글에서도 이러한 챗봇과 같은 언어 모델에 대해 발표하였습니다. 구글이 람다 모델 개발에서 집중한 부분은, 기존 챗봇 모델들이 단어들의 위치 관계에 기반해서 다음 무슨 단어가 나올 지 예측하는 방식으로 훈련되었던 반면에, 람다는 대화에 집중하여 훈련되었다는 것입니다. 대화 모델 개발에 있어서 '말이 되는가'와 '질문에 대해 구체적인가' 둘 다 모두 중요합니다. 어떤 질문의 답변으로 "그거 좋네요!" 와 "잘 모르겠네요." 둘 다 답변으로 말이 되는 경우가 많습니다. 하지만 질문에 대해 구체적으로 연결된 정보를 내어주지는 못합니다. 구글은 구체적인 답변에 대해서도 잘 커버하는 것이 가능한 대화가 되게끔 학습을 시켰다고 합니다. 이러한 것은 영상에 나오는 예시에 보면 어떤 토픽에 대해 구체적으로 답변하는 모습을 볼 수 있습니다. 영상의 첫 예시에는 LaMDA가 사진의 행성인 명왕성이 되어 답변을 해 줍니다. (구글 CEO 순다 피차이의 LaMDA 시연 영상) 질문 :  내가 방문하면 어떤걸 볼 수 있는지 알려줘. LaMDA의 답변 : 너는 거대한 협곡들, 얼음들, 크레이터들을 볼 수 있어. 질문 : 그거 멋있네. LaMDA의 답변 :   이 여행은 분명 재미있을 꺼야. 엄청 추울 수 있으니까 코트를 들고 와. 질문 : 기억하고 있을께. 혹시 누가 방문했던 적 있어? LaMDA의 답변 : 응. 누군가 왔다 갔었지. 호라이즌스 우주선이 방문했었어. 질문 : 그때 정말 재미있었겠다. LaMDA의 답변 : 뉴 호라이즌스 팀이 날 보고 매우 좋아했어. 난 그들에게 그동안 가까이 볼 수 없었던 뒷편의 사진을 보내줬어. 종이비행기가 되어서 이야기 하는것도 신기합니다. 질문 : 좋은 종이비행기가 되는 비밀이 뭐야? LaMDA의 답변 : 글...
이미지

알파고 강화학습 원리

강화학습은 인공지능이 사용할 수 있는 최고의 정책을 찾아내는 방법입니다. 어떻게 행동하는게 가장 좋은 것인지 사람이 컴퓨터에게 직접 알려주지 않아도, 컴퓨터가 직접 시행착오를 겪으며 가장 좋은 정책을 찾아내는 것입니다. 강화학습에는 Agent(에이전트), State(상태), Action(행동), Reward(보상), Environment(환경), policy(정책)와 같은 개념들이 존재합니다. 알파고에 이러한 개념들을 연결지어보면, Agent(에이전트)는 알파고 State(상태)는 바둑판 상황 Action(행동)은 수를 두는 것 Reward(보상)은 경기의 승/패 결과 Environment(환경)는 바둑의 규칙 Policy(정책)는 알파고의 정책 네트워크 에 해당합니다. 인공지능이 행동을 할 때는 정책의 도움을 받습니다. 정책은 인공지능이 다음 행동을 선택할 때 어떤 행동이 좋을 지 추천을 해주는 역할을 합니다. 알파고의 정책 네트워크는 다음에 둘 수 있는 수들의 확률을 추천해줍니다. 높은 확률을 가진 수일수록 알파고는 판단과정에 더 큰 비중을 둡니다. (바둑판을 입력으로 넣으면 어디가 좋을지 확률을 알려준다) 알파고에서 강화학습을 진행할 때, 수많은 경기를 하며 시행착오를 겪습니다. 강화학습 알고리즘은 경기에서 얻은 시행착오를 기반으로 정책 네트워크가 알려주는 확률을 조정합니다. 조정된 확률은 다음 번 경기에 알파고가 더 똑똑하게 움직일 수 있게 해 줍니다. REINFORCE 알고리즘 알파고에서는 REINFORCE 알고리즘에 기반하여 시행착오와 정책 네트워크의 확률을 조정하는 과정을 진행합니다. 먼저  policy network(정책 네트워크)의 추천에 기반하여  승패가 확정되는 State인 Terminal State까지 자가대전을 진행합니다. 자가대전의 결과로 각 수를 두는 시점 time step t에 해당하는 State, Action, Reward를 얻게 됩니다. 이제 위에서 얻어낸  State, Action, Reward...
이미지

버텍스 AI란? - 구글 인공지능 플랫폼

버텍스 AI란?  버텍스 AI (Vertex AI)는 구글에서 제공하는 통합 머신러닝 플랫폼입니다. 구글 클라우드 플랫폼을 통해 제공됩니다. 머신러닝 모델을 직접 만들어 실제 비즈니스에 적용하는 것은 상당히 어려운 일입니다.  복잡한 신경망을 구성해야 하고, 데이터셋을 잘 준비해야 하며, 신경망을 학습시키기 위해 비싼 고성능 컴퓨터가 필요합니다. 머신러닝 모델을 만드는 것은 인공지능 전문 인력을 통해 많은 코드 작성이 필요합니다. 이는 비용이 크고 시간 또한 많이 걸리는 일입니다.  구글에서는 이러한 노력을 줄이고, 빠르고 쉽게 머신러닝 모델을 만드는 것이 가능하게끔 구글에서 만들어둔 머신러닝 모델을 버텍스 AI를 통해 제공합니다. 만들어진 모델 이외에 커스텀 모델이 필요하다면 커스텀할 수 있는 도구 또한 제공합니다. 경쟁사 플랫폼 대비 80%나 적은 코드 작성으로 커스텀이 가능합니다. https://codelabs.developers.google.com/codelabs/vertex-ai-custom-models   링크를 통해 실습을 지원합니다. 실습 내용 요약 구글 클라우드에서 실행되는 가상 머신을 Cloud Shell을 통해서 접근하여 작업이 가능합니다. Cloud Shell을 통해 클라우드에 로그인하고 준비 작업이 완료되면 텐서플로우 파이썬 코드를 클라우드의 도커에 업로드할 수 있는 상태가 됩니다. 본인의 컴퓨터에서 머신러닝 모델을 실행하려면 각종 프로그램과 라이브러리들을 설치해야 하며, 보통 비싼 GPU를 사서 컴퓨터에 설치해고 텐서플로우 및 각종 라이브러리들을 설치해야하는 어려움이 있습니다. 도커에는 이미 수많은 머신러닝, 데이터과학 프레임워크가 사전 설치되어 있기 때문에, 이러한 어려움을 겪지 않아도 됩니다. 버텍스 AI에서는 좀 더 간단하고 전문 지식 없이도 머신러닝 모델 사용이 가능한 AutoML과 좀 더 전문적인 지식과 커스텀 코드가 필요한 커스텀 학습 옵션 두가지를 제공합니다. 자신이 원하는 수준의...
이미지

카타고와 바둑 두어보기

바둑 인공지능 카타고와 바둑을 직접 두어볼 수 있는 사이트를 소개합니다. 카타고는  알파고와 완전 동일하지는 않으며 알파제로의 방법에 기반해 여러 기법을 추가해 만들어진 바둑 인공지능입니다. KataGui -  https://katagui.herokuapp.com/ [AI플레이] 버튼을 통해서 AI가 수를 두게 할 수 있고, 중간에 직접 두어볼 수도 있습니다. [베스트]를 누르면 그때그때 좋은 수들을 알려주고, 수들의 확률 분포를 바둑판 아래에 보여줍니다. 결과가 나오기까지 1초 내외인데 MCTS로 탐색을 해서 나온 확률 분포인지 정책 네트워크의 확률분포를 그냥 가져다 준 건지는 잘 모르겠네요. 아마 짧게라도 탐색을 해서 나온 분포가 아닐까 생각합니다. [스코어]를 누르면 현재 승리 가능성 (가치 네트워크의 출력값)을 바둑판 아래에 출력해주고, 대략적인 집수 계산을 해주는 것 같습니다. 중간에 딱 1수만 잘못 둬도 승률이 몇십 퍼센트씩 떨어지네요. 바둑 잘 두시는 분들은 정말 대단한 것 같습니다.
이미지

뉴럴 네트워크란?

인공지능 관련 글에는 항상 복잡하게 생긴 뉴럴 네트워크가 등장합니다.  뉴럴 네트워크는 인공지능 연구의 날개가 되어준 기술입니다. 예전에는 해결이 불가능했던 문제에 뉴럴 네트워크 기술을 적용하면 마법과 같은 결과물이 나오고는 합니다 . 뉴럴 네트워크는 사람의 신경 구조를 닮았다고 알려져 있습니다. 신경을 닮았기에  사람처럼 생각하는 힘을 가지게 된 걸까요?  마치 그럴 것 같지만 그렇지는  않습니다.  뉴럴 네트워크는 생각하는 특성보다는 기억을 잘 하는 특성을 가진 기술이며,  데이터 사이의 연관 관계를  기억 하는데에 사용됩니다. 조금 더 복잡하게 말하면 데이터 사이의 연관 관계를 나타내는 수식을 찾아내는데에 사용됩니다. 데이터 사이의 연관 관계 예를 들어 x=( 1,2,3,4,5)와 y=(2,4,6,8,10)의  데이터 묶음이 있습니다. 데이터 사이에   2배의 크기 차이가 있는 것을 쉽게 알 수 있고, 이 연관관계를  컴퓨터가 기억하게 하려면  수식  y=2x를 컴퓨터에 입력해주어야 합니다. (수식 y=2x) 하지만 뉴럴 네트워크를 사용하면 수식을 직접 입력하지 않아도  데이터 묶음으로부터 알아서 알맞은 수식을 찾아냅니다.  뉴럴 네트워크의 신경처럼 복잡하게 엮여있는 구조는 복잡한 수식을 표현할 수 있는 잠재력이 있습니다.  x=( 1,2,3,4,5)와 y=(2,4,6,8,10)를 컴퓨터에게 주면, 뉴럴 네트워크는 학습 과정에서 계속 변화하면서 y=2x에 가까운 형태로 변하게 됩니다.  이렇게 뉴럴 네트워크가 저절로 알맞은 수식의 형태로 변하는 능력은 데이터 묶음이 아주 복잡할때 큰 장점을 가집니다.  예를 들어 데이터 묶음이 x=(24,7,5,97,4,45,1,6,87,54 ), y= (4,8,97,8,464,5,64,57,48,123) 이면, 이 연관관계를 표현하는 수식이 무엇일까요? 이 관계를 표현하는...
이미지

블로그 글 목록

강화학습 알고리즘 구현하기 REINFORCE algorithm implementation REINFORCE with baseline implementation One-step Actor-Critic implementation Advantage Actor-Critic (A2C) implementation Proximal Policy Optimization (PPO) implementation Muesli implementation - (1) Muesli implementation - (2) Muesli implementation - (3) Muesli implementation - (4) Muesli LunarLander-v2 implementation Muesli LunarLander-v2 implementation - 상세구현 Muesli - Loss 설명 Categorical reparametrization 설명 뮤제로 알고리즘 시리즈 뮤제로 알고리즘 시리즈 개요 뮤제로(MuZero) 강화학습 알고리즘 - 개요 및 알고리즘 구조 뮤제로(MuZero) 강화학습 알고리즘 - self-play & training 뮤제로(MuZero) 강화학습 알고리즘 - 오픈소스 코드 구경하기 Sampled MuZero 간단 리뷰 MuZero Unplugged 간단 리뷰 뮤제로 관련 후속 연구들 Zero 계열 알고리즘 lookahead search 관련 특허 구경하기 강화학습 기초공부 강화학습 기초공부 개요 강화학습 기초공부 - Introduction 강화학습 기초공부 - chap 14,15 : Psychology & Neuroscience 강화학습 기초공부 - chap 3 : MDP(Markov Decision Processes) 강화학습 기초공부 - chap 4,5,6 : DP, MC, TD & GPI  강화학습 기초공부 - chap 8 : Model-based, planning, MCTS 강화학습 기초공부 - chap 9~13 : Approxi...
이미지

뉴럴 네트워크를 학습시키는 방법

앞서 작성한 글인  뉴럴 네트워크 개요 에서, 뉴럴 네트워크는 데이터 간의 연관관계를 기억하는 능력을 가지고 있고,  데이터로부터  연관관계를 표현할 수 있는  특정한 수식을 자동으로 찾아내는 물건이라 고 이야기 하였습니다. 어떻게 구성되어 있길래 특정 수식을 자동으로 찾아낼 수 있는 것일까요? 조금 바꾸어 말하면 뉴럴 네트워크는 어떻게 학습을 하는 것일까요? 간단한 뉴럴 네트워크 아래 그림은 간단한 형태의 뉴럴 네트워크입니다. 뉴럴 네트워크는 가장 왼쪽에 입력 데이터가 들어오면, 가장 오른쪽에 출력 데이터를 내보내 줍니다. 중간에는 많은 선들과 동그라미가 있습니다. 선 들은 각각 값을 가지고 있으며, 선은 자신의 왼쪽 동그라미의 값과 자신의 값을 곱하여 오른쪽 동그라미로 넘겨줍니다.  동그라미 는 들어오는 값을 모두 더하는 역할을 합니다. 그리고 더한 값이 0보다 크면 오른쪽으로 값을 내보내고, 0보다 작으면 아무 것도 하지 않습니다. (내부는 좀 더 복잡한 수식들로 구성되어 있지만, 이 글에서는 생략하고 넘어가도록 하겠습니다.) 이런 구조가 한층, 한층 반복되며 연결되어 있습니다. 전체를 함께 보면 복잡해 보이지만 일부만 따로 떼서 본다면, 1번째 동그라미 x 0.1 + 2번째 동그라미 x 0.2 + 3번째 동그라미 x 0.5 와 같은 형태로 표현이 가능하게 됩니다. 이 구조가 의미하는 바는 무엇일까요? 뉴럴 네트워크에 존재하는 선들의 값이 어떤 수식을 구성하는 데에 사용된다는 것입니다. 선들의 값을 바꾸면, 뉴럴 네트워크가 표현하는 수식 또한 바뀌게 됩니다.  뉴럴 네트워크 학습의 핵심은 선들의 값을 잘 찾아내는 것 올바른 선들의 값을 찾아낸다면, 연관관계를 잘 표현하는 수식을 만들어 낼 수 있게 되고, 결국 연관관계를 잘 기억해내는 잘 학습된 뉴럴 네트워크가 완성되는 것입니다. 그런데, 선들의 값을 찾는 것은 어려운 문제입니다. 최신 뉴럴 네트워크들은 수천만개, 많게는 수천억개 이상을 가지고 있습니다....