## 연결리스트

연결리스트, Linked List 는 각 노드들이 한 줄로 연결되어 있는 방식으로 각 노드는 데이터와 포인터 (다음 노드의 정보)를 가지고 있다. 연결리스트는 일반적인 배열과 다르게 삽입과 삭제가 `O(1)`에 가능하다는 장점이 있다. 하지만 특정 n번 째 정보를 찾는 데에는 `O(n)`시간이 걸린다는 단점도 있다.

![단일 연결 리스트](https://upload.wikimedia.org/wikipedia/commons/thumb/9/9c/Single_linked_list.png/800px-Single_linked_list.png)

![이중 연결 리스트](https://upload.wikimedia.org/wikipedia/commons/thumb/c/ca/Doubly_linked_list.png/800px-Doubly_linked_list.png)

이중 연결리스트는 이 포인터에 앞, 뒤 정보가 모두 담겨 있다.

![원형 연결 리스트](https://upload.wikimedia.org/wikipedia/commons/thumb/9/98/Circurlar_linked_list.png/800px-Circurlar_linked_list.png)

마지막 노드의 포인터가 첫 번째 노드를 가르킨다.

## 구현

먼저 가장 최초에 있는 노드를 `header`라고 부르고, 맨 마지막에 있는 노드를 `tail`이라고 부른다. 또한 일반적인 배열과는 다르게, 배열의 시작을 1로 하고, 0번째 노드는 비어있는 노드로 가정한다. 이는 구현에 있어 조금 더 편하게 하기 위함이다.

그리고 구현해볼 메소드는 다음과 같다.

- print: 리스트를 볼 수 있도록 프린트 한다.
- getAt(n): n번째 노드를 꺼낸다.
- insertAt(n, node): n번째에 `node`를 삽입한다.
- insertAfter(prev, new): `prev`이후에 `new`를 삽입한다.
- popAt(n): n번째 노드를 삭제한다.
- popAfter(prev): `prev` 이후 노드를 삭제한다.
- size: 전체 노드 개수를 계산한다.
- traverse: 전체 노드를 배열로 리턴한다.

### python

#### Node

```python
class Node:
 def __init__(self, item):
 self.data = item # 데이터 정보
 self.next = None # 다음 노드 정보
```

#### Linked List

```python
class LinkedList:
 def __init__(self):
 self.size = 0
 self.head = Node(None)
 self.tail = None

 def traverse(self):
 result = []
 curr = self.head
 while curr.next:
 curr = curr.next
 result.append(curr.data)
 return result

 def getAt(self, n):
 if n < 0 or n > self.size:
 return None

 i = 0
 curr = self.head
 while i < n:
 curr = curr.next
 i += 1
 
 return curr

 def insertAfter(self, prev, new):
 # 새로운 노드의 다음 노드는 이전 노드의 다음 정보
 new.next = prev.next
 # prev가 tail일 경우
 if prev.next is None:
 self.tail = new
 # 이제 이전 노드의 다음 노드는 사로운 노드
 prev.next = new
 self.size += 1


 def insertAt(self, n, new):
 if n < 1 or n > self.size + 1:
 return False

 # tail에 들어갈 경우
 if n != 1 and n == self.size + 1:
 prev = self.tail
 else:
 prev = self.getAt(n - 1)

 return self.insertAfter(prev, new)

 def popAfter(self, prev):
 popData = prev.next.data
 ## tail 을 제거하려고 할때 
 if prev.next.next is None: 
 self.tail = prev
 prev.next = None
 else:
 prev.next = prev.next.next
 
 self.size -= 1

 return popData

 def popAt(self, n):
 if n < 1 or n > self.size:
 raise IndexError

 # head일 경우
 if n == 1:
 prev = self.head
 else: 
 prev = self.getAt(n - 1)
 
 return self.popAfter(prev)

 def print(self):
 if self.size == 1:
 print("this linked list is empty")
 else:
 print(self.traverse())
```

## 연결리스트 연결리스트, Linked List 는 각 노드들이 한 줄로 연결되어 있는 방식으로 각 노드는 데이터와 포인터 (다음 노드의 정보)를 가지고 있다. 연결리스트는 일반적인 배열과 다르게 삽입과 삭제가 `O(1)`에 가능하다는 장점이 있다. 하지만 특정 n번 째 정보를 찾는 데에는 `O(n)`시간이 걸린다는 단점도 있다.  ![단일 연결 리스트...

알고리즘 - 연결 리스트

네이버 클라우드 플랫폼의 서비스 중 하나인 https://www.ncloud.com/product/applicationService/sens 로 SMS를 발송하는 예제. ncloud서비스를 다 써본건 아니지만, `make_signature`는 전 서비스에 다 똑같이 쓸 수 있을 것 같은 기분이다.

```python
import time
import requests
import hashlib
import hmac
import base64

def send_sms(phone_number, subject, message):
  def make_signature(access_key, secret_key, method, uri, timestmap):
    secret_key = bytes(secret_key, 'UTF-8')

    message = method + " " + uri + "\n" + timestamp + "\n" + access_key
    message = bytes(message, 'UTF-8')
    signingKey = base64.b64encode(hmac.new(secret_key, message, digestmod=hashlib.sha256).digest())
    return signingKey

  #  URL
  url = 'https://sens.apigw.ntruss.com/sms/v2/services/ncp:sms:kr:99999999999:sample/messages'
  # access key
  access_key = 'access_key'
  # secret key
  secret_key = 'secret_key'
  # uri
  uri = '/sms/v2/services/ncp:sms:kr:99999999999:sample/messages'
  timestamp = str(int(time.time() * 1000))

  body = {
    "type":"LMS",
    "contentType":"COMM",
    "countryCode":"82",
    "from":"01012345678",
    "content": message,
    "messages":[
        {
            "to": phone_number,
            "subject": subject,
            "content": message
        }
    ]
  }

  key = make_signature(access_key, secret_key, 'POST', uri, timestamp)
  headers = {
    'Content-Type': 'application/json; charset=utf-8',
    'x-ncp-apigw-timestamp': timestamp,
    'x-ncp-iam-access-key': access_key,
    'x-ncp-apigw-signature-v2': key
  }


  res = requests.post(url, json=body, headers=headers)
  print(res.json())
  return res.json()
```


네이버 클라우드 플랫폼의 서비스 중 하나인 https://www.ncloud.com/product/applicationService/sens 로 SMS를 발송하는 예제. ncloud서비스를 다 써본건 아니지만, `make_signature`는 전 서비스에 다 똑같이 쓸 수 있을 것 같은 기분이다. ```python import time import req...

[Python] Send ncloud sms message

## Image Representation & Classification

### Images as Grids of Pixels

```python
import numpy as np
from skimage import io
import matplotlib.image as mpimg

import matplotlib.pyplot as plt
import cv2

import urllib

%matplotlib inline
```

먼저 이미지를 불러온다.

```python
waymo_car_url = 'https://zdnet2.cbsistatic.com/hub/i/r/2018/01/22/e270d68c-c028-421a-bc5b-5d2a9a9458d1/resize/770xauto/50e9d2f0fc86841ba455489d50651291/google-waymo-self-driving-atlanta.png'
f = urllib.request.urlopen(waymo_car_url)
image = mpimg.imread(f)

print('Image dimensions:', image.shape)
```

```
Image dimensions: (410, 770, 4)
```

```python
# 이미지를 회색으로 바꾼다.
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
plt.imshow(gray_image, cmap='gray')
```

![waymo-gray](../images/01.png)

```python
# 특정 좌표의 grayscale
x = 400
y = 300

print(gray_image[y,x])
```

```
0.543404
```

```python
# 맥시멈 / 미니멈 grayscale

max_val = np.amax(gray_image)
min_val = np.amin(gray_image)

print('Max: ', max_val)
print('Min: ', min_val)
```

```
Max: 0.9646824
Min: 0.040556863
```

### RGB colorspace

```python
plt.imshow(image)
```

![waymo](../images/02.png)

```python
## 각각의 RGB영역 확보
r = image[:,:,0]
g = image[:,:,1]
b = image[:,:,2]
```

```python
fx, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20,10))
ax1.set_title('R channel')
ax1.imshow(r, cmap='gray')
ax2.set_title('G channel')
ax2.imshow(g, cmap='gray')
ax3.set_title('B channel')
ax3.imshow(b, cmap='gray')
```

![waymo-rgb](../images/03.png)

### Color Threshold, Bluescreen

파란색 크로마키에 있는 사진을 합성하는 과정이다.

![image](https://ak5.picdn.net/shutterstock/videos/548875/thumb/1.jpg)

```python
cromakey_blue = 'https://ak5.picdn.net/shutterstock/videos/548875/thumb/1.jpg'
f = urllib.request.urlopen(cromakey_blue)
image = mpimg.imread(f, 0)
print('This image is:', type(image), 'with dimensions:', image.shape)
```

```
This image is: <class 'numpy.ndarray'> with dimensions: (480, 852, 3)
```

```python
# 이미지 복사
image_copy = np.copy(image)

# BGR이미지를 RGB로 변환
image_copy = cv2.cvtColor(image_copy, cv2.COLOR_BGR2RGB)

# 복사된 이미지 보여주기
plt.imshow(image_copy)
```

![red](../images/04.png)

```python
lower_blue = np.array([0,0,200])
upper_blue = np.array([250,250,255])

# 마스킹될 영역을 선택한다.
mask = cv2.inRange(image, lower_blue, upper_blue)

# 마스킹 이미지 표시
plt.imshow(mask, cmap='gray')
```

![mask](../images/05.png)

```python
# 이미지를 카피한다음
masked_image = np.copy(image_copy)
# 마스킹 영역을 제외하고 모두 검정색으로 바꾼다면
masked_image[mask != 0] = [0, 0, 0]
plt.imshow(masked_image)
```

![mask](../images/06.png)

효과적으로 파란색 영역을 제거한 것을 알 수 있다. 여기에 배경을 합성해보자.

```python
space_url = 'https://images.unsplash.com/photo-1496715976403-7e36dc43f17b?ixlib=rb-1.2.1&w=1000&q=80'
sf = urllib.request.urlopen(space_url)
image = np.asarray(bytearray(sf.read()), dtype="uint8")
background_image = cv2.imdecode(image, cv2.IMREAD_COLOR)
background_image = cv2.cvtColor(background_image, cv2.COLOR_BGR2RGB)

crop_background = background_image[0:480, 0:852]
# 이번엔 반대로 마스킹 해야할 영역을 검정색으로 처리한다.
crop_background[mask == 0] = [0, 0, 0]
plt.imshow(crop_background)
```

![background](../images/07.png)

```python
# 두 이미지를 합치면
complete_image = masked_image + crop_background
plt.imshow(complete_image)
```

![complete](../images/08.png)

## Image Representation & Classification ### Images as Grids of Pixels  ```python import numpy as np from skimage import io import matplotlib.image as mpimg  import matplotlib.pyplot as plt import cv...

Computer Vision 01) - Image Representation

<h2 id="image-representation--classification">Image Representation &#x26; Classification</h2>
<h3 id="images-as-grids-of-pixels">Images as Grids of Pixels</h3>
<pre class="language-python"><code class="language-python">import numpy as np
from skimage import io
import matplotlib.image as mpimg

import matplotlib.pyplot as plt
import cv2

import urllib

%matplotlib inline
</code></pre>
먼저 이미지를 불러온다.
<pre class="language-python"><code class="language-python">waymo_car_url = 'https://zdnet2.cbsistatic.com/hub/i/r/2018/01/22/e270d68c-c028-421a-bc5b-5d2a9a9458d1/resize/770xauto/50e9d2f0fc86841ba455489d50651291/google-waymo-self-driving-atlanta.png'
f = urllib.request.urlopen(waymo_car_url)
image = mpimg.imread(f)

print('Image dimensions:', image.shape)
</code></pre>
<pre><code>Image dimensions: (410, 770, 4)
</code></pre>
<pre class="language-python"><code class="language-python"># 이미지를 회색으로 바꾼다.
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
plt.imshow(gray_image, cmap='gray')
</code></pre>
<img src="../images/01.png" alt="waymo-gray">
<pre class="language-python"><code class="language-python"># 특정 좌표의 grayscale
x = 400
y = 300

print(gray_image[y,x])
</code></pre>
<pre><code>0.543404
</code></pre>
<pre class="language-python"><code class="language-python"># 맥시멈 / 미니멈 grayscale

max_val = np.amax(gray_image)
min_val = np.amin(gray_image)

print('Max: ', max_val)
print('Min: ', min_val)
</code></pre>
<pre><code>Max: 0.9646824
Min: 0.040556863
</code></pre>
<h3 id="rgb-colorspace">RGB colorspace</h3>
<pre class="language-python"><code class="language-python">plt.imshow(image)
</code></pre>
<img src="../images/02.png" alt="waymo">
<pre class="language-python"><code class="language-python">## 각각의 RGB영역 확보
r = image[:,:,0]
g = image[:,:,1]
b = image[:,:,2]
</code></pre>
<pre class="language-python"><code class="language-python">fx, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20,10))
ax1.set_title('R channel')
ax1.imshow(r, cmap='gray')
ax2.set_title('G channel')
ax2.imshow(g, cmap='gray')
ax3.set_title('B channel')
ax3.imshow(b, cmap='gray')
</code></pre>
<img src="../images/03.png" alt="waymo-rgb">
<h3 id="color-threshold-bluescreen">Color Threshold, Bluescreen</h3>
파란색 크로마키에 있는 사진을 합성하는 과정이다.
<img src="https://ak5.picdn.net/shutterstock/videos/548875/thumb/1.jpg" alt="image">
<pre class="language-python"><code class="language-python">cromakey_blue = 'https://ak5.picdn.net/shutterstock/videos/548875/thumb/1.jpg'
f = urllib.request.urlopen(cromakey_blue)
image = mpimg.imread(f, 0)
print('This image is:', type(image), 'with dimensions:', image.shape)
</code></pre>
<pre><code>This image is: &#x3C;class 'numpy.ndarray'> with dimensions: (480, 852, 3)
</code></pre>
<pre class="language-python"><code class="language-python"># 이미지 복사
image_copy = np.copy(image)

# BGR이미지를 RGB로 변환
image_copy = cv2.cvtColor(image_copy, cv2.COLOR_BGR2RGB)

# 복사된 이미지 보여주기
plt.imshow(image_copy)
</code></pre>
<img src="../images/04.png" alt="red">
<pre class="language-python"><code class="language-python">lower_blue = np.array([0,0,200])
upper_blue = np.array([250,250,255])

# 마스킹될 영역을 선택한다.
mask = cv2.inRange(image, lower_blue, upper_blue)

# 마스킹 이미지 표시
plt.imshow(mask, cmap='gray')
</code></pre>
<img src="../images/05.png" alt="mask">
<pre class="language-python"><code class="language-python"># 이미지를 카피한다음
masked_image = np.copy(image_copy)
# 마스킹 영역을 제외하고 모두 검정색으로 바꾼다면
masked_image[mask != 0] = [0, 0, 0]
plt.imshow(masked_image)
</code></pre>
<img src="../images/06.png" alt="mask">
효과적으로 파란색 영역을 제거한 것을 알 수 있다. 여기에 배경을 합성해보자.
<pre class="language-python"><code class="language-python">space_url = 'https://images.unsplash.com/photo-1496715976403-7e36dc43f17b?ixlib=rb-1.2.1&#x26;w=1000&#x26;q=80'
sf = urllib.request.urlopen(space_url)
image = np.asarray(bytearray(sf.read()), dtype="uint8")
background_image = cv2.imdecode(image, cv2.IMREAD_COLOR)
background_image = cv2.cvtColor(background_image, cv2.COLOR_BGR2RGB)

crop_background = background_image[0:480, 0:852]
# 이번엔 반대로 마스킹 해야할 영역을 검정색으로 처리한다.
crop_background[mask == 0] = [0, 0, 0]
plt.imshow(crop_background)
</code></pre>
<img src="../images/07.png" alt="background">
<pre class="language-python"><code class="language-python"># 두 이미지를 합치면
complete_image = masked_image + crop_background
plt.imshow(complete_image)
</code></pre>
<img src="../images/08.png" alt="complete">

Pytorch - 08) CIFAR 10

CIFAR 10 는 열가지 단어별 이미지가 있는 데이터 셋이다. 기존에 손글씨를 분류하는 것 보다는 확실히 어려운 작업이 될 것이다.

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

## 전처리 작업

```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

transformer = transforms.Compose([transforms.Resize((32, 32)),
                                  transforms.ToTensor(),
                                  transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
                                 ])

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

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)

def im_convert(tensor):
  image = tensor.clone().detach().numpy()
  image = image.transpose(1, 2, 0)
  image = image * np.array([0.5, 0.5, 0.5] + np.array([0.5, 0.5, 0.5]))
  image = image.clip(0, 1)
  return image

classes = ("plane", "car", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck")

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(classes[labels[i].item()])CIFA
```

![CIFAR10-1](../images/CIFAR10-1.png)

## Optimizer 와 Criterion

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

## 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.to(device)
    labels = labels.to(device)
    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.to(device)
        val_label = val_label.to(device)
        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}, acc: {:5f}".format(epoch_loss, epoch_acc))
    print("validation loss: {:.5f}, acc: {:5f}".format(val_epoch_loss, val_epoch_acc))
```

## 1st try

LeNet을 활용하여, 기존에 손글씨를 분류했을 때 썼던 파라미터 그대로 해보자.

### Model

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

  def __init__(self):
    super().__init__()
    # RGB세개 1채널, 20개 특징 추출, filter 크기, stride 1
    self.conv1 = nn.Conv2d(3, 20, 5, 1)
    # 전에서 20개
    self.conv2 = nn.Conv2d(20, 50, 5, 1)
    self.fc1 = nn.Linear(5*5*50, 500)
    # 0.5 가 권장 할 만하대
    self.dropout1 = nn.Dropout(0.5)
    self.fc2 = nn.Linear(500, 10)

  def forward(self, x):
    x = F.relu(self.conv1(x))
    x = F.max_pool2d(x, 2, 2)
    x = F.relu(self.conv2(x))
    x = F.max_pool2d(x, 2, 2)
    # flatten
    x = x.view(-1, 5*5*50)
    x = F.relu(self.fc1(x))
    x = self.dropout1(x)
    x = self.fc2(x)
    return x
```

### 결과

```bash
===================================================
epoch:  1
training loss: 1.51251, acc: 44.908001
validation loss: 1.27473, acc: 54.189999
===================================================
epoch:  2
training loss: 1.16539, acc: 58.480003
validation loss: 1.07463, acc: 61.829998
===================================================
epoch:  3
training loss: 1.00764, acc: 64.464005
validation loss: 1.04436, acc: 63.349998
===================================================
epoch:  4
training loss: 0.90411, acc: 68.162003
validation loss: 0.96203, acc: 66.619995
===================================================
epoch:  5
training loss: 0.82512, acc: 71.142006
validation loss: 0.92654, acc: 67.889999
===================================================
epoch:  6
training loss: 0.76343, acc: 73.138000
validation loss: 0.90890, acc: 69.029999
===================================================
epoch:  7
training loss: 0.70817, acc: 75.176003
validation loss: 0.90005, acc: 69.639999
===================================================
epoch:  8
training loss: 0.66021, acc: 76.596001
validation loss: 0.91046, acc: 69.409996
===================================================
epoch:  9
training loss: 0.61744, acc: 78.116005
validation loss: 0.91911, acc: 69.799995
===================================================
epoch:  10
training loss: 0.57813, acc: 79.522003
validation loss: 0.94296, acc: 69.189995
===================================================
epoch:  11
training loss: 0.53510, acc: 80.990005
validation loss: 0.95957, acc: 69.209999
===================================================
epoch:  12
training loss: 0.50244, acc: 82.116005
validation loss: 0.98390, acc: 69.419998
```

![CIFAR10-2](../images/CIFAR10-2.png)

![CIFAR10-3](../images/CIFAR10-3.png)

### 총평

딱봐도 Overfitting이 일어났고, 정확도도 구리다.

## 2nd Model

Convolution을 하나더 추가해서, 특징을 조금더 뽑아내는 방향으로 바꿔보자.

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

  def __init__(self):
    super().__init__()
    # 32px 이었다가, conv를 거치면서 절반으로 감소
    self.conv1 = nn.Conv2d(3, 16, 3, 1, padding=1)
    self.conv2 = nn.Conv2d(16, 32, 3, 1, padding=1)
    self.conv3 = nn.Conv2d(32, 64, 3, 1, padding=1)
    self.fc1 = nn.Linear(4*4*64, 500)
    self.dropout1 = nn.Dropout(0.5)
    self.fc2 = nn.Linear(500, 10)

  def forward(self, x):
    x = F.relu(self.conv1(x))
    x = F.max_pool2d(x, 2, 2)
    x = F.relu(self.conv2(x))
    x = F.max_pool2d(x, 2, 2)
    x = F.relu(self.conv3(x))
    x = F.max_pool2d(x, 2, 2)
    x = x.view(-1, 4*4*64)
    x = F.relu(self.fc1(x))
    x = self.dropout1(x)
    x = self.fc2(x)
    return x
```

첫번째 Conv에서는 입력채널이 3개, 추출할 filter는 3개이며 filter의 크기는 3, stride는 1이다. 그리고 padding을 1씩 넣어서 크기가 줄어드는 것을 방지했다.

따라서 각각의 convolution을 거칠 때마다 입력값이 절반으로 줄어들게 된다. (MaxPooling 사이즈가 2, 2 이므로)

| input | conv1 | pool1 | conv2 | pool2 | conv3 | pool3 |
| :---: | :---: | :---: | :---: | :---: | :---: | :---: |
|  32   |  32   |  16   |  16   |   8   |   8   |   4   |

### 결과

```bash
===================================================
epoch:  1
training loss: 1.51715, acc: 44.712002
validation loss: 1.25653, acc: 55.230000
===================================================
epoch:  2
training loss: 1.16654, acc: 58.526001
validation loss: 1.09924, acc: 60.959999
===================================================
epoch:  3
training loss: 1.02785, acc: 63.822002
validation loss: 1.02541, acc: 64.019997
===================================================
epoch:  4
training loss: 0.91954, acc: 67.690002
validation loss: 1.01354, acc: 64.529999
===================================================
epoch:  5
training loss: 0.84753, acc: 70.680000
validation loss: 0.92927, acc: 67.639999
===================================================
epoch:  6
training loss: 0.79165, acc: 71.830002
validation loss: 0.88947, acc: 69.279999
===================================================
epoch:  7
training loss: 0.73852, acc: 73.806000
validation loss: 0.92085, acc: 68.559998
===================================================
epoch:  8
training loss: 0.68945, acc: 75.670006
validation loss: 0.91607, acc: 68.529999
===================================================
epoch:  9
training loss: 0.64567, acc: 77.178001
validation loss: 0.93162, acc: 69.290001
===================================================
epoch:  10
training loss: 0.61021, acc: 78.222000
validation loss: 0.89344, acc: 70.389999
===================================================
epoch:  11
training loss: 0.57332, acc: 79.376007
validation loss: 0.93702, acc: 70.189995
===================================================
epoch:  12
training loss: 0.53661, acc: 80.696007
validation loss: 0.92468, acc: 70.689995
```

![CIFAR10-4](../images/CIFAR10-4.png)

![CIFAR10-5](../images/CIFAR10-5.png)

정확도가 향상된 모습이지만, 여전히 Overfitting이 발생하고 있다.

## 3rd try

Data Augmentation, 데이터에 인위적인 변화를 주어서 학습이 용이하게 끔 해보자.

![data-augmentation](https://www.researchgate.net/publication/319413978/figure/fig2/AS:533727585333249@1504261980375/Data-augmentation-using-semantic-preserving-transformation-for-SBIR.png)

```python
transform_train = transforms.Compose([transforms.Resize((32, 32)),
                                      transforms.RandomHorizontalFlip(),
                                      transforms.RandomRotation(10),
                                      transforms.RandomAffine(0, shear=10, scale=(0.8, 1.2)),
                                      transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
                                      transforms.ToTensor(),
                                      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
                                     ])

transformer = transforms.Compose([transforms.Resize((32, 32)),
                                  transforms.ToTensor(),
                                  transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
                                 ])


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

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)
```

`transform_train`에 적용된 augmentation을 살펴보자

- `transforms.RandomHorizontalFlip()` 0.5확률로 이미지를 뒤집음
- `transforms.RandomRotation(10)` 10도 이하로 랜덤하게 기울인다.
- `transforms.RandomAffine(0, shear=10, scale=(0.8, 1.2)` 기하학(...)에서 쓰이는 아핀변환이다.
  ![CIFAR10-6](../images/CIFAR10-6.png)
- `transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2)` 밝기, 대비, 채도를 랜덤하게 조절한다.

### 결과

```bash
===================================================
epoch:  1
training loss: 1.69155, acc: 38.206001
validation loss: 1.47858, acc: 46.969997
===================================================
epoch:  2
training loss: 1.39742, acc: 49.534004
validation loss: 1.23282, acc: 54.919998
===================================================
epoch:  3
training loss: 1.27040, acc: 54.270004
validation loss: 1.14570, acc: 58.629997
===================================================
epoch:  4
training loss: 1.17016, acc: 58.068005
validation loss: 1.06811, acc: 61.609997
===================================================
epoch:  5
training loss: 1.11306, acc: 60.408005
validation loss: 1.02522, acc: 63.559998
===================================================
epoch:  6
training loss: 1.07079, acc: 61.996002
validation loss: 0.98546, acc: 65.559998
===================================================
epoch:  7
training loss: 1.01881, acc: 63.968002
validation loss: 0.91596, acc: 68.080002
===================================================
epoch:  8
training loss: 0.98842, acc: 65.208000
validation loss: 0.89914, acc: 68.000000
===================================================
epoch:  9
training loss: 0.96484, acc: 65.940002
validation loss: 0.88494, acc: 68.619995
===================================================
epoch:  10
training loss: 0.93930, acc: 66.904007
validation loss: 0.88999, acc: 68.830002
===================================================
epoch:  11
training loss: 0.91366, acc: 67.650002
validation loss: 0.84115, acc: 70.619995
===================================================
epoch:  12
training loss: 0.89831, acc: 68.562004
validation loss: 0.83667, acc: 70.750000
```

![CIFAR10-7](../images/CIFAR10-7.png)

![CIFAR10-8](../images/CIFAR10-8.png)

어떻게 하면 정확도를 더 올릴 수 있을까~~~?


Pytorch - 08) CIFAR 10 CIFAR 10 는 열가지 단어별 이미지가 있는 데이터 셋이다. 기존에 손글씨를 분류하는 것 보다는 확실히 어려운 작업이 될 것이다.   ![CIFAR10](../images/CIFAR10.png)  ## 전처리 작업  ```python import torch import matplotlib.py...

Pytorch 08) - CIFAR 10 학습

Pytorch - 07) Convolutional Neural Network (2)

이번에는 코드로 구현해보자.

```python
class LeNet(nn.Module):
  
  def __init__(self):
    super().__init__()
    # 흑백이라 1채널, 20개 특징 추출, filter 크기, stride 1
    self.conv1 = nn.Conv2d(1, 20, 5, 1)
    # 전에서 20개
    self.conv2 = nn.Conv2d(20, 50, 5, 1)
    self.fc1 = nn.Linear(4*4*50, 500)
    # 0.5 가 권장 할 만하대
    self.dropout1 = nn.Dropout(0.5)
    self.fc2 = nn.Linear(500, 10)

  def forward(self, x):
    x = F.relu(self.conv1(x))
    x = F.max_pool2d(x, 2, 2)
    x = F.relu(self.conv2(x))
    x = F.max_pool2d(x, 2, 2)
    # flatten
    x = x.view(-1, 4 * 4 * 50)
    x = F.relu(self.fc1(x))
    x = self.dropout1(x)
    x = self.fc2(x)
    return x
```

먼저 첫번째 conv1애서는 1개의 필터, 20개의 특징을 추출 해 낼 것이다. 필터는 5x5 크기로, 이미지가 그리 크지 않으므로 stride는 1로 할것이다. 

두번 conv2는 입력값이 20이고 (이전 conv의 ouput), 50개의 특징을 같은 크기와 stride로 찾는다.

그리고 마지막에는 fully conncted layer를 linear로 취한다. 여기서 주목할 것은 첫번째 fc의 input 값이다. 필터의 크기가 5x5 이기 때문에, 5x5필터는 width 와 heigt를 각각 4씩 줄인다. 

- 1x1 필터: 원래크기 유지
- 2x2 필터: 크기 1 감소
- 3x3 필터: 크기 2 감소
- 4x4 필터: 크기 3 감소
- 5x5 필터: 크기 4 감소

따라서 각 conv layer를 거칠 때마다 크기가 4씩 줄어들게 된다. 

그리고 max_pool2d를 2,2 크기로 사용할 것이므로 크기는 절반으로 줄어들게 된다. 요약하자면 다음과 같다.

| input | conv1 | pool1 | conv2 | pool2 |
|:-----:|:-----:|:-----:|:-----:|:-----:|
| 28    | 24    | 12    | 8     | 4     |

4x4 크기의 이미지가, 50개의 특징으로 나오게 되므로, fully connected 의 input은 $$4\times 4 \times 50$$이 된다. 그리고 이를 500개의 output 으로 만들 것이다. 그리고 과적합을 방지하기 위하여, dropout을 0.5비율로 적용했다. 마지막 fc에서는, 10개의 숫자를 판별해야 하므로 500, 10을 적용했다.

활성화 함수로는 relu를 사용하였고, fully connected로 넘기기 위해, 평탄화를 작업(view적용)을 한다. 몇줄이 생길지는 모르겠지만, 암튼 row를 $$4\times 4 \times 50$$를 맞추기 위하여 `.view(-1, 4*4*50)` 을 적용했다. fc1을 쓰고, 그 사이에 dropout을 하고, 마지막에는 relu없이 값을 내보낸다.

이 것이 바로 [LeNet](https://www.researchgate.net/figure/Structure-of-LeNet-5_fig1_312170477)이다.

![LeNet](https://www.researchgate.net/profile/Yiren_Zhou/publication/312170477/figure/fig1/AS:448817725218816@1484017892071/Structure-of-LeNet-5.png)

### training

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

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.to(device)
    labels = labels.to(device)
    # 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.to(device)
        val_label = val_label.to(device)
        # 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}, acc: {:5f}".format(epoch_loss, epoch_acc))
    print("validation loss: {:.5f}, acc: {:5f}".format(val_epoch_loss, val_epoch_acc))
```

```
===================================================
epoch:  1
training loss: 0.57984, acc: 84.566666
validation loss: 0.17183, acc: 95.019997
===================================================
epoch:  2
training loss: 0.14266, acc: 95.785004
validation loss: 0.10837, acc: 96.729996
===================================================
epoch:  3
training loss: 0.09881, acc: 97.026672
validation loss: 0.07965, acc: 97.529999
===================================================
epoch:  4
training loss: 0.07957, acc: 97.633339
validation loss: 0.06295, acc: 97.970001
===================================================
epoch:  5
training loss: 0.06528, acc: 97.988335
validation loss: 0.05194, acc: 98.389999
===================================================
epoch:  6
training loss: 0.05605, acc: 98.290001
validation loss: 0.04634, acc: 98.419998
===================================================
epoch:  7
training loss: 0.05048, acc: 98.465004
validation loss: 0.04152, acc: 98.779999
===================================================
epoch:  8
training loss: 0.04411, acc: 98.653336
validation loss: 0.03743, acc: 98.820000
===================================================
epoch:  9
training loss: 0.03852, acc: 98.820000
validation loss: 0.03573, acc: 98.869995
===================================================
epoch:  10
training loss: 0.03615, acc: 98.881668
validation loss: 0.03582, acc: 98.839996
===================================================
epoch:  11
training loss: 0.03363, acc: 98.976669
validation loss: 0.03422, acc: 98.820000
===================================================
epoch:  12
training loss: 0.03024, acc: 99.063339
validation loss: 0.03219, acc: 98.879997
```

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

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

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

약 99% 의 정확도로 이미지를 분류하였으며, 이전에 제대로 구별하지 못한 이미지도 제대로 구별해 내었다.


Pytorch - 07) Convolutional Neural Network (2) 이번에는 코드로 구현해보자.  ```python class LeNet(nn.Module):      def __init__(self):     super().__init__()     # 흑백이라 1채널, 20개 특징 추출, filter 크기, stride 1     se...

yceffort

python

알고리즘 - 연결 리스트

[Python] Send ncloud sms message

Computer Vision 01) - Image Representation

Pytorch 08) - CIFAR 10 학습

Pytorch 07) - Convolutional Neural Network (2)