인공신경망 Neural Network #1

이 글의 전체 예제는 https://github.com/Kcrong/basic-neural-network 에 있습니다.

이 글은 http://blog.secmem.org/197 을 참고했으며, 모든 예제를 직접 작성하였습니다.

1. 뉴럴 네트워크란?

컴퓨터 공학에서 뉴럴 네트워크란, 인공지능 분야의 기술로 인간의 뇌 속에 있는 신경을 모델링 하여 문제를 해결하는 방법을 말합니다.

2. 뉴런이란?

뉴런은 신경망을 구성하는 신경세포 한 개를 말합니다.

뉴런 하나는 단순히 전기 신호를 전달하는 역할 밖에 없지만, 이 뉴런이 엄청 모이면 인간의 지능을 가지게 됩니다. (실제 인간은 1000억개의 뉴런을 가지고 있다 합니다.)

뉴런의 동작방식은 다음과 같습니다.

출처: 나무 위키

Cell Body    : 세포체

Nucleus    : 세포핵

Dendrites    : 가지 돌기 (수상 돌기)

Axon            : 축삭

Axon Hillock    : 축삭소구

Axon Ending    : 축삭말단

Myelin sheath    : 말이집

Nodes of Ranvier    : 랑비에 결절

Synapse        :  시냅스

뉴런은 핵을 중심으로 여러 개의 작은 가지 돌기와 한 개의 커다란 축삭이 뻗어 나와 있습니다.

가지 돌기가 다른 뉴런이 보내주는 신호를 전달 받는 곳입니다. (Input) 한 개의 뉴런은 수상 돌기를 통해 1만 ~ 10만 개 정도의 뉴런과 연결되어 있다고 합니다.

축삭 이라고 하는 커다란 돌기가 다른 뉴런에게 신호를 전달하는 역할을 합니다. (Output) 뉴런 당 하나의 축삭을 가지고 있습니다.

가지 돌기와 축삭, 각각 Input 과 Output 을 알아보았는데, 뉴런은 신호를 전달만 하는 것이 아닙니다.

따라서 연산이 가능합니다.

뉴런과 뉴런은 시냅스로 연결되어 있습니다. 시냅스는 전기신호를 화학신호로 바꾸어 전달하게 되는데, 각 시냅스 마다 연결 강도가 달라 이 화학 신호의 강도도 제각각으로 전달되게 됩니다.

뉴런은 다른 뉴런에게 받은 이 신호 강도의 합이 일정한 값 (역치값) 이상이 되면 축삭에 전기신호를 전달합니다.

정리하면,

1. 가지 돌기는 다른 여러 개의 뉴런에게 화학 신호를 받아들인다.

2. 각 연결 부의 화학 신호의 강도 (연결 강도)가 다르다

3. 받아들인 화학신호 강도의 합이 역치값 이상이면 축삭으로 전기신호를 전달한다.

4. 축삭의 전기신호가 다른 뉴런에게 전달된다.

이제 이걸 파이썬 코드로 옮기면 됩니다.

3. 기본 뉴런 만들기

우선 기본 뉴런 클래스를 만듭니다.

class Neuron:
    def __init__(self, name):
        # Private Var
        self._next = list()  # 연결된 다음 뉴런을 저장할 list 변수
        self._weight = dict()  # 가중치 dict 변수
        self.data = None  # 이 뉴런의 데이터 합을 저장할 변수
        self.threshold = 0  # 역치 값 (여기선 0으로 설정)
        if name is None:
            name = randomkey(5)
        self.name = name  # 식별을 위한 이름 설정

    def link_neuron(self, next_neuron, weight=None):
        """
        :param next_neuron: 연결할 뉴런
        :param weight: 연결할 뉴런과의 가중치
        """
        self._next.append(next_neuron)
        if not weight:
            weight = random()
        self._weight[next_neuron] = weight

    def __repr__(self):
        return "<Neuron %s>" % self.data

    def go_next(self):
        if self.data >= self.threshold:  # 역치 값 비교 (역치 값보다 데이터 합이 작으면 다음 뉴런으로 전달하지 않음)
            for next_neuron in self._next:  # 자신과 연결된 모든 뉴런에서
                next_data = self.data * self._weight[next_neuron]  # 전달할 데이터 연산 (가중치 * 자신의 데이터)

                if next_neuron.data:  # 전달할 뉴런의 데이터가 None 이 아니면
                    next_neuron.data += next_data
                else:  # None 일 경우, 전달 데이터로 초기화
                    next_neuron.data = next_data
        else:
            pass

뉴런 네트워크는 연산 속도를 위해 객체 지향으로 작성하는 경우가 적지만, 이해를 위해 객체지향으로 작성해 보았습니다.

4. 결과를 알 수 없는 뉴럴 네트워크 만들어 보기

두 InputNeuron 이 입력을 받고, 이 두 뉴런의 전기 신호 (데이터)를 출력 뉴런이 받는 방식입니다.

우선 Neuron 클래스를 상속받는 InputNeuron, OutputNeuron 클래스를 만듭니다.

class InputNeuron(Neuron):
    all_neuron = list()  # 모든 InputNeuron 객체를 저장할 리스트

    def __init__(self, name=None):
        super().__init__(name)  # 부모 클래스의 생성자 호출 (인자로 받은 name 전달)
        InputNeuron.all_neuron.append(self)  # 객체 생성 시 InputNeuron 클래스의 all_neuron 리스트에 객체 추가

    def __repr__(self):
        return "<InputNeuron %s>" % self.name

    @classmethod
    def set_init_data(cls, data_list):  # 처음 입력 데이터 설정  
        if len(cls.all_neuron) != len(data_list):  # 데이터 길이와 입력 뉴런 길이가 다를 경우 에러
            print("Input Error Diff length")
            return False

        OutputNeuron.reset()  # 출력뉴런의 데이터 초기화

        for neuron, data in zip(cls.all_neuron, data_list):
            neuron.data = data  # 입력뉴런 데이터 초기화

    @classmethod
    def work(cls): # 모든 입력 뉴런 데이터 전달
        for neuron in cls.all_neuron:
            neuron.go_next()


class OutputNeuron(Neuron):
    all_neuron = list()

    def __init__(self, name=None):
        super().__init__(name)
        OutputNeuron.all_neuron.append(self)

    @classmethod
    def reset(cls):  # OutputNeuron 의 데이터 초기화
        for neuron in cls.all_neuron:
            neuron.data = None

    @classmethod
    def get_result(cls):  # OutputNeuron 중에 가장 데이터가 큰 Neuron 을 반환
        return max(cls.all_neuron, key=lambda x: x.data)

    def __repr__(self):
        return "<OutputNeuron %s>" % self.name

입력 뉴런에 들어갈 값은

(0, 0)

(0, 1)

(1, 0)

(1, 1)

이 네 가지 경우로 입력해보도록 하겠습니다.

if __name__ == '__main__':

    # Make Neuron Object list
    # Two Input Neuron (0, 1)
    # Two Output Neuron (0, 1)
    input_neuron_list = [InputNeuron() for i in range(2)]
    output_neuron_list = [OutputNeuron(i) for i in [0, 1]]

    # Link All Neuron
    for input_neuron in input_neuron_list:
        for output_neuron in output_neuron_list:
            # Set Random weight of links
            input_neuron.link_neuron(output_neuron)

    inputdata = [  # 입력할 데이터 생성
        [0, 0],
        [0, 1],
        [1, 0],
        [1, 1]
    ]

    for data in inputdata:
        InputNeuron.set_init_data(data)  # 입력뉴런에 데이터 설정
        InputNeuron.work()  # 다음 뉴런으로 데이터 전달
        result = OutputNeuron.get_result()  # 출력 뉴런 중에 가장 큰 뉴런 결과로 가져옴
        print(data, result)  # 결과 출력

결과:

[0, 0] <OutputNeuron 0>
[0, 1] <OutputNeuron 1>
[1, 0] <OutputNeuron 1>
[1, 1] <OutputNeuron 1>

연결 강도를 모두 랜덤으로 한 탓에 결과를 유추하는 것은 불가능합니다.

또한 실행할 때마다 결과는 달라집니다. 위 결과에서는 1이 3번, 0이 1번 나왔네요

다음 포스팅에서는 뉴런의 동작이 개선된 네트워크를 구성해보고, 스스로 학습을 하게 하는 방법에 대해 다루도록 하겠습니다.