Pytorch - 06) Convolutional Neural Network (1)

## Convolutional Neural Network (CNN)

### Fully Connected Layer의 문제점

Convolutional Neural Network (이하 CNN)은 이미지, 비디오, 텍스트, 사운드를 분류하는 딥러닝에서 가장 많이 사용되는 알고리즘 중 하나다. CNN은 패턴을 찾는데 특히 유용하며, 데이터에서 직접 학습하며, 패턴을 사용하여 이미지를 분류하여 특징을 수동으로 추출할 필요가 없다.

기존 신경망은 인접하는 계층의 모든 뉴런이 연결되어 있는 fully-connected 구조다. 이전에 28*28*1 짜리 이미지를 학습했을때, 3차원적인 정보는 모두 무시하고 1차원 배열로 변환하여 학습하였다. 이는 공간적인 정보를 모두 잃게 된다.

![cnn1](../images/cnn1.png)

예를 들어 가까운 픽셀은 값이 비슷하거나, rgb값이 비슷하거나 하는 ㄹ등의 정보가 있을 수 있지만, 1차원으로 쭉 늘어트리게 되면 이러한 정보 (패턴)가 모두 무시되어 버린다.

또한, 큰이미지가 인풋으로 들어오게되면 weight로 설정해야 하는 값이 기하급수적으로 많아지게 되며, 이는 성능저하를 불러온다.

### Convolution

합성곱연산은, 특징정 크기 (width, height)를 갖는 필터(filter, kernel)를 일정간격(stride)로 이동해가며 입력데이터에 적용하는 것을 의미한다.

![cnn](https://cdn-images-1.medium.com/max/1600/1*7S266Kq-UCExS25iX_I_AQ.png)

![filter-stride](http://deeplearning.stanford.edu/wiki../../../images/6/6c/Convolution_schematic.gif)

원본이미지에서 필터를 곱하는 것을 합성곱(convolution)이라고 한다. 이렇게 주어진 필터를 이미지 전체에 stride에 따라서 적용하면서, 이미지의 특징을 찾아내는 것이다.

이렇게 하게 되면, 해당 필터는 필터가 갖고 있는 특징이 데이터에 있는지 없는지를 검출 해 줄 수 있다.

![filter](https://adeshpande3.github.io/assets/Filter.png)

왼쪽이 곡선의 특징을 찾는 필터라면, 오른쪽과 같은 모양을 필터가 찾아내는 것이라고 보면 된다.

![filter1](https://adeshpande3.github.io/assets/OriginalAndFilter.png)

![filter2](https://adeshpande3.github.io/assets/FirstPixelMulitiplication.png)

이런 식으로, 쥐의 엉덩이에 있는 곡선의 특징을 이미지에서 찾아내게 되는 것이다. Linear에 비유하자면, weight가 filter가 되는 것이다. 마찬가지로 bias (편향) 도 포함될 것이다.

### padding

cnn을 하기전에, 입력데이터 주변을 특정값으로 채우는 단계로, 이는 주로 입력 데이터와 출력데이터의 크기를 맞추기 위해서 쓴다.

![padding](https://adeshpande3.github.io/assets/Pad.png)

32x32x3의 입력값에서 5x5x3 필터를 적용 시키게 되면, feature map의 크기는 28x28x3이 된다. 이렇게 사이즈가 안 맞는것을 막기 위해서 Padding을 쓴다. 입력데이터 주위에 2의 두께로 0을 둘러 쌓아주면, 36x36x3이 되고, 5x5x3 필터를 적용하더라도 결과값은 32x32x3 로 유지된다.

이러한 패딩은 특징이 유실되는 것을 방지해주고, 또한 과적합도 방지하는 효과가 있다. 주로 0을 적용하는 zero-padding을 쓴다.

### stride

필터를 적용하는 위치의 간격을 의미한다. stride가 커지면, 당연히 간격이 넓어지므로 출력크기가 작아진다.

![stride](http://deeplearning.stanford.edu/wiki../../../images/6/6c/Convolution_schematic.gif)

위의 이미지에서는 한칸씩 (1의 크기로) stride를 적용하고 있다.

### 출력 크기 계산

- 입력크기: H, W
- 필터크기: FH, FW
- 출력크기: OH, OW
- 패딩: P
- 스트라이드 S

$$ OH = \frac{H + 2P - FH}{S} + 1 $$

$$ OW = \frac{W + 2P - FW}{S} + 1 $$

두 결과는 모두 정수로 나누어 떨어지는 값이어야 한다.

### 3차원 데이터 (RGB 이미지)

3차원 이미지 데이터에 대해서는, 필터도 이미지와 마찬가지로 같은 수의 채널을 갖고 있어야 한다.

### Pooling

이렇게 input에서 filter 를 적용하여 특징을 추출했다면, 이를 어떻게 판단할지가 중요 하다. 이렇게 추출된 map을 인위적으로 줄이는 작업을 pooling이라고 한다.

![pooling](https://upload.wikimedia.org/wikipedia/commons/e/e9/Max_pooling.png)

pooling 하는 방법은 크게 max와 average가 있는데, 위 샘플 이미지에서는 최대값을 가져오는 MaxPooling 을 수행했다. 이는 큰값이 다른 주변 값(특징)을 대표한다는 개념을 적용시키게 된다. 이는 과적합을 방지하고, 컴퓨팅 리소스를 줄이는 효과를 가져온다.

## Convolutaional Layer

![cnn-sample](https://image.slidesharecdn.com/deeplearning-161020090534/95/deep-learning-stm-6-19-638.jpg?cb=1476964837)

자동차 인식을 위해 CNN을 적용한 모습이다. Conv-Relu-Conv-Relu-Pool-Conv-Relu-Conv-Relu-Pool-Conv-Relu-Conv-Relu-Pool를 적용해서 인식을 해낸 모습이다.

정리하자면, 이미지에서 특징을 추출해내는 작업을 몇번 거치고, 그뒤에 이를 fully connect 하여 perceptron을 바탕으로 최종적으로 예측을 하는 것이라고 할 수 있다.

### ReLU를 쓰는이유

- 대부분의 실제 예제는 linear한 상황이 별로 없다.
- ReLU는 negative값을 모두 무시하기 때문에, 조금 더 낫다.
- tanh와 sigmoid는 vanishing gradient 문제를 갖고 있다.
  - Deep Neural Netwrok는 Backpropagation (역전파)를 하기 위해서 gradient descent (경사하강법)을 적용하여 parameter를 조정한다.
  - 그러나 이 gradient 값이 매우 작아지게 되면, 이것을 효율적으로 개선해나가는 것이 쉽지 않아지고, 느려진다.
  - sigmoid는 중간 값에서는 경사가 있지만, 값이 작거나 커질 수록 극도로 경사가 작은 값을 갖게 된다. (0과 가까워 진다.)
  - 따라서 아무리 계산을 누적해도 굉장히 작은 값이 나오게 된다.
- Relu는 input이 음수면 그냥 0을 리턴, 양수면 같은 값을 리턴한다.
- 따라서 값이 극도로 작아지거나 커진다고 해서 gredient가 사라지지 않는다.

![cnn2](../images/cnn2.png)

MNIST 손글씨 데이터셋에 CNN을 적용한다면 위의 이미지와 같은 \모습이 될것이다.


Pytorch - 06) Convolutional Neural Network (1) ## Convolutional Neural Network (CNN)  ### Fully Connected Layer의 문제점  Convolutional Neural Network (이하 CNN)은 이미지, 비디오, 텍스트, 사운드를 분류하는 딥러닝에서 가장 많이 사용되는 ...

Pytorch 06) - Convolutional Neural Network (1)

Pytorch - 05) Image Recognition

마지막으루다가 손글씨 분류해보는 실습을 해보겠습니다.

### Dataset

```python
import torch
import matplotlib.pyplot as plt
import numpy as np

from torch import nn
from torch.nn import functional as F
from torchvision import datasets, transforms


# 리사이즈
# 텐서화
# channel, height, width를 정규화 한거임
# 처음 세개는 mean
# 그 다음 세개는 sd
transformer = transforms.Compose([transforms.Resize((28, 28)),
                                  transforms.ToTensor(),
                                  transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
                                 ])


training_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transformer)
validation_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transformer)

# 6000개를 100개 배치로 나눠서 돌림
training_loader = torch.utils.data.DataLoader(dataset=training_dataset, batch_size=100, shuffle=True)
validation_loader = torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=100, shuffle=False)
```

텐서를 받아서 image로 보여주는 메소드를 만들자.

```python
def im_convert(tensor):
  # 복제하고, 자동미분 끄고, numpy로
  image = tensor.clone().detach().numpy()
  # 데이터 형태는 color channel 1 28 px 28 px , 즉 1, 28, 28로 되어있음
  # 이거를 28, 28, 1 로 변경
  image = image.transpose(1, 2, 0)
  # denormalize
  image = image * np.array([0.5, 0.5, 0.5] + np.array([0.5, 0.5, 0.5]))
  # 데이터를 0과 1사이로만 있도록 보정
  image = image.clip(0, 1)
  return image
```

맛보기로 이미지를 한번 보자.

```python
dataiter = iter(training_loader)
images, labels = dataiter.next()

fig = plt.figure(figsize=(25, 4))

for i in np.arange(20):
  # row 2 column 10
  ax = fig.add_subplot(2, 10, i+1, xticks=[], yticks=[])
  plt.imshow(im_convert(images[i]))
  ax.set_title(labels[i].item())
```

![image-recognition1](../images/image-recognition1.png)

### Model

```python
class Classifier(nn.Module):

  def __init__(self, n_input, H1, H2, n_output):
    super().__init__()
    self.linear1 = nn.Linear(n_input, H1)
    self.linear2 = nn.Linear(H1, H2)
    self.linear3 = nn.Linear(H2, n_output)

  def forward(self, x):
    x = F.relu(self.linear1(x))
    x = F.relu(self.linear2(x))
    x = self.linear3(x)
    return x
```

hidden layer2개에, linear와 활성화 함수로 relu를 사용했다. sigmoid와 다르게 relu는 값 그자체가 확률을 나타내지 않으므로, 마지막에는 ReLU를 쓰지 않았다.

```python
model = Classifier(784, 125, 65, 10)
model
```

```bash
Classifier(
  (linear1): Linear(in_features=784, out_features=125, bias=True)
  (linear2): Linear(in_features=125, out_features=65, bias=True)
  (linear3): Linear(in_features=65, out_features=10, bias=True)
)
```

이미지가 28\*28이므로 784개의 input, 총 10개 (0~9)로 구별해야 하므로 output은 10개로 나타넀다. 가운데 125와 65는 그냥 임의로 넣어봤다. 해보면서 조절해보면 된다.

```python
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.005)
```

classification 문제라서 CrossEntroypyLoss를, 그리고 optimizer로는 Adam을 사용하였다.

### training

```python
epochs = 12
running_loss_history = []
running_correct_history = []
validation_running_loss_history = []
validation_running_correct_history = []

for e in range(epochs):

  running_loss = 0.0
  running_correct = 0.0
  validation_running_loss = 0.0
  validation_running_correct = 0.0

  for inputs, labels in training_loader:

    inputs = inputs.view(inputs.shape[0], -1)
    outputs = model(inputs)
    loss = criterion(outputs, labels)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    _, preds = torch.max(outputs, 1)

    running_correct += torch.sum(preds == labels.data)
    running_loss += loss.item()



  else:
    # 훈련팔 필요가 없으므로 메모리 절약
    with torch.no_grad():

      for val_input, val_label in validation_loader:
        val_input = val_input.view(val_input.shape[0], -1)
        val_outputs = model(val_input)
        val_loss = criterion(val_outputs, val_label)

        _, val_preds = torch.max(val_outputs, 1)
        validation_running_loss += val_loss.item()
        validation_running_correct += torch.sum(val_preds == val_label.data)


    epoch_loss = running_loss / len(training_loader)
    epoch_acc = running_correct.float() / len(training_loader)
    running_loss_history.append(epoch_loss)
    running_correct_history.append(epoch_acc)

    val_epoch_loss = validation_running_loss / len(validation_loader)
    val_epoch_acc = validation_running_correct.float() / len(validation_loader)
    validation_running_loss_history.append(val_epoch_loss)
    validation_running_correct_history.append(val_epoch_acc)

    print("===================================================")
    print("epoch: ", e + 1)
    print("training loss: {:.5f}, {:5f}".format(epoch_loss, epoch_acc))
    print("validation loss: {:.5f}, {:5f}".format(val_epoch_loss, val_epoch_acc))
```

```bash
===================================================
epoch:  1
training loss: 0.34698, 89.241669
validation loss: 0.18939, 94.029999
===================================================
epoch:  2
training loss: 0.17725, 94.583336
validation loss: 0.16674, 94.790001
===================================================
epoch:  3
training loss: 0.15004, 95.341667
validation loss: 0.16987, 94.989998
===================================================
epoch:  4
training loss: 0.12949, 95.991669
validation loss: 0.13101, 96.040001
===================================================
epoch:  5
training loss: 0.11537, 96.478333
validation loss: 0.14699, 95.970001
===================================================
epoch:  6
training loss: 0.10967, 96.628334
validation loss: 0.11986, 96.410004
===================================================
epoch:  7
training loss: 0.10788, 96.681664
validation loss: 0.16216, 95.400002
===================================================
epoch:  8
training loss: 0.10198, 96.928337
validation loss: 0.13875, 96.029999
===================================================
epoch:  9
training loss: 0.09768, 97.044998
validation loss: 0.13843, 96.129997
===================================================
epoch:  10
training loss: 0.09128, 97.230003
validation loss: 0.14281, 96.349998
===================================================
epoch:  11
training loss: 0.09073, 97.208336
validation loss: 0.15617, 95.629997
===================================================
epoch:  12
training loss: 0.09084, 97.209999
validation loss: 0.13772, 96.470001
```

### Loss

```python
plt.plot(running_loss_history, label='training loss')
plt.plot(validation_running_loss_history, label='validation loss')
plt.legend()
```

![image-recognition2](../images/image-recognition2.png)

### Accuracy

```python
plt.plot(running_correct_history, label='training accuracy')
plt.plot(validation_running_correct_history, label='validation accuracy')
```

![image-recognition3](../images/image-recognition3.png)

정확도는 95% 안팎으로 나왔다. 그러나 validation loss가 training loss보다 커지는 것을 보아, 훈련하는 과정에서 overfitting이 일어났다고 봐야할 것이다. hyperparameter를 조금씩 조절할 필요가 있어 보인다.

### Test

```python
import requests
from PIL import Image
import PIL

url = 'https://images.homedepot-static.com/productImages/007164ea-d47e-4f66-8d8c-fd9f621984a2/svn/architectural-mailboxes-house-letters-numbers-3585b-5-64_1000.jpg'
response = requests.get(url, stream=True)
img = Image.open(response.raw)
plt.imshow(img)
```

![image-recognition4](../images/image-recognition4.png)

```python
# 반전
img = PIL.ImageOps.invert(img)
# 흑백으로 좀더 또렷하게
img = img.convert('1')
img = transformer(img)

plt.imshow(im_convert(img))
```

![image-recognition5](../images/image-recognition5.png)

```python
img = img.view(img.shape[0], -1)
outputs = model(img)
_, pred = torch.max(outputs, 1)
print(pred.item())
```

```bash
5
```

맞췄다. 한번 validation dataset에 다시 해보자.

```python
dataiter = iter(validation_loader)
images, labels = dataiter.next()
images_ = images.view(images.shape[0], -1)
output = model(images_)
_, preds = torch.max(output, 1)

fig = plt.figure(figsize=(25, 4))

for i in np.arange(20):
  # row 2 column 10
  ax = fig.add_subplot(2, 10, i+1, xticks=[], yticks=[])
  plt.imshow(im_convert(images[i]))
  ax.set_title("{} ({})".format(str(preds[i].item()), str(labels[i].item())), color=('green' if preds[i] == labels[i] else 'red'))
```

![image-recognition5](../images/image-recognition6.png)

하나 빼고 다 맞췄는데, 저건 내가봐도 6으로 볼 수도 있을 것 같다. 착한 분류기 ㅇㅈ 합니다.


Pytorch - 05) Image Recognition 마지막으루다가 손글씨 분류해보는 실습을 해보겠습니다.  ### Dataset  ```python import torch import matplotlib.pyplot as plt import numpy as np  from torch import nn from torch.nn import functi...

Pytorch 05) - Image Recognition

Pytorch - 04) Deep Neural Network

## Deep Neural Network

이전 [Perceptron](https://yceffort.github.io/2019/02/19/pytorch-03-perceptron.html)에서 한개의 Perceptron으로는 XOR연산을 효과적으로 분류하지 못한다는 것을 이야기 했었다.

![perceptron-xor](https://cdn-images-1.medium.com/max/1600/1*Tc8UgR_fjI_h0p3y4H9MwA.png)

그리고 이런 XOR 이 아니더라도, 선형이 아닌 형태의 데이터를 분류 할 수 없을 것이다.

![deep-neural-network3](../images/deep-neural-network3.png) 

이런형태의 데이터는 어떻게 classification 해야 될까? 라는 생가에서 시작된게, perceptron을 여러개 배치하는 것이다.

![deep-neural-network4](../images/deep-neural-network4.png) 

[Tensorflow playground](https://playground.tensorflow.org/#activation=sigmoid&batchSize=10&dataset=circle&regDataset=reg-plane&learningRate=0.03&regularizationRate=0&noise=0&networkShape=4&seed=0.99755&showTestData=false&discretize=false&percTrainData=50&x=true&y=true&xTimesY=false&xSquared=false&ySquared=false&cosX=false&sinX=false&cosY=false&sinY=false&collectStats=false&problem=classification&initZero=false&hideText=false) 예제다.

input layer 와 output layer 사이에 4개의 perceptron을 배치했는데, 각각의 perceptron이 선형으로 되어 있으며, 이 4개의 선형이 이루는 사각형 형태로 classification이 되어 있음을 알 수 있다.

![deep-neural-network1](../images/deep-neural-network1.png)

![deep-neural-network2](../images/deep-neural-network2.png)

$$x1, x2$$에 대한 입력값이 각각 있고, 이 입력 값에 대해서 서로다른 perceptron이 다른 weight을 바탕으로 각각 다른 구별을 하고, 이 두가지 값을 또다른 weight로 보는 작업들을 반복하여 작업을 수행한다. 

### Feedforward

input layer의 값이 hidden layer 로 전달되고, hidden layer가 ouput layer로 전파하는 과정 (hidden layer가 여러개면 hidden layer간 전파도 있을 것이다)을 feedforward, 순전파라고 한다. 말그대로, 앞쪽의 입력값을 뒤로 보내는 것을 의미한다. hidden layer에 있는 각각의 노드는 퍼셉트론의 활성함수라고 볼 수 있다.

### Backpropagation

임의의 값을 기반으로 보낸 feedforward가 당연히 제대로된 classification을 해낼리가 없다. 그래서 Backpropagation(역전파)를 한다. 역전파는 input의 역방향으로 오차를 돌려보내서 weight을 재업데이트 하는 것이다. 각 파라미터 별로 Loss에 대한 그래디언트를 구한뒤, 그래디언트들이 향한 쪽으로 파라미터를 업데이트 한다.

## Code

### 데이터셋

```python
import torch
import numpy as np
import matplotlib.pyplot as plt
import torch.nn as nn
from sklearn import datasets

n_pts = 500
X, y = datasets.make_circles(n_samples=n_pts, random_state=123, noise=0.2, factor=0.3)

x_data = torch.Tensor(X)
y_data = torch.Tensor(y.reshape(500, 1))

def scatter_plot():
  plt.scatter(X[y==0, 0], X[y==0, 1], color='red')
  plt.scatter(X[y==1, 0], X[y==1, 1], color='blue')

scatter_plot()
```

![deep-neural-network5](../images/deep-neural-network5.png)

가운데 파란색 점들이 1이고, 빨간색이 0 이다.

```python
class Model(nn.Module):
  
  def __init__(self, input_size, H1, output_size):
    super().__init__()
    self.linear1 = nn.Linear(input_size, H1)
    self.linear2 = nn.Linear(H1, output_size)
    
  def forward(self, x):
    x = torch.sigmoid(self.linear1(x))
    x = torch.sigmoid(self.linear2(x))
    return x
  
  def predict(self, x):
    return 1 if self.forward(x) >= 0.5 else 0
```

차이점은 hidden layer가 하나 추가됐다는 것이다. 두개 모두 linear로 처리되고 있으며, 활성화 함수로 sigmoid를 적용하였다.

```python
model = Model(2, 4, 1)
print(list(model.parameters()))
```

input, hidden, output이 각각 2, 4, 1 이다.

```
[Parameter containing:
tensor([[-0.1573,  0.6670],
        [-0.5144,  0.6607],
        [ 0.6625,  0.1984],
        [ 0.3064, -0.2649]], requires_grad=True), Parameter containing:
tensor([-0.0411,  0.6752, -0.0167,  0.6902], requires_grad=True), Parameter containing:
tensor([[-0.2804, -0.0074,  0.1881,  0.4310]], requires_grad=True), Parameter containing:
tensor([-0.1316], requires_grad=True)]
```

이제 학습을 시켜보자.

```python
criterion = nn.BCELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
```

```python
epochs = 1000
losses = []

for i in range(epochs):
  y_pred = model.forward(x_data)
  loss = criterion(y_pred, y_data)
  
  print("epochs:", i, "loss:", loss.item())
  
  losses.append(loss.item())
  optimizer.zero_grad()
  loss.backward()
  optimizer.step()
```

```
epochs: 0 loss: 0.6942843198776245
epochs: 1 loss: 0.6935287117958069
epochs: 2 loss: 0.6930914521217346
epochs: 3 loss: 0.6929344534873962
epochs: 4 loss: 0.6929613351821899
epochs: 5 loss: 0.6930437088012695
epochs: 6 loss: 0.6930822730064392
epochs: 7 loss: 0.6930424571037292
epochs: 8 loss: 0.6929377913475037
epochs: 9 loss: 0.6928017139434814
...
epochs: 990 loss: 0.12231576442718506
epochs: 991 loss: 0.12226035445928574
epochs: 992 loss: 0.12220513820648193
epochs: 993 loss: 0.12215007096529007
epochs: 994 loss: 0.12209513783454895
epochs: 995 loss: 0.12204025685787201
epochs: 996 loss: 0.12198563665151596
epochs: 997 loss: 0.12193109095096588
epochs: 998 loss: 0.12187661975622177
epochs: 999 loss: 0.1218223124742508
```

```python
plt.plot(range(epochs), losses)
```

![deep-neural-network6](../images/deep-neural-network6.png)

오차가 완만하게 감소하여 약 0.1에서 수렴함을 알수 있다.

```python
def plot_decision_boundray(X, y):
  # x축 y축 min max 값을 구해 그래프의 상하좌우 길이를 세팅한다.
  x_span = np.linspace(min(X[:, 0]), max(X[:, 0]))
  y_span = np.linspace(min(X[:, 1]), max(X[:, 1]))
  # 이 두개로 그리드를 만든다.
  xx, yy = np.meshgrid(x_span, y_span)
  # .ravel()로 평탄화 하고 이 둘을 합쳐 tensor로 변환한다.
  grid = torch.Tensor(np.c_[xx.ravel(), yy.ravel()])
  # 값 예측
  pred_func = model.forward(grid)
  # xx와 모양을 맞춰 그래프에 넣을 수 있게 세팅한다.
  # detach를 하여 autograd를 off한다.
  # numpy()로 변환하여 그래프를 그릴 수 있게 한다.
  z = pred_func.view(xx.shape).detach().numpy()
  # 등고선
  plt.contourf(xx, yy, z)
```

![deep-neural-network7](../images/deep-neural-network7.png)

그래프가 완성되었다. 짙은 검은색일 수록 1일 확률이 높고, 그렇지 않은 영역은 하얀색에 가깝다. 대체로 overfitting되지 않고 제대로 예측한 것을 알 수 있다.

Pytorch - 04) Deep Neural Network ## Deep Neural Network  이전 [Perceptron](https://yceffort.github.io/2019/02/19/pytorch-03-perceptron.html)에서 한개의 Perceptron으로는 XOR연산을 효과적으로 분류하지 못한다는 것을 이야기 했었다.  ![p...

Pytorch 04) - Deep Nueral Network

Pytorch - 03) Perceptron

## Perceptron

(마지막 정리가 되길 바라며)

Perceptron은 우리 두뇌 (뉴런)의 인지능력을 모방하도록 만든 인위적인 네트워크다.

![perceptron](https://cdn-images-1.medium.com/max/1600/1*_Zy1C83cnmYUdETCeQrOgA.png)

퍼셉트론은 다수의 신호를 받아서, 하나의 신호를 출력한다. 여기에서 x는 입력값이고 w는, 가중치라고 부르는 weight이다. 각 입력치에 가중치를 부여하여, 입력신호화 계산하고, 그 신호의 총합이 정해진 값을 넘으면 1을 출력한다.

각 입력신호에 weight가 부여되며, 이 weight가 클수록 해당 입력값이 중요한 역할을 한다고 볼 수 있다. 머신러닝에서 하는 것은 이 weight을 조정하는 작업이라고 할 수 있다.

이렇게만 보면, 앞에서 보았던 linear classification 모형이라고도 볼 수 있다. 실수형의 input 벡터를 받아서, 이를 선형으로 계산하는 것이라고도 볼 수 있다.

처음에는 임의로 설정된 weight으로 시작하여, 여기에 training data를 모형에 입력하며 weight을 결과값에 맞도록 개선 나간다.

$$ b + w1x1 + w2x2 < 0 $$

$$ b + w1x1 + w2x2 \geq 0 $$

여기서 가중치 (weight)는 입력신호과 결과에 주는 영향도를 조절하며, 편향 (bias)는이 뉴런이 얼마나 쉽게 활성화(1을 출력하느냐?)화되는 지를 조정하는 변수다.

그러나 문제는, 말그대로 선형분류만 가능하다는 것이다. XOR 논리는 어느 한쪽이 1일때만 1을 출력하는 배타적인 논리연산인데, 이를 선으로 구별하지 못하는 것을 알 수 있다.

![perceptron-xor](https://cdn-images-1.medium.com/max/1600/1*Tc8UgR_fjI_h0p3y4H9MwA.png)

xor 연산은 (1,0)이나 (0,1) 일 때 활성화되는데, 선으로는 이를 구별해내지 못한다.

그래서 이러한 문제를 해결하기 위해 여러개의 퍼셉트론을 layer화 하여 극복해 내었다.

![multi-layer-perceptron](https://www.oreilly.com/library/view/getting-started-with/9781786468574/graphics/B05474_04_05.jpg)

## perceptron in pytorch

### 데이터셋 만들기

```python
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt

from sklearn import datasets

n_pts = 100
centers = [[-0.5, 0.5], [0.5, -0.5]]
X, y = datasets.make_blobs(n_samples=n_pts, random_state=123, centers=centers, cluster_std=0.4)

x_data = torch.Tensor(X)
y_data = torch.Tensor(y.reshape(100, 1))

print(x_data[:5])
print(y_data[:5])
```

```
tensor([[-0.1372, -0.0715],
 [ 0.8044, -0.3706],
 [-0.6022, -0.6194],
 [ 0.5709, -0.5120],
 [ 0.0064, 0.1533]])
tensor([[0.],
 [1.],
 [0.],
 [1.],
 [0.]])
```

```python
def scatter_plot():
 plt.scatter(X[y==0, 0], X[y==0, 1])
 plt.scatter(X[y==1, 0], X[y==1, 1])

scatter_plot()
```

![perceptron1](../images/perceptron1.png)

이런 형태의 만들어 냈다.

### 모델만들기

```python
class Model(nn.Module):

 def __init__(self, input_size, output_size):
 super().__init__()
 self.linear = nn.Linear(input_size, output_size)

 def forward(self, X):
 pred = torch.sigmoid(self.linear(X))
 return pred

 def predict(self, x):
 return 1 if pred >= 0.5 else 0
```

활성화 함수로 sigmoid함수를 사용하였다.

$$ s(z) = \frac{1}{1 + e ^ {-z}} $$

![sigmoid](https://icim.nims.re.kr/file/1d96aff862744eef892c8c8027159935.jpg)

모양에서도 알 수 있듯이, 이함수의 특징은

- 0/1 을 구별하는 부분은 경사가 급격하고, 나머지는 완만하다.
- 활성함수의 값을 성공확률이라는 의미로 해석이 가능하다.

```python
torch.manual_seed(2)
model = Model(2, 1)
list(model.parameters())
```

```
[Parameter containing:
 tensor([[ 0.1622, -0.1683]], requires_grad=True), Parameter containing:
 tensor([0.1939], requires_grad=True)]
```

input 값이 두개이고, output은 하나인 model을 만들어 냈다.

```python
[w, b] = model.parameters()
w1, w2 = w.view(2)
b1 = b[0]


def get_params():
 return w1.item(), w2.item(), b.item()

print(w1.item(), w2.item(), b1.item())
```

```
0.16220331192016602 -0.1682732105255127 0.19390898942947388
```

랜덤으로 가중치 2개와 bias가 생성되었다.

```python
def plot_fit(title):
 plt.title = title
 w1, w2, b1 = get_params()
 # 0 = w1*x1 + w2*x2 + b
 x1 = np.array([-2.0, 2.0])
 # 0 = w1*x1 + w2*x2 + b
 # 를 x2 입장에서 계산
 x2 = (w1*x1 + b1) / -w2
 plt.plot(x1, x2, 'red')
 scatter_plot()
```

![perceptron2](../images/perceptron2.png)

아직은 회귀선이 나타나지 않은 것을 알 수 있다. 이제 이것을 학습시켜 보자.

```python
criterion = nn.BCELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
```

이번에 사용해볼 손실함수는 Cross Entropy Loss 다. (binary의 경우에는 Binary Cross Entropy Loss, `BCELoss`를 사용해야하며, 활성함수로 sigmoid를 꼭써줘야 한다.)

Regression에서는 MSE를, Classification에서는 Cros Entropy를, 여러 class를 구별하는 경우에는 Softmax를 쓴다.

공식은 아래와 같다.

$$ \text{Cross Entropy} = P(X) * -log(Q(x)) $$

여기서 $$P(x)$$는 실제값을, $$Q(x)$$는 예상값이다.

![cross-entropy-loss](https://ml-cheatsheet.readthedocs.io/en/latest/_images/cross_entropy.png)

예측이 맞을때에는 0으로 수렴하고, 틀릴 경우에는 무한대로 발산하는 특성을 가지고 있다. 즉, 틀릴수록 loss를 크게 두어서 가중치를 조절할 수 있게 하는 것이다.

### training

```python
epochs = 1000
losses = []
for i in range(epochs):

 y_pred = model.forward(x_data)
 loss = criterion(y_pred, y_data)
 print("epoch: ", i, "loss: ", loss.item())
 losses.append(loss.item())

 optimizer.zero_grad()
 loss.backward()
 optimizer.step()
```

```
epoch: 0 loss: 0.6185115575790405
epoch: 1 loss: 0.6174639463424683
epoch: 2 loss: 0.6164201498031616
epoch: 3 loss: 0.6153794527053833
epoch: 4 loss: 0.614342451095581
epoch: 5 loss: 0.6133086681365967
epoch: 6 loss: 0.6122783422470093
epoch: 7 loss: 0.6112515330314636
epoch: 8 loss: 0.6102280616760254
epoch: 9 loss: 0.6092080473899841
...
epoch: 990 loss: 0.25722837448120117
epoch: 991 loss: 0.2571081817150116
epoch: 992 loss: 0.25698813796043396
epoch: 993 loss: 0.2568681538105011
epoch: 994 loss: 0.2567485272884369
epoch: 995 loss: 0.2566289007663727
epoch: 996 loss: 0.2565094828605652
epoch: 997 loss: 0.25639018416404724
epoch: 998 loss: 0.2562710642814636
epoch: 999 loss: 0.2561522126197815
```

loss가 0.25에 수렴하고 있다.

```python
plt.plot(range(epochs), losses)
plt.ylabel('loss')
plt.xlabel('epoch')
```

![perceptron3](../images/perceptron3.png)

점점 loss가 줄어들고

![perceptron4](../images/perceptron4.png)

육안으로 보기에도, 정확히 분류하는 것을 알 수 있었다.

### Test

```python
point1 = torch.Tensor([1.0, -1.0])
point2 = torch.Tensor([-1.0, 1.0])
plt.plot(point1.numpy()[0], point1.numpy()[1], 'ro')
plt.plot(point2.numpy()[0], point2.numpy()[1], 'ko')



print("Red point positive probability = {}".format(model.forward(point1).item()))
print("black point positive probability = {}".format(model.forward(point2).item()))

print("Red point in class = {}".format(model.forward(point1).item()))
print("black point in class = {}".format(model.forward(point2).item()))

plot_fit('Trained Model')
```

```
Red point positive probability = 0.9424158334732056
black point positive probability = 0.05055497586727142
Red point in class = 1
black point in class = 0
```

![perceptron5](../images/perceptron5.png)

Pytorch - 03) Perceptron ## Perceptron  (마지막 정리가 되길 바라며)  Perceptron은 우리 두뇌 (뉴런)의 인지능력을 모방하도록 만든 인위적인 네트워크다.  ![perceptron](https://cdn-images-1.medium.com/max/1600/1*_Zy1C83cnmYUdETCeQrOgA.png)  퍼셉트...

Pytorch 03) - Perceptron

Pytorch - 02) Linear Regression

## Linear Regression

Linear Regression이 한국말로 뭐였더라?

```python
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import numpy as np
```

### 데이터셋 만들기

대충 뭔가 있어보이는 데이터셋을 만들자.

```python
X = torch.randn(100, 1)*10
y = X + 3*torch.randn(100, 1)
plt.plot(X.numpy(), y.numpy(), 'o')
plt.ylabel('y')
plt.xlabel('x')
```

![lr1](../images/lr1.png)

```python
# nn.Module은 사용자 정의 모듈을 생성하는데 있어서 가장 기초가 되는 모듈이다.
class LR(nn.Module):

  # linear regression의 입력값과 출력값 갯수를 받는다.
  def __init__(self, input_size, output_size):
    super().__init__()
    # nn.Linear를 상속받는다.
    self.linear = nn.Linear(input_size, output_size)

  # 정방향 호출 함수. 이 함수를 통해서 linear regression을 수행하게 된다.
  def forward(self, x):
    pred = self.linear(x)
    return pred
```

nn.Linear는

$$y = xA^{T} + b$$

```python
# random seed
torch.manual_seed(1)
# 입력값이 한개고, 출력값이 한개
model = LR(1, 1)
print(model)
```

```
LR(
  (linear): Linear(in_features=1, out_features=1, bias=True)
)
```

파라미터를 살펴보면

```python
print(list(model.parameters()))
```

이렇게 weight와 bias 가 무작위로 들어가 있는 것을 알 수 있다.

```
[Parameter containing:
tensor([[0.5153]], requires_grad=True), Parameter containing:
tensor([-0.4414], requires_grad=True)]
```

이제 Linear Regression을 해보자.

```python
w, b = model.parameters()
def get_params():
  return w[0][0].item(), b[0].item()

def plot_fit(title):
  plt.title = title
  # weight 와 bias
  w1, b1 = get_params()
  # -30 부터 30까지
  x1 = np.array([-30, 30])
  # 선형 추정선을 그려본다.
  y1 = w1*x1 + b1
  plt.plot(x1, y1, 'r')
  plt.scatter(X, y)
  plt.show()

plot_fit('Initial Model')
```

![lr2](../images/lr2.png)

회귀선,,,인지,, 추정선,,,인지 암튼지간에 제대로 그리지 못했다는 것을 알 수 있다. 그래서 이를 학습시키려고 한다.

```python
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01)
```

criterion은 `Mean Squred Error`를 , optimizer는 stochastic gradient descent (확률적 경사하강법)을 사용한다. learning_rate는 0.01 이다.

배치 경사하강법은, 매스텝에서 전체 훈련세트를 활용해서 그래디언트를 계산하기 대문에, 훈련세트가 커지면 속도가 매우 느려진다. 그러나 SGD는 매스텝에서 무작위 딱 한개의 샘플만을 처리하고, 그 샘플에 대한 그래디언트만 계산한다.

따라서 속도는 훨씬 빠르지만, 매 iteration 에서 적은 데이터만 처리하기 때문에 훨씬 불안정하다. 위아래로 요동치면서 감소하므로, 물론 시간이 지나면 최소값에 얼추 닿긴 하겠지만, 말그대로 얼추일 뿐이다.

이러한 무작위성은 국소최소값을 벗어나게 하므로 (무작위로 처리하므로), 전역 최소값을 찾을 확률이 더 크다.

암튼 지간에

```python
# 100 회 반복
epochs = 100
losses = []
for i in range(epochs):
  # 예측
  y_pred = model.forward(X)
  # 오차 계산
  loss = criterion(y_pred, y)
  print("epoch:", i, "loss:", loss.item())

  # 오차 누적 (계산을 위해서)
  losses.append(loss)
  # optimzer 초기화
  optimizer.zero_grad()
  # backward를 수행하여 그래디언트 계산
  loss.backward()
  # learning rate 만큼 가중치를 주어서 hyper parameter 업데이트
  optimizer.step()
```

```bash
epoch: 0 loss: 31.671594619750977
epoch: 1 loss: 22.02737808227539
epoch: 2 loss: 16.717256546020508
epoch: 3 loss: 13.792343139648438
epoch: 4 loss: 12.180136680603027
epoch: 5 loss: 11.290426254272461
epoch: 6 loss: 10.798413276672363
epoch: 7 loss: 10.525352478027344
epoch: 8 loss: 10.372870445251465
epoch: 9 loss: 10.286834716796875
...
epoch: 90 loss: 10.071357727050781
epoch: 91 loss: 10.071175575256348
epoch: 92 loss: 10.071000099182129
epoch: 93 loss: 10.070833206176758
epoch: 94 loss: 10.070671081542969
epoch: 95 loss: 10.070516586303711
epoch: 96 loss: 10.070366859436035
epoch: 97 loss: 10.07022476196289
epoch: 98 loss: 10.070086479187012
epoch: 99 loss: 10.069954872131348
```

```python
plt.plot(range(epochs), losses)
plt.ylabel('Loss')
plt.xlabel('epoch')
```

![lr3](../images/lr3.png)

시간이 지나면서 오차가 감소한 것을 알 수 있다.

```python
plot_fit("Trained Model")
```

![lr4](../images/lr4.png)

이전보다 잘 학습되었다.


Pytorch - 02) Linear Regression ## Linear Regression  Linear Regression이 한국말로 뭐였더라?  ```python import torch import torch.nn as nn import matplotlib.pyplot as plt import numpy as np ```  ### 데이터셋 만들기 ...

Pytorch 02) - Linear Regression

Pytorch - 02) Linear Regression
<h2 id="linear-regression">Linear Regression</h2>
Linear Regression이 한국말로 뭐였더라?
<pre class="language-python"><code class="language-python">import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import numpy as np
</code></pre>
<h3 id="데이터셋-만들기">데이터셋 만들기</h3>
대충 뭔가 있어보이는 데이터셋을 만들자.
<pre class="language-python"><code class="language-python">X = torch.randn(100, 1)*10
y = X + 3*torch.randn(100, 1)
plt.plot(X.numpy(), y.numpy(), 'o')
plt.ylabel('y')
plt.xlabel('x')
</code></pre>
<img src="../images/lr1.png" alt="lr1">
<pre class="language-python"><code class="language-python"># nn.Module은 사용자 정의 모듈을 생성하는데 있어서 가장 기초가 되는 모듈이다.
class LR(nn.Module):

 # linear regression의 입력값과 출력값 갯수를 받는다.
 def __init__(self, input_size, output_size):
 super().__init__()
 # nn.Linear를 상속받는다.
 self.linear = nn.Linear(input_size, output_size)

 # 정방향 호출 함수. 이 함수를 통해서 linear regression을 수행하게 된다.
 def forward(self, x):
 pred = self.linear(x)
 return pred
</code></pre>
nn.Linear는
<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>y</mi><mo>=</mo><mi>x</mi><msup><mi>A</mi><mi>T</mi></msup><mo>+</mo><mi>b</mi></mrow><annotation encoding="application/x-tex">y = xA^{T} + b</annotation></semantics></math>y=xAT+b
<pre class="language-python"><code class="language-python"># random seed
torch.manual_seed(1)
# 입력값이 한개고, 출력값이 한개
model = LR(1, 1)
print(model)
</code></pre>
<pre><code>LR(
 (linear): Linear(in_features=1, out_features=1, bias=True)
)
</code></pre>
파라미터를 살펴보면
<pre class="language-python"><code class="language-python">print(list(model.parameters()))
</code></pre>
이렇게 weight와 bias 가 무작위로 들어가 있는 것을 알 수 있다.
<pre><code>[Parameter containing:
tensor([[0.5153]], requires_grad=True), Parameter containing:
tensor([-0.4414], requires_grad=True)]
</code></pre>
이제 Linear Regression을 해보자.
<pre class="language-python"><code class="language-python">w, b = model.parameters()
def get_params():
 return w[0][0].item(), b[0].item()

def plot_fit(title):
 plt.title = title
 # weight 와 bias
 w1, b1 = get_params()
 # -30 부터 30까지
 x1 = np.array([-30, 30])
 # 선형 추정선을 그려본다.
 y1 = w1*x1 + b1
 plt.plot(x1, y1, 'r')
 plt.scatter(X, y)
 plt.show()

plot_fit('Initial Model')
</code></pre>
<img src="../images/lr2.png" alt="lr2">
회귀선,,,인지,, 추정선,,,인지 암튼지간에 제대로 그리지 못했다는 것을 알 수 있다. 그래서 이를 학습시키려고 한다.
<pre class="language-python"><code class="language-python">criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01)
</code></pre>
criterion은 <code>Mean Squred Error</code>를 , optimizer는 stochastic gradient descent (확률적 경사하강법)을 사용한다. learning_rate는 0.01 이다.
배치 경사하강법은, 매스텝에서 전체 훈련세트를 활용해서 그래디언트를 계산하기 대문에, 훈련세트가 커지면 속도가 매우 느려진다. 그러나 SGD는 매스텝에서 무작위 딱 한개의 샘플만을 처리하고, 그 샘플에 대한 그래디언트만 계산한다.
따라서 속도는 훨씬 빠르지만, 매 iteration 에서 적은 데이터만 처리하기 때문에 훨씬 불안정하다. 위아래로 요동치면서 감소하므로, 물론 시간이 지나면 최소값에 얼추 닿긴 하겠지만, 말그대로 얼추일 뿐이다.
이러한 무작위성은 국소최소값을 벗어나게 하므로 (무작위로 처리하므로), 전역 최소값을 찾을 확률이 더 크다.
암튼 지간에
<pre class="language-python"><code class="language-python"># 100 회 반복
epochs = 100
losses = []
for i in range(epochs):
 # 예측
 y_pred = model.forward(X)
 # 오차 계산
 loss = criterion(y_pred, y)
 print("epoch:", i, "loss:", loss.item())

 # 오차 누적 (계산을 위해서)
 losses.append(loss)
 # optimzer 초기화
 optimizer.zero_grad()
 # backward를 수행하여 그래디언트 계산
 loss.backward()
 # learning rate 만큼 가중치를 주어서 hyper parameter 업데이트
 optimizer.step()
</code></pre>
<pre class="language-bash"><code class="language-bash">epoch: 0 loss: 31.671594619750977
epoch: 1 loss: 22.02737808227539
epoch: 2 loss: 16.717256546020508
epoch: 3 loss: 13.792343139648438
epoch: 4 loss: 12.180136680603027
epoch: 5 loss: 11.290426254272461
epoch: 6 loss: 10.798413276672363
epoch: 7 loss: 10.525352478027344
epoch: 8 loss: 10.372870445251465
epoch: 9 loss: 10.286834716796875
...
epoch: 90 loss: 10.071357727050781
epoch: 91 loss: 10.071175575256348
epoch: 92 loss: 10.071000099182129
epoch: 93 loss: 10.070833206176758
epoch: 94 loss: 10.070671081542969
epoch: 95 loss: 10.070516586303711
epoch: 96 loss: 10.070366859436035
epoch: 97 loss: 10.07022476196289
epoch: 98 loss: 10.070086479187012
epoch: 99 loss: 10.069954872131348
</code></pre>
<pre class="language-python"><code class="language-python">plt.plot(range(epochs), losses)
plt.ylabel('Loss')
plt.xlabel('epoch')
</code></pre>
<img src="../images/lr3.png" alt="lr3">
시간이 지나면서 오차가 감소한 것을 알 수 있다.
<pre class="language-python"><code class="language-python">plot_fit("Trained Model")
</code></pre>
<img src="../images/lr4.png" alt="lr4">
이전보다 잘 학습되었다.