Python에서 객체에 대한 key, value 조회

key, value 자료 구조는 매우 효율적인으로 데이터를 저장하고 빠르게 검색할 수 있는 구조입니다. Python에서도 제공하는 key, value 자료구조는 Javascript와 매우 유사한데요. 예를들어 다음처럼 key와 value를 자유롭게 구성할 수 있습니다.

book = {
    'Boy': (100, 200),
    'Guy': (200, 400),
    'Girl': (300, 150),
    'Woman': (400, 800)
}

총 4개의 요소로 구성되어 있는데.. 각 요소를 순회하면서 조회하기 위한 코드는 다음과 같습니다.

for word, pages in book.items():
    print(word, pages)

위의 실행 결과는 다음과 같습니다.

Boy (100, 200)
Guy (200, 400)
Girl (300, 150)
Woman (400, 800)

앞서 book 변수에 대한 타입명은 dictionary입니다. 이 타입에서 key 요소는 중복될 수 없습니다.

특정 key 값을 갖는 요소를 제거하기 위해서는, 예를들어 key가 ‘Boy’ 인 요소를 제거하기 위한 코드는 다음과 같습니다.

del book['Boy']

또한 특정 키를 가진 요소가 존재하는지에 대한 검사는 다음과 같습니다.

print('Boy' in book)
print('Girl' in book)

앞서 key가 ‘Boy’인 요소는 제거되었으므로, 위의 코드에 대한 결과는 다음과 같습니다.

False
True

Python의 Thread API

Python의 언어적 한계로 Thread 기능의 지원이 적합하진 않다고 하지만, 문제점을 최대한 개선하여 GIL이라는 장치를 통해 지원한다고 합니다. GIL은 Global Interpreter Lock의 약자입니다. 코드는 다음과 같습니다.

import threading

class T(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        pass

    def run(self):
        for i in range(100):
             print(self.name, i)

13번 줄의 코드인 self.name은 Thread-n과 같은 스레드의 내부 이름이며, 여기에서 n은 내부 번호입니다. 앞서 정의한 스레드 T의 사용은 다음과 같습니다.

ts = [T() for i in range(4)]

for t in ts:
    t.start()

총 4개의 스레드를 생성하고 start 매서드를 통해 스레드를 시작합니다.

몬테카를로 방법(Montecarlo Method)

몬테카를로 방법(Monte Carlo method)은 어떤 문제에 대한 해를 무수히 많은 시도를 통해 얻어진 확률을 기반으로 하는 계산법입니다. 아래의 그림은 위키디피아의 몬테카를로에 대한 소개에 나온 이미지로써 원주율 π 값을 구하는 예입니다.

넓이가 1인 정사각형, 이 정사각형 내부에 반지름이 1인 사분원이 있습니다. 그러면 사분원이 차지하는 넓이는 π/4가 될 것이다. 이제 0 이상, 1 이하인 x와 y의 값을 무작위로 뽑은 후 x^2 + y^2 ≤ 1의 조건을 만족할 확률은 사분원의 넓이와 같은 π/4가 됩니다.

위의 논리를 코드로 작성하여 π를 구하면 다음과 같습니다.

import random

n = 1000000 # 백만번의 시도
count = 0

for i in range(n):
    # x, y를 무작위로 0~1사이의 값으로 결정
    x = random.uniform(0, 1)
    y = random.uniform(0, 1)

    # 사분원 내부에 발생하는 경우수 
    if (x**2 + y**2) <= 1: count += 1

# 백만번의 시도 중 사분원 내부일 경우에 대한 확률은 사분원의 넓이이므로 이를 4배 곱하여 π 계산
print('phi', 4*count/n)

위의 코드 중 4*count/n은 다음의 비례식을 통해 도출된 결과입니다.

전체확률 : 사분원 내부일 경우에 대한 확률 = 사각형의 넓이 : 사분원의 넓이

위의 비례식에 수치값을 대입하면 다음과 같습니다.

1 : count/n = 1 : π/4

몬테카를로 방법을 통해 실제와 가까운 해를 얻기 위해서는 방대한 단순 계산을 매우 빠르게 처리할 수 있는 컴퓨터가 필수입니다. 이 몬테카를로 방법은 핵폭탄이나 수소폭탄의 개발에서 핵심적인 역활을 담당했다고 합니다. 제 경우도 핵폭탄 개발이 필요해서... 가 아닌 강화학습(Reinforcement learning)의 한 방법으로 접하게 되었습니다.

신경망을 이용한 비선형 모델의 회귀분석

딥러닝을 위한 신경망은 기본적으로 선형회귀분석을 기반으로 합니다. 선형 회귀 분석이라는 전제 조건은 아주 복잡한 모델, 즉 비선형인 형태의 모델은 추론할 수 없지만, 신경망의 층(Layer)를 깊게 쌓으면서 그 중간에 비선형성을 부여하는 활성화 함수를 넣어주게 되면 선형회귀분석에 기반한 신경망으로도 아주 복잡한 비선형 모델도 추론할 수 있다는 것입니다. 예를 들어, 아래와 같은 분포를 가지는 데이터셋에 대한 회귀분석도 가능합니다.

위의 데이터는 다음과 같은 공식에 대해서, y값에 표준편차 30인 정규분포의 잡음(Noise)를 추가해 생성한 것입니다.

    $$y = 0.5 \times x^{3} - 0.5 \times x^{2} - 90 \times sin(x^{2}) + 1 $$

이제 위의 데이터셋을 이용해 딥러닝 학습을 통해 비선형 모델에 대한 추론에 대한 코드를 정리하겠습니다. 코드는 파이선으로, 그리고 딥러닝 라이브러리는 파이토치를 사용했습니다.

먼저 필요한 패키지를 임포트합니다.

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.init as init
import matplotlib.pyplot as plt

학습을 위해 데이터가 필요한데, 앞서 언급한 공식을 활용하여 총 5000개의 (x, y) 값의 데이터를 생성합니다. 물론 y 값에는 마찬가지로 앞서 언급한 표준편차가 30인 정규분포로 생성된 잡음을 반영합니다. 아래는 이에 대한 코드입니다.

num_data = 5000
noise = init.normal_(torch.FloatTensor(num_data,1), std=30)
x = init.uniform_(torch.Tensor(num_data,1),-10,10)

def func(x): return 0.5*(x**3) - 0.5*(x**2) - torch.sin(2*x)*90 + 1 
y_noise = func(x) + noise

신경망 모델을 생성합니다. 신경망 모델에 대한 코드는 아래와 같습니다.

model = nn.Sequential(
    nn.Linear(1,5),
    nn.LeakyReLU(0.2),
    nn.Linear(5,10),
    nn.LeakyReLU(0.2),
    nn.Linear(10,10),
    nn.LeakyReLU(0.2),    
    nn.Linear(10,10),
    nn.LeakyReLU(0.2),        
    nn.Linear(10,5),
    nn.LeakyReLU(0.2),          
    nn.Linear(5,1),
)

위의 신경망을 도식화하면 다음과 같습니다.

활성화 함수로 Leaky ReLU를 사용한 이유는, Sigmoid의 경우 기울기 소실이 발생하여 학습이 잘이루어지지 않고 일반 ReLU를 사용할 경우 학습 대상이 되는 가중치와 편향이 음수가 될 경우에 입력값까지 음수가 되면 최종 활성화 값이 항상 0이 되어 이 값이 뉴런에 전달되고, 전달 받은 뉴런이 제 역활을 하지 못하는 현상(문헌에서는 Dying Neuron이라고 함)이 발생하기 때문입니다 Leaky ReLU는 기울기 소실 문제와 입력값이 음수일때에도 일반 ReLU처럼 0이 아닌 가중치(위에서는 0.2)가 반영된 값이 활성값으로 결정되어 Dying Neuron 현상을 막아줍니다.

다음은 학습에 대한 코드입니다.

gpu = torch.device('cuda')
loss_func = nn.L1Loss().to(gpu)
optimizer = torch.optim.Adam(model.parameters(), lr=0.002)

model = model.to(gpu)
x = x.to(gpu)
y_noise = y_noise.to(gpu)

num_epoch = 20000
loss_array = []
for epoch in range(num_epoch):
    optimizer.zero_grad()
    output = model(x)
    
    loss = loss_func(output,y_noise)
    loss.backward()
    optimizer.step()
    
    loss_array.append(loss)

    if epoch % 100 == 0:
        print('epoch:', epoch, ' loss:', loss.item())

손실값은 매우 단순한 L1 손실을 사용는데, 위의 학습을 위한 데이터셋의 경우 오차값의 절대값이 L1 값이고 오차값에 대해 손실값이 비례하므로 L1 손실은 적당하고 학습 속도가 빠릅니다. 그리고 가중치에 대한 최적화 방법은 Adam을 사용했습니다. 일반 SGD 방식은 그 방식이 매우 단순해서 좀처럼 학습이 되지 않습니다.

이제 학습 동안 손실값의 추이와 추론된 신경망의 모델에 대한 결과를 그래프로 나타내기 위한 코드는 다음과 같습니다.

plt.plot(loss_array)
plt.show()

plt.figure(figsize=(10,10))

x = x.cpu().detach().numpy()
y_noise = y_noise.cpu().detach().numpy()
output = output.cpu().detach().numpy()

plt.scatter(x, y_noise, s=1, c="gray")
plt.scatter(x, output, s=1, c="red")

plt.show()

위 코드에서 손실에 대한 그래프 결과는 다음과 같습니다.

손실값이 매 에폭마다 감소하는 것을 보면 학습이 제대로 이루어지고 있다는 것을 알 수 있습니다. 그리고 가장 중요한 그래프인, 신경망 학습의 추론 결과에 대한 그래프입니다.

회색 지표는 학습 데이터이고 빨간색 지표가 학습된 모델이 추론한 결과입니다. 데이테에 매우 근접한 추론 결과를 나타내고 있는 것을 볼 수 있습니다. 그래프가 곡선처럼 보이지만 사실은 직선으로 구성된 그래프입니다. 이는 앞서 언급했듯이 신경망이 선형회귀에 기반하고 있기 때문입니다.

Python의 람다(Lambda)

파이썬의 람다 기능은 익명 함수(Anonymous), 즉 이름이 없는 함수를 정의하기 위한 용도로 사용됩니다. 참고로 컴퓨터 분야에서 정의는 없던 것에 대한 구체적인 생성을 의미하며, 선언은 일단 이름만 붙여두고 구체적인 생성은 다른 곳에서 대신하는 것을 의미합니다.

일반적으로 파이썬에서 함수는 다음처럼 정의됩니다.

def func(a):
    return a+1

위와 동일한 람다 방식의 함수 정의는 다음과 같죠. 위의 동일성을 유지하기 위해 람다 함수를 func에 할당하여 이름을 붙인 경우입니다. 호출은 일반함수과 동일합니다.

func = lambda a: a+1

다른 예로, 인자를 두개 받아 받은 인자값을 합해 반환하는 람다 함수는 다음과 같습니다.

func = lambda a,b: a+b

이 람다 함수의 사용은 생각해 보면, map처럼 함수를 인자로 받는 함수에서와 같습니다.

r = list(map(lambda a,b: a+b, [1,2,3], [10,20,30]))
print(r) # [11, 22, 33]

덧붙여 람다 함수를 이용하여 함수를 반환하는 함수를 정의할 수 있습니다. 클로저(Closure)라고도 하죠.

def makeFunc(n):
    return lambda a : a % n == 1

isOdd = makeFunc(2)

print(isOdd(11))

물론 클로저 함수를 정의하기 위해 람다를 사용할 필요는 없습니다. 아래처럼요.

def makeFunc(n):
    def func(a):
        return a % n == 1
    return func

단, 위의 코드는 함수의 이름(func)을 불필요하게 부여했다는 점이 거슬립니다.

람다를 통한 함수의 정의는 제약이 많습니다. 람다 함수는 반드시 반환값에 대한 단 한줄의 코드로만 구성되어야 한다는 점입니다. 그렇다면 람다함수에서 어떤 논리적인 조건처리는 어떻게 구현할 수 있을까요? 거기에 대한 힌트는 아래의 코드를 통해 살펴볼 수 있습니다.

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
r = list(
        map(
            lambda x: 
                'BIG' if x > 5 
                else 'SMALL' if x < 5 
                else 'MIDDLE',
            a
        )
    )
print(r) # ['SMALL', 'SMALL', 'SMALL', 'SMALL', 'MIDDLE', 'BIG', 'BIG', 'BIG', 'BIG', 'BIG']

이해를 돕고자 들여쓰기를 했는데, 리스트 요소 중 5보다 작으면 SMALL, 5보다 크면 BIG, 딱 5이면 MIDDLE 문자열로 구성된 또 다른 리스트를 반환하는 것입니다.

실제 코딩에서는 들여쓰기가 제거된 아래의 형태가 되겠네요.

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
r = list(map(lambda x: 'BIG' if x > 5 else 'SMALL' if x < 5 else 'MIDDLE', a))
print(r)