웹 개발 메모장

[자바스크립트] 채팅 구현 코드 (프론트)

도로롱주 — Mon, 18 Nov 2019 18:01:42 +0900

채팅 구현 코드(프론트)

웹소켓 통신 부분을 제외한 프론트단의 코드입니다.

CSS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

*{ margin: 0; padding: 0; }
 
.chat_wrap .header { font-size: 14px; padding: 15px 0; background: #F18C7E; color: white; text-align: center;  }
 
.chat_wrap .chat { padding-bottom: 80px; }
.chat_wrap .chat ul { width: 100%; list-style: none; }
.chat_wrap .chat ul li { width: 100%; }
.chat_wrap .chat ul li.left { text-align: left; }
.chat_wrap .chat ul li.right { text-align: right; }
 
.chat_wrap .chat ul li > div { font-size: 13px;  }
.chat_wrap .chat ul li > div.sender { margin: 10px 20px 0 20px; font-weight: bold; }
.chat_wrap .chat ul li > div.message { display: inline-block; word-break:break-all; margin: 5px 20px; max-width: 75%; border: 1px solid #888; padding: 10px; border-radius: 5px; background-color: #FCFCFC; color: #555; text-align: left; }
 
.chat_wrap .input-div { position: fixed; bottom: 0; width: 100%; background-color: #FFF; text-align: center; border-top: 1px solid #F18C7E; }
.chat_wrap .input-div > textarea { width: 100%; height: 80px; border: none; padding: 10px; }
 
.format { display: none; }
Colored by Color Scripter

cs

HTML

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

<div class="chat_wrap">
    <div class="header">
        CHAT
    </div>
    <div class="chat">
        <ul>
            <!-- 동적 생성 -->
        </ul>
    </div>
    <div class="input-div">
        <textarea placeholder="Press Enter for send message."></textarea>
    </div>
 
    <!-- format -->
 
    <div class="chat format">
        <ul>
            <li>
                <div class="sender">
                    <span></span>
                </div>
                <div class="message">
                    <span></span>
                </div>
            </li>
        </ul>
    </div>
</div>
Colored by Color Scripter

cs

JAVASCRIPT

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

const Chat = (function(){
    const myName = "blue";
 
    // init 함수
    function init() {
        // enter 키 이벤트
        $(document).on('keydown', 'div.input-div textarea', function(e){
            if(e.keyCode == 13 && !e.shiftKey) {
                e.preventDefault();
                const message = $(this).val();
 
                // 메시지 전송
                sendMessage(message);
                // 입력창 clear
                clearTextarea();
            }
        });
    }
 
    // 메세지 태그 생성
    function createMessageTag(LR_className, senderName, message) {
        // 형식 가져오기
        let chatLi = $('div.chat.format ul li').clone();
 
        // 값 채우기
        chatLi.addClass(LR_className);
        chatLi.find('.sender span').text(senderName);
        chatLi.find('.message span').text(message);
 
        return chatLi;
    }
 
    // 메세지 태그 append
    function appendMessageTag(LR_className, senderName, message) {
        const chatLi = createMessageTag(LR_className, senderName, message);
 
        $('div.chat:not(.format) ul').append(chatLi);
 
        // 스크롤바 아래 고정
        $('div.chat').scrollTop($('div.chat').prop('scrollHeight'));
    }
 
    // 메세지 전송
    function sendMessage(message) {
        // 서버에 전송하는 코드로 후에 대체
        const data = {
            "senderName"    : "blue",
            "message"        : message
        };
 
        // 통신하는 기능이 없으므로 여기서 receive
        resive(data);
    }
 
    // 메세지 입력박스 내용 지우기
    function clearTextarea() {
        $('div.input-div textarea').val('');
    }
 
    // 메세지 수신
    function resive(data) {
        const LR = (data.senderName != myName)? "left" : "right";
        appendMessageTag("right", data.senderName, data.message);
    }
 
    return {
        'init': init
    };
})();
 
$(function(){
    Chat.init();
});
Colored by Color Scripter

cs

2. CGAN(Conditional Generative Adversarial Network)

도로롱주 — Wed, 7 Aug 2019 09:11:37 +0900

Abstract
Introduction
Conditional Adversarial nets
Experiments
References

Abstract

생성모델을 학습시키는 GAN을 기반으로 GAN의 조건부(Conditional) 버전으로 기존 모델에 간단히 y를 추가하여 만든 적대적 신경망을 소개합니다.

CGAN이 class label(0~9)에 맞는 MNIST 이미지를 생성할 수 있음을 보여줍니다.

또한 이 모델이 multi-modal 모델에 어떻게 사용될 지, 또 이미지 태깅에 어떻게 응용 가능할 지를 설명합니다.

Introduction

CGAN

GAN 모델과 비교하여 c가 추가되었고 나머지는 같습니다.
C는 class label 등에 기반할 수 있습니다.
original GAN에서는 불가능 했었던, 생성 데이터에 대한 제어가 가능해 집니다.

Conditional Adversarial nets

Original Gan

original gan 목적함수

CGAN

CGAN 목적함수

위는 GAN과 CGAN의 목적함수입니다. GAN에서 input 데이터가 x 였다면, CGAN에서는 input 데이터가 x|y 입니다.

조건부 데이터를 입력으로 받는다는 이야기 입니다.

original GAN에서 input 데이터에 추가정보 y라는 조건이 붙는다면(y를 같이 input한다면) 조건부 생성 모델을 만들 수 있습니다.

y는 어떤 보조정보라도 될 수 있는데, class label이나 다른 modality의 데이터 등이 될 수 있습니다.

Experiment

CGAN

실험 결과로 위 이미지와 같이 condition을 통해 0~9 중 원하는 이미지를 생성할 수 있습니다.

소스코드: https://github.com/djkim1991/cgan

1. GAN: Generative Adversarial Networks

도로롱주 — Fri, 2 Aug 2019 20:43:45 +0900

Abstract
Introduction
Adversarial Nets
Theoritical Results
Experiments
Advantages and disadvantages
Conclusions and future work
References

Abstract

이 논문에서는 적대적으로 동작하는 두 생성 모델을 동시에 학습시키는 새 framework를 제안합니다.

G(생성자)는 원본 data distribution을 흉내 내고, D(판별자)는 data가 원본 data인지, G(생성자)가 생성한 data인지 판별합니다. G(생성자)의 목적은 D(판별자)를 속이는 것이 목적이고, D(판별자)는 data를 정확하게 판별하는 것이 목적입니다.

따라서, D(판별자)의 정확도는 종국에 50%가 됩니다.

Introduction

GAN

적대적인 두 네트워크를 학습시킵니다. D는 data가 X에서 온 것인지, G에서 온 것인지 잘 판별하는 것이 목표이고, G는 D를 속일 정도로 data를 잘 생성하는 것이 목표입니다.

다층 퍼셉트론을 사용하면, 다른 복잡한 네트워크 필요 없이 forward/backpropagation 만으로도 학습이 가능합니다.

Adversarial Nets

GAN 목적 함수

G는 V를 최소화 하려고 한다.

D는 V를 최소화 하려고 한다.

E: 기댓값

X~Pdata(x): 원본 데이터 분포에서 왔을 때,

X~Pz(z): 생성 데이터 분포에서 왔을 때

학습시킬 때, inner loop에서 G를 최적화하는 것은 매우 많은 계산을 필요로 하고, 유한한 데이터셋에서는 overfitting을 초래하기 때문에, k step만큼 D를 최적화 시키고 G는 1 step만 최적화 하도록 합니다.

학습 초반에는 G가 형편없기 때문에 D는 판별을 아주 잘하게 됩니다.

G가 log(1-D(G(z))를 최소화하도록 하는 것 보다는, log(D(G(x))를 최대화하도록 하는 것이 더 학습이 잘됩니다.

이유는 G가 너무 형편없는 경우, log(1-D(G(z))의 gradient 값이 너무 작아 학습이 느리기 때문입니다.

GAN 학습과정

검은 점선: 원본 데이터의 분포

초록 실선: G가 생성한 분포

파란 점선: D가 판별한 결과

화살표: x = G(z) mapping

(a) 초기상태, G, D 모두 학습전

(b) D 학습 후, 판별을 잘하고 있다.

(d) 충분한 학습 후, G가 생성한 분포가 원본의 분포와 거의 동일하며, D의 판별 값이 0.5에 수렴한다.

Theoretical Results

Theoretical Results

Experiments

MNIST, TFD, CIFAR-10에 대해 학습을 진행한 결과가 다음과 같습니다.

GAN 학습 결과

소스코드: https://github.com/djkim1991/gan

Adventages and disadvantages

장점

- backpropagation 만으로 학습이 가능합니다.(마르코프 체인이 필요 없다.)

- 다양한 함수들이 모델들을 모델에 접목하여 활용도가 뛰어나고 발전 가능성이 높습니다.

단점

- 판별자 D와 생성자 G가 균형을 잘 맞추어 성능이 향상되어야 하는데, 정답이 없고 쉽지 않습니다.

- 모델이 실제 데이터 분포를 따라가지 못하고 그저 뭉뚱그리기만 하면서, 다양성을 잃을 수 있습니다.

예를 들면, MNIST로 학습하는 경우 단순히 목적함수의 loss만 줄이는 방향으로 설정되어, 0~9 총 10가지 숫자를 골고루 생성하는 것이 아니라 특정 숫자만 만들려고 하는 경우입니다.

Conclusions and future work

사실 2014년 처음 발표된 original GAN은 학습이 불안정하고 고해상도 이미지는 생성하지 못하는 한계를 갖고 있습니다.

이러한 문제를 보완하기 위해 GAN 이후로 수많은 발전된 GAN이 연구되어 발표되었습니다.

Generative Adversarial Networks 발전 스토리

도로롱주 — Sun, 28 Jul 2019 19:07:13 +0900

Ian Goodfellow가 2014년 Generative Adversarial Networks(GAN)을 꿈꾸었을 때, 그 분야가 이렇게까지 빠른 발전이 있을거라고는 생각하지 못했을 것입니다.

아래 사진들을 봅시다.

https://regmedia.co.uk/2018/10/01/biggan.jpg

이 이미지들은 100% 가짜 이미지입니다.

가짜 이미지라는 것이, 포토샵같이 사람이 인위적으로 작업한 이미지를 말하는 것이 아닙니다.

오직 엄청난 양의 덧셈, 곱셈등 GPU 연산만을 통해 만들어낸 가짜 이미지입니다.

이 이미지들을 만들어낸 알고리즘이 GAN입니다.

2014년 발표된 기본 GAN의 모든 개선 알고리즘을 살펴보는 것은 현실적으로 매우 힘듭니다.

대신 지난 몇 년 동안 GAN 연구에서 멋진 결과를 나타낸 몇몇 연구들을 선택해서 살펴봅시다.

("Convolution"이나 "Wasserstein distance"등의 개념들은 자세히 설명하기보다는 참고할 수 있는 코드를 링크하겠습니다.)

아래는 GAN landscape를 표현한 그림입니다.

GAN landscape

1. GAN: Generative Adversarial Networks

2. CGAN: Conditional Generative Adversarial Network

3. DCGAN: Deep Convolutional Generative Adversarial Network

4. CycleGAN

5. CoGAN: Coupled Generative Adversarial Networks

6. ProGAN: Progressive Generative Adversarial Networks

7. WGAN: Wassertein Generative Adversarial Networks

8. SAGAN: Self-Attention Generative Adversarial Networks

9. BigGAN: Big Generative Adversarial Networks

10. StyleGAN: Style-based Generative Adversarial Networks

원문: https://blog.floydhub.com/gans-story-so-far/

7. nn.Sequential을 사용한 신경망 구현

도로롱주 — Mon, 22 Jul 2019 22:47:50 +0900

nn.Sequantial을 사용한 신경망 구현(앞서 정의한 신경망 모델(#6 )의 연장)

nn.Sequantial을 사용하지 않은 신경망

아래 신경망에서는 __init__() 에서 사용할 네트워크 모델들을 정의 해주고,
forward() 함수에서 그 모델들을 사용하여 순전파 로직을 구현했습니다.

class MyNeuralNetwork(nn.Module):
    def __init__(self):
        super(MyNeuralNetwork, self).__init__()

        self.conv1 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=5)
        self.conv2 = nn.Conv2d(in_channels=64, out_channels=30, kernel_size=5)
        self.fc1 = nn.Linear(in_features=30*5*5, out_features=128, bias=True)
        self.fc2 = nn.Linear(in_features=128, out_features=10, bias=True)

    def forward(self, x):
        x = F.relu(self.conv1(x), inplace=True)
        x = F.max_pool2d(x, (2, 2))

        x = F.relu(self.conv2(x), inplace=True)
        x = F.max_pool2d(x, (2, 2))

        x = x.view(x.shape[0], -1)
        x = F.relu(self.fc1(x), inplace=True)
        x = F.relu(self.fc2(x), inplace=True)

        return x

nn.Sequantial을 사용한 신경망

nn.Sequantial을 사용하면 __init__() 에서 사용할 네트워크 모델들을 정의 해줄 뿐만 아니라,
forward() 함수에서 구현될 순전파를 Layer 형태로 보다 가독성이 뛰어나게 코드를 작성할 수 있습니다. Layer가 복잡해질수록 nn.Sequential은 그 효가가 뛰어납니다.

class MyNeuralNetwork(nn.Module):
    def __init__(self):
        super(MyNeuralNetwork, self).__init__()

        self.layer1 = nn.Sequential(
            nn.Conv2d(in_channels=3, out_channels=64, kernel_size=5),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2)
        )

        self.layer2 = nn.Sequential(
            nn.Conv2d(in_channels=64, out_channels=30, kernel_size=5),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2)
        )

        self.layer3 = nn.Sequential(
            nn.Linear(in_features=30*5*5, out_features=128, bias=True),
            nn.ReLU(inplace=True)
        )

        self.layer4 = nn.Sequential(
            nn.Linear(in_features=128, out_features=10, bias=True),
            nn.ReLU(inplace=True)
        )

    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = x.view(x.shape[0], -1)
        x = self.layer3(x)
        x = self.layer4(x)

        return x

6. 신경망 학습과 평가

도로롱주 — Mon, 22 Jul 2019 00:07:43 +0900

신경망 학습과 평가(앞서 정의한 신경망 모델(#5 )의 연장)

신경망 모델 개선 ①

학습에 사용할 데이터는 CIFAR10 입니다.
이 신경망 모델은 이미지를 입력받았을 때, 이미지가 어떤 이미지인지 분류하는 모델입니다.
분류되는 class는 '비행기', '자동차', '개구리' 등 10개 입니다.
따라서 forward 함수의 output은 10개의 classes를 분류할 수 있도록 out_features가 10이 되어야 합니다.

신경망 모델 개선 ②

2개의 convolutional Layer를 사용
2개의 Linear Layout을 사용
convolutional Layout을 통과한 데이터들을 max_pool2d 함수로 2*2 필터를 사용해 풀링
활성화 함수로는 relu함수를 사용

개선된 신경망 모델 코드

import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader

import torchvision
import torchvision.transforms as transforms


class MyNeuralNetwork(nn.Module):
    def __init__(self):
        super(MyNeuralNetwork, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=5)
        self.conv2 = nn.Conv2d(in_channels=64, out_channels=30, kernel_size=5)
        self.fc1 = nn.Linear(in_features=30*5*5, out_features=128, bias=True)
        self.fc2 = nn.Linear(in_features=128, out_features=10, bias=True)

    def forward(self, x):
        x = F.relu(self.conv1(x), inplace=True)
        x = F.max_pool2d(x, (2, 2))

        x = F.relu(self.conv2(x), inplace=True)
        x = F.max_pool2d(x, (2, 2))

        x = x.view(x.shape[0], -1)
        x = F.relu(self.fc1(x), inplace=True)
        x = F.relu(self.fc2(x), inplace=True)

        return x

    @staticmethod
    def load_data():
        # classes of "CIFAR10"
        classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

        transform = transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
        ])

        train_set = torchvision.datasets.CIFAR10(
            root='./data',
            train=True,
            download=False,
            transform=transform
        )

        test_set = torchvision.datasets.CIFAR10(
            root='./data',
            train=False,
            download=False,
            transform=transform
        )
        train_loader = DataLoader(train_set, batch_size=8, shuffle=True, num_workers=0)
        test_loader = DataLoader(test_set, batch_size=8, shuffle=False, num_workers=0)

        return train_loader, test_loader

신경망 모델 학습

신경망 모델을 학습시키기 위해서는 optimizer와 loss function이 필요합니다.

loss function은 forward 함수가 return 한 결과(예측 값)와 실제 값이 얼마나 다른 지를 return 해주는 함수입니다.
optimizer는 역전파를 통해 각 노드들의 미분값을 구하고 그것을 활용해 하이퍼 파라미터들을 조정함으로써 신경망 모델을 좀더 나은 방향으로 변화시키는 역할을 합니다.

optimizer는 torch.optim.SGD를 사용했고,
loss함수는 torch.nn.CrossEntropyLoss를 사용했습니다.

optimizer = torch.optim.SGD(params=network.parameters(), lr=0.001, momentum=0.9)
loss_function = nn.CrossEntropyLoss()

epoch 크기를 3으로 하여 학습을 시키는 코드는 아래와 같습니다.

network = MyNeuralNetwork()
train_loader, test_loader = network.load_data()

optimizer = torch.optim.SGD(params=network.parameters(), lr=0.001, momentum=0.9)
loss_function = nn.CrossEntropyLoss()

epoch_size = 3
for epoch in range(epoch_size):
    for i, data in enumerate(train_loader):
        inputs, labels = data
        inputs, labels = Variable(inputs), Variable(labels)

        if torch.cuda.is_available():
            inputs = inputs.cuda()
            labels = labels.cuda()
            network.cuda()

        optimizer.zero_grad()
        out = network.forward(inputs)
        loss = loss_function(out, labels)
        loss.backward()
        optimizer.step()

        if(i % 100 == 0):
            print('{0}: loss is {1}'.format(i, loss))

print("train over")

신경망 모델 평가

test 데이터를 이용해 신경망 모델이 예측한 값과 실제 label이 얼마나 같은 지 모두 확인하여 그 정확도를 출력하는 코드입니다.

total = 0
correct = 0
for _, data in enumerate(test_loader):
    images, labels = data

    if torch.cuda.is_available():
        images = images.cuda()
        labels = labels.cuda()

    out = network.forward(Variable(images))
    _, predicted = torch.max(out.data, 1)

    total += labels.size(0)
    correct += (predicted == labels).sum()

print('Accuracy is {0}%'.format(100*correct/total))

참고: 김군이(https://www.youtube.com/watch?v=hAdjMBR-ttg)

5. 신경망 정의와 순방향 전파

도로롱주 — Mon, 22 Jul 2019 00:03:42 +0900

신경망 정의와 순방향 전파(Neural Network and Forward propagation)

Neural Network 정의

신경망은 아래 그림과 같이
input layer, hidden layer, output layer 를 갖습니다.

신경망 모델을 pytorch를 사용해 class로 구현하기

pytorch의 nn.module을 상속받아 low level의 코딩을 줄일 수 있습니다.

import torch
import torch.nn as nn


class MyNeuralNetwork(nn.Module):
    def __init__(self):
        pass # 모델 코딩

    def forward(self, x):
        pass # 순전파 코딩

CIFAR10 데이터셋

CIFAR10 데이터셋을 학습하는 신경망 모델을 만들려고 합니다.
CIFAR10 데이터셋은 32 * 32 크기의 RGB 데이터입니다.
이 데이터셋을 torchvision을 통해 다음과 같이 데이터를 로드하려고 합니다.

train_set = torchvision.datasets.CIFAR10(
    root='./data',
    train=True,
    download=False,
    transform=transform
)

test_set = torchvision.datasets.CIFAR10(
    root='./data',
    train=False,
    download=False,
    transform=transform
)
train_loader = DataLoader(train_set, batch_size=8, shuffle=True, num_workers=0)
test_loader = DataLoader(test_set, batch_size=8, shuffle=False, num_workers=0)

이렇게 로드한 데이터의 형태를 살펴보면

# print shapes of loaded data
for n, (img, labels) in enumerate(test_loader):
    print(n, img.shape, labels.shape)

torch.Size([8, 3, 32, 32]) torch.Size([8])

batch_size 8 로 가져온 이미지가 채널이 3이고, 크기가 32 * 32 인 이미지라는 것을 알 수 있습니다.

모델과 순전파 코딩

nn.Conv2d를 사용한 모델입니다.
nn.Conv2d에 대한 내용은 앞에 있으니 넘어가겠습니다.(https://github.com/djkim1991/pytorchStudy/issues/3)
forward 함수는 입력 데이터가 어떤 결과를 return 하는 지 작성하면 됩니다.
여기서는 입력 데이터 x가 Conv2d 함수를 두번 통과한 결과를 return 합니다.

import torch
import torch.nn as nn


class MyNeuralNetwork(nn.Module):
    def __init__(self):
        super(MyNeuralNetwork, self).__init__()
        self.net_1 = nn.Conv2d(3, 5, 5)
        self.net_2 = nn.Conv2d(5, 10, 5)

    def forward(self, x):
        x = self.net_1(x)
        x = self.net_2(x)

        return x

참고: 김군이(https://www.youtube.com/watch?v=KXiDzNai9tI)

4. Pytorch torchvision에서 데이터셋 가져오기

도로롱주 — Sun, 21 Jul 2019 23:59:34 +0900

`torchvision`에서 데이터셋 가져오기

`torchvision`

( pip install torchvision 으로 설치 )
널리 사용되는 데이터 셋, 아키텍쳐 모델 computer vision에서의 일반적인 이미지 변환으로 구성되어 있습니다.

torchvision.datasets

MNIST
Fashion-MNIST
KMNIST
EMNIST
FakeData
COCO
LSUN
ImageFolder
DatasetFolder
Imagenet-12
CIFAR
STL10
SVHN
PhotoTour
SBU
Flickr
VOC
Cityscapes

torchvision.models

Alexnet
VGG
ResNet
SqueezeNet
DenseNet
Inception v3
GoogLeNet

torchvision.transforms

Transforms on PIL Image
Transforms on torch.*Tensor
Conversion Transforms
Generic Transforms
Functional Transforms

torchvision.utils

`torchvision.transforms`

다양한 이미지 변환 기능들을 제공해 줍니다.

EX)

`torchvision.transform.ToTensor`

PIL 이미지 또는 numpy.ndarray를 pytorch의 텐서로 변형시켜 줍니다.

transforms.ToTensor()

`torchvision.transforms.Normalize(mean, std, inplace=False)`

평균과 표준편차를 사용하여 이미지를 정규화 시켜 줍니다.

transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))

`torchvision.transform.Compose`

여러 transform 들을 Compose로 구성할 수 있습니다.

transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

`torchvision.datasets.CIFAR10`

CIFAR10 데이터셋을 가져옵니다.

train_set = torchvision.datasets.CIFAR10(
    root='./data',        # 데이터 저장 위치
    train=True,           # True: train set, False: test set
    download=False,       # 다운로드 여부, (이미 다운받았으면 False로 지정)
    transform=transform   # 데이터 선처리 작업
)

test_set = torchvision.datasets.CIFAR10(
    root='./data',
    train=False,
    download=False,
    transform=transform
)

`torch.utils.data.DataLoader`

torchvision.dataset의 데이터들을 불러옵니다.
batch_size, shuffle, num_workers 등 10여개의 parameter를 전달 받습니다.

train_loader = DataLoader(train_set, batch_size=8, shuffle=True, num_workers=0)
test_loader = DataLoader(test_set, batch_size=8, shuffle=False, num_workers=0)

참고: 김군이(https://www.youtube.com/watch?v=KXiDzNai9tI)

3. Pytorch nn과 nn.functional

도로롱주 — Sun, 21 Jul 2019 22:51:30 +0900

필요 패키지

import torch.nn as nn
import torch.nn.functional as F

문서

nn
https://pytorch.org/docs/1.0.1/nn.html
nn.functional
https://pytorch.org/docs/1.0.1/nn.html#torch-nn-functional

nn 과 nn.functional

제공하는 기능들은 비슷한데 사용하는 방법에 차이가 있습니다.

nn 이 제공하는 기능들

Parameters
Containers
Conv
Pooling
Padding
Non-linear Activation
Normalization
Recurrent
Linear
Dropout
Sparse
Distance
Loss
Vision
Data Parallel
Utilities
...

nn.functional 이 제공하는 기능들

Conv
Pooling
Non-linear Activation
Normalization
Linear function(=fully connected layer)
Dropout
Loss
Vision
...

conv2d의 사용

nn 과 nn.functional의 차이를 conv2d를 이용해서 알아봅시다.

nn.conv2d
nn.functionnal.conv2d

torch.nn.Conv2d VS torch.nn.functional.Conv2d

입력 이미지에 2d Convolution을 적용시키는 메소드 입니다.

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

torch.nn.functional.conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)

`nn.Conv2d`

weight를 직접 선언해주지 않음

in_channels : input image 채널의 수
out_channels : convolution 결과 채널의 수
kernel_size : convolution 커널의 크기(필터 크기)

`torch.nn.functional.conv2d`

weight를 직접 선언 ( 외부에서 만든 filter를 사용 )

input : input Tensor ( minibatch×in_channels×iH×iW )
weight : 필터의 shape ( out_channels × groups in_channels × kH × kW )

예제

아래 그림과 같은 convolution 연산을 pytorch로 진행해 보겠습니다.

convolution 연산

1. `torch.nn.functional.conv2d`

이미지와 같은 input, filter 텐서를 생성하고 conv2d 메소드로 연산한 코드와 결과입니다.

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
import numpy as np

input = torch.Tensor(np.array([[[  
[1,1,1,0,0],  
[0,1,1,1,0],  
[0,0,1,1,1],  
[0,0,1,1,0],  
[0,1,1,0,0]  
]]]))

filter = torch.Tensor(np.array([[[  
[1,0,1],  
[0,1,0],  
[1,0,1]  
]]]))

input = Variable(input, requires\_grad=True)  
filter = Variable(filter)

out = F.conv2d(input, filter)  
print(out)

tensor([[[[4., 3., 4.],  
[2., 4., 3.],  
[2., 3., 4.]]]], grad_fn=) [Finished in 0.5s]

2. `torch.nn.conv2d`

nn.conv2d는 weight를 제공해 주기 때문에 filter를 넘기지 않았습니다.
결과 출력 뿐만 아니라 사용된 weight도 같이 출력하겠습니다.
(호출할 때마다 결과가 달라집니다.)


import torch  
import torch.nn as nn  
import torch.nn.functional as F  
from torch.autograd import Variable  
import numpy as np

input = torch.Tensor(np.array([[[  
[1,1,1,0,0],  
[0,1,1,1,0],  
[0,0,1,1,1],  
[0,0,1,1,0],  
[0,1,1,0,0]  
]]]))

input = Variable(input, requires_grad=True)

func = nn.Conv2d(1,1,3)  
print(func.weight)

out = func(input)  
print(out)

Parameter containing:  
tensor([[[[-0.0219, 0.0051, 0.0586],  
[ 0.1440, 0.3288, -0.2014],  
[ 0.0100, 0.1854, -0.1580]]]], requires\_grad=True)  
tensor([[[[ 0.0342, 0.3050, 0.5113],  
[-0.2727, 0.2196, 0.4731],  
[-0.0924, 0.4095, 0.5477]]]], grad_fn=) [Finished in 0.5s]

참고: 김군이(https://www.youtube.com/watch?v=VKhFeh92eps)

2. Pytorch autograd와 Variable

도로롱주 — Sun, 21 Jul 2019 22:45:18 +0900

autograd

Auto Gradient

autograd를 사용하면 backprop을 위한 미분 값을 자동으로 계산해 줍니다.
자동 계산을 위해서 사용하는 변수는 torch.autograd에 있는 Variable 입니다.

역전파(backpropagation)

복잡한 함수에 대해 텐서들 마다 각각 편미분을 진행하려면 연산량이 엄청나기 때문에, 합성 함수 미분의 성질을 이용하여 훨씬 적은 연산만으로 각 텐서들에 대한 미분을 구하는 방법입니다.
여기서 역전파에 대한 자세한 내용을 다루지는 않겠습니다.

Variable의 모습

torch.aurograd.Variable()을 통해 Variable을 생성합니다.

import torch
import numpy as np
a = torch.Tensor(np.array([[1]]))
a = torch.autograd.Variable(a, requires_grad=True)

Variable은 아래와 같은 속성들을 갖고 있습니다.
.backward() 가 호출되면 미분이 시작되고 그 정보가 담기게 됩니다.

data
Tensor 형태의 데이터
grad
Data가 거쳐온 layer에 대한 미분 값
grad_fn
미분 값을 계산한 함수에 대한 정보

예시

식 d를 a에 대해 미분한 결과를 보여주는 예제입니다.

import torch
import numpy as np

a = torch.Tensor(np.array([[1]]))
a = torch.autograd.Variable(a, requires_grad=True)

b = a + 2
c = b**2
d = c*3

d.backward()

print("="*50)
print("d.data:", d.data)
print("d.grad:", d.grad)
print("d.grad_fn:", d.grad_fn)

print("="*50)
print("c.data:", c.data)
print("c.grad:", c.grad)
print("c.grad_fn:", c.grad_fn)

print("="*50)
print("b.data:", b.data)
print("b.grad:", b.grad)
print("b.grad_fn:", b.grad_fn)

print("="*50)
print("a.data:", a.data)
print("a.grad:", a.grad)
print("a.grad_fn:", a.grad_fn)

위 코드의 실행 결과입니다.

==================================================
d.data: tensor([[27.]])
d.grad: None
d.grad_fn: <MulBackward0 object at 0x0000025A0F43ABE0>
==================================================
c.data: tensor([[9.]])
c.grad: None
c.grad_fn: <PowBackward0 object at 0x0000025A0F43AC18>
==================================================
b.data: tensor([[3.]])
b.grad: None
b.grad_fn: <AddBackward0 object at 0x0000025A0F43AF60>
==================================================
a.data: tensor([[1.]])
a.grad: tensor([[18.]])
a.grad_fn: None
[Finished in 0.5s]

참고: 김군이(https://www.youtube.com/watch?v=VKhFeh92eps)

웹 개발 메모장

[자바스크립트] 채팅 구현 코드 (프론트)

2. CGAN(Conditional Generative Adversarial Network)

1. GAN: Generative Adversarial Networks

Generative Adversarial Networks 발전 스토리

7. nn.Sequential을 사용한 신경망 구현

nn.Sequantial을 사용한 신경망 구현(앞서 정의한 신경망 모델(#6 )의 연장)

nn.Sequantial을 사용하지 않은 신경망

nn.Sequantial을 사용한 신경망

6. 신경망 학습과 평가

신경망 학습과 평가(앞서 정의한 신경망 모델(#5 )의 연장)

신경망 모델 개선 ①

신경망 모델 개선 ②

개선된 신경망 모델 코드

신경망 모델 학습

신경망 모델 평가

5. 신경망 정의와 순방향 전파

신경망 정의와 순방향 전파(Neural Network and Forward propagation)

Neural Network 정의

신경망 모델을 pytorch를 사용해 class로 구현하기

CIFAR10 데이터셋

모델과 순전파 코딩

4. Pytorch torchvision에서 데이터셋 가져오기

torchvision에서 데이터셋 가져오기

torchvision

torchvision.datasets

torchvision.models

torchvision.transforms

torchvision.utils

torchvision.transforms

EX)

torchvision.transform.ToTensor

torchvision.transforms.Normalize(mean, std, inplace=False)

torchvision.transform.Compose

torchvision.datasets.CIFAR10

torch.utils.data.DataLoader

3. Pytorch nn과 nn.functional

필요 패키지

문서

nn 과 nn.functional

nn.functional 이 제공하는 기능들

conv2d의 사용

torch.nn.Conv2d VS torch.nn.functional.Conv2d

nn.Conv2d

torch.nn.functional.conv2d

예제

1. torch.nn.functional.conv2d

2. torch.nn.conv2d

2. Pytorch autograd와 Variable

autograd

역전파(backpropagation)

Variable의 모습

예시

`torchvision`에서 데이터셋 가져오기

`torchvision`

`torchvision.transforms`

`torchvision.transform.ToTensor`

`torchvision.transforms.Normalize(mean, std, inplace=False)`

`torchvision.transform.Compose`

`torchvision.datasets.CIFAR10`

`torch.utils.data.DataLoader`

`nn.Conv2d`

`torch.nn.functional.conv2d`

1. `torch.nn.functional.conv2d`

2. `torch.nn.conv2d`