Hatena::�֥���(Diary)

shi3z��Ĺʸ���� RSS�ե����� Twitter

2017-04-11

�������ߴ������Хå������ڤ��ΤƤ��Ȥ����դ줳�ߤ�Chainer2(�١���1)�򶲤붲�����������̤�� 06:31

�������Ĥ��ˤ��λ������Ƥ��ޤä���


����ǯ�ܤ��񤤤����ϡ֥᥸�㡼�С������󥢥åפϲ����θߴ������ΤƤ�!�פȹ��餫�����������Ƥ���Chainer2���������ݤ��衼�ȻפäƤ����Τ������Ĥ��˥��꡼���������ˤʤäƤ��ޤä����ܤ˴֤˹礦�ʤ�����ľ�������ȻפäƤ������ɡ����󤼤������������ʤ��ΤǤȤꤢ����ȯ�䤷���������ߥ���Ū�ˤϥ��ꥮ�����ä��͡�


�����ơ����⤽��Chainer�ϡ������Ǥ��������ߴ������Хå��Хå����ڤ��ΤƤ롢����ƻŪ���ե졼������Ǥ��뤳�ȤϤ褯�Τ����Ƥ��롣���Υ��åץǡ��ȥڡ������󽵴֤˰����Ȥ��������ʤ��ΤǤ��ꡢChainer��ȯ�Υ����Х��Ȥ��罸���Ƥ��ʤ��ʤ����������ޤ��ʤ���ò�����Ƥ����Τ⤵�⤢���ʤ��Ȥ��������ʤΤ����ݤ������󡣤����ʿ��졣


���ޤ��ȤϤ�������ʬ�ΰ������ե졼������κǿ��ǤǤ����Τǡ������ʤ����ΤҤ����֤����褦�ˡ֤����ʤ顢���ޤ��˥塼�����ͥå��򤢤꤬�Ȥ��פȥ��åХ������櫓�ˤ⤤���ʤ��Τǡ������뤪���롦�����ۤ��Ȥ��ˤ����뤪���롢��ʬ���ܤΤ����˽񤤤�������ñ��MNIST����Ƥߤ���


���ޤ����������ΤߤΤ���

import numpy as np
import chainer
import chainer.functions as F
import chainer.links as L
from chainer import Variable,optimizers,Chain

train, test = chainer.datasets.get_mnist(ndim=3)

class Model(Chain):
    def __init__(self):
        super(Model, self).__init__(
            l1=L.Linear(784, 100),
            l2=L.Linear(100, 100),
            l3=L.Linear(100, 10),
            )
    def __call__(self, x):
        h = F.relu(self.l1(x))
        h = F.relu(self.l2(h))
        return self.l3(h)


model = L.Classifier(Model())
optimizer = optimizers.MomentumSGD(lr=0.01, momentum=0.9)
optimizer.setup(model)


batchsize = 1000

def conv(batch,batchsize):
    x=[]
    t=[]
    for j in range(batchsize):
        x.append(batch[j][0])
        t.append(batch[j][1])
    return Variable(np.array(x)),Variable(np.array(t))

for n in range(20):
    for i in chainer.iterators.SerialIterator(train, batchsize,repeat=False):
        x,t = conv(i,batchsize)
        
        model.cleargrads()
        loss = model(x,t)
        loss.backward()
        optimizer.update()

    i = chainer.iterators.SerialIterator(test,batchsize, repeat=False).next()
    x,t = conv(i,batchsize)
    loss = model(x,t)
    print n,loss.data,model.accuracy.data

���ǤäƤ��������ν�������2�ˤ����ޤǤ��ʤ��Ť���

��1����������ǡƳ�����줿iterator�˥������ꤢ�碌�����ˤʤä���������

�������ߴ���������1�Ǥ������������ǥС������󥢥åפ��Ƥ������顢�⤦�Ĥ��Ƥ����Τ��ɤ���


����ȯ���ˤ��Ԥ��������Фä����Τ褦�˸����롣

�������Ƥ��ĤޤǷФäƤ��ޥ����Ρ����б����ʤ��ʤ��Ȼפä��顢�ޥ����Ρ����б���ChainerMN�ϸ��������Ƥʤ�(�äƤ������ϡ��ɥ����ɤ���?)����������������������! TensorFlow����10��®���������������ʤ��ߤ��ꡢ������������������


�����⤽������trainer��Ƴ�����줿�Τϥޥ����Ρ��ɤǤ��뤿�ᤸ���ʤ��ä��󤫤���


���ޡ��������������⤢���Ĥġ�ñ����MNIST�Ϥ��Τޤ�ư���ƾ����ۥäȤ�����

��trainer���Ȥä��������Ϥ��Ƥʤ��������⤽��trainer�ν������Ϥ��ʤ걣�ä����Ƥ��ޤ��Τ��ͤ����ʤ��äƤ��Ż��ˤϤ��ޤ������Ƥʤ��������ؽ����ٶ��ˤϤ����ʤ����ɤ��Τ��⤷���ʤ����ɡ������ޤDZ��ä������Τ�(Deel�Τ��Ȥ�ê�˾夲)��


�����ơ��ޤ������ۥäȤ����Ȥ����Ǿ��߹��ߤ���Ƥߤ�

import numpy as np
import chainer
import chainer.functions as F
import chainer.links as L
from chainer import Variable,optimizers,Chain

train, test = chainer.datasets.get_mnist(ndim=3)

#import cupy
#from chainer import cuda
GPU=-1

#cuda.get_device(GPU).use()
#xp = cuda.cupy if GPU >= 0 else np
xp=np

class Model(Chain):
    def __init__(self):
        super(Model, self).__init__(
            conv1=L.Convolution2D(1, 20, 5),
            conv2=L.Convolution2D(20, 50, 5),
            fc1=L.Linear(800, 500), 
            fc2=L.Linear(500, 10),
            )
    def __call__(self, x,train=True):
        cv1 = self.conv1(x)
        relu = F.relu(cv1)
        h = F.max_pooling_2d(relu, 2)
        h = F.max_pooling_2d(F.relu(self.conv2(h)), 2)
        h = F.dropout(F.relu(self.fc1(h)))
        return self.fc2(h)


model = L.Classifier(Model())
#model.to_gpu(GPU)

optimizer = optimizers.MomentumSGD(lr=0.01, momentum=0.9)
optimizer.setup(model)


batchsize = 1000
#print type(train[0][1])
def conv(batch,batchsize):
    x=[]
    t=[]
    for j in range(batchsize):
        x.append(batch[j][0])
        t.append(batch[j][1])
    return Variable(xp.array(x)),Variable(xp.array(t))

for n in range(20):
    for i in chainer.iterators.SerialIterator(train, batchsize,repeat=False):
        x,t = conv(i,batchsize)
        
        model.cleargrads()
        loss = model(x,t)
        loss.backward()
        optimizer.update()
        
    i = chainer.iterators.SerialIterator(test, batchsize).next()
    x,t = conv(i,batchsize)
    loss = model(x,t)
    print n,loss.data

����������

���Ϥ����顼�Фޤ�����

chainer2 shi3z$ python mnist_cnn.py 
Traceback (most recent call last):
  File "mnist_cnn.py", line 56, in <module>
    loss = model(x,t)
  File "/Users/shi3z/anaconda/lib/python2.7/site-packages/chainer/links/model/classifier.py", line 67, in __call__
    self.y = self.predictor(*x)
  File "mnist_cnn.py", line 30, in __call__
    h = F.dropout(F.relu(self.fc1(h)), train=train)
TypeError: dropout() got an unexpected keyword argument 'train'
chainer2 shi3z$ 

�����ޤ��������ߴ����ʥ������顣

��dropout���������ꤷ�Ƥ���train�Ϥ����ʤ��ʤä��餷�����ޤ�����Ū�˽��������Ф����ä������ʡ�


��Chainer�˸¤��ʤ��������ɡ������ؽ��ϤΥե졼������Ϻ���Ū�˥����ԥ塼����ư�������򤷤ʤ����ݼ����Ȥ����Ӥθ����ǥ����ԥ塼���Υ꥽������̵�̤˻Ȥ����Ȥ��ץ������ߥ󥰤λ��夫�顢�褦�䤯�����ԥ塼������ǽ���³��ޤǰ����Ф�������̵�̤ʥѥ��᡼���Ϥ����������򤸤��֤����ֻȤ��ٹ�Ū�ץ������ߥ󥰤�æ�Ѥ����ե������˰ܤäƤ��Τ��⤷���ʤ����ޤ����ԡ��ɾ����ˤʤäƤ������������������ʡ�


��Chainer�ξ��硢�����Ǥ���Python�Ǥ����Ȥ�������(������C���������ä�®������GPU�Ǥ���ǽ��������Ū���礭���ΤǸ��ᤴ���줬��)�������Τǡ������ܤ˺�Ŭ���������Ȥ����Ⱥǽ�Ū�ˤϰ����ޥ������ǽ񤯤褦�ˤʤ뤫�⤷���ʤ����ޤ������ɤκ�Ŭ�����Τ��Τ�AI�ˤ��餻���㤤�����Ǹ��ϡ��������ǽ��ˤ��ä��Ȥ�������®�Υե졼������ˤʤ��������ʡ�


��Chainer2�˰ܹԤ��Ƥ��ι��찵�Ҳ��ˤĤ��Ƥ������������Ȥ��������Ȥ������ä�Pytorch��Keras�˰ܹԤ��뤫�������ȻפäƤ����顢���٤�Google����Sonnet�Ȥ������ɤ����Υץ��Х������ߤ�����̾����TensorFlow���åѡ����ФƤ����纮����

��

�����μ��Τ��Τϥ����ץ뤬·�äƤ��ʤ��Ȥ����ޤ���̣��̵���������͡��׻��񸻤���ʬ�ˤ��äơ��ޥ����Ρ��ɤ�1�Ρ���8�𤯤餤��GPU�����ޤۤɤ����С�Keras+TensorFlow�����ΤȤ������ּ��ڤǺǶ��ȸ����롣


�����ʤߤˤ��ä���Ʊ�����Τ�Keras�ǽ񤯤Ȥ����ʴ���


from __future__ import print_function

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop


batch_size = 128
num_classes = 10
epochs = 20

# the data, shuffled and split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()

x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')

y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

model = Sequential()
model.add(Dense(100, activation='relu', input_shape=(784,)))
model.add(Dropout(0.2))
model.add(Dense(100, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))

model.summary()

model.compile(loss='categorical_crossentropy',
              optimizer=RMSprop(),
              metrics=['accuracy'])

history = model.fit(x_train, y_train,
                    batch_size=batch_size,
                    epochs=epochs,
                    verbose=1,
                    validation_data=(x_test, y_test))
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

�����ȡ��������Ǥ�Keras�����֥����ץ뤬¿�������Τ��䤳����������LSTM�ޤǤ��롣Chainer�⥳�ߥ��˥ƥ��ϴ�ĥ�äƤ��뤬��pix2pix�ΰܿ��Ȥ��⤽�������ɤʤ���­���Ƥʤ����������롣�����äƴ����ʤ������ʡ����ü����᤯�ǿ��������򤤤�������ʤ�Keras�ϥ饯�����ܿ��Υ˥塼�����ͥåȸ����Ԥˤʤ����Ȥ����󤸤��ʤ����а��֤�������


��Chainer�Υ����åȤǤ���Define by Run���褭���Τϡ����ۤ��ü��ʥ������ʤΤǡ�Keras�����Τ��������Хå����ڤäƤ����Τϥ����С��������ȸ����롣


�������θ����Ԥξ�����Chainer���餤�μ�ͳ�٤�ɬ�פ��Ȼפ����������Ǥ��ä��Ȥ��Ƥ⾾��˭�������󾧤����褦�ʥޥ��������������ȤΥ˥塼�����ͥåȤϼ¸�������(�ޤ����줬�¸����䤹���ե졼������Ϥʤ�)��


���֥ޥ��������������Ȥˤ���Deep Learning�פ��ʤ��Ǥ��뤫�Ȥ����ΤϤ�����ʸ���ɤ����ߤ���

https://kaigi.org/jsai/webprogram/2016/pdf/953.pdf


����ʸ�Ȥ��Ƥ�����Ū�ɤߤ䤹�����������ˤ�̤�褬���뵤�����롣��ǯ����ʸ�����ɡ�


�������ѡ����ץȥ���(�쥤�䡼���Ѥ߽Ťͤˤ����˥塼�����ͥå�)�α�Ĺ�Ȥ��ƤΥ˥塼�����ͥåȤ������ϡ��Լ����Ǥ��롢�Ȥ����Τ�������ʸ�μ��ݤǡ���ʪ��Ǿ�Ϥ����ʹ�¤�ˤʤäƤʤ�������Ʊ��Ū�ʥޥ��������������ȤΥ˥塼�����ͥåȤȤ��Ƽ������٤������������Ǥ����꤯�����Ϥ������Ȥ������Ƥǡ��ºݤ˼����������ѡ����ץȥ�����Ʊ������ǽ���Ф��������꤯�������Ȥ����äǤ��롣


��������ʸ���ɤ��ȡ��ʤ��ۤɾ����������ɤ����ƾ��߹��ߤ�̴�򴶤������ʤ��Τ��������褯�狼�ä���


���פ����ˡ������ߤȤ����Τϸ�©�˸������櫓������ʪ��Ǿ����������������̵�뤷���ʰ�Ū�ʼ����˸����뤷�������ʸ�©����ˡ�Ǥ��Ȥ����꤯�Ԥä��Ȥ��Ƥ��򤷤���?�Ȥ������Ȥϴ���Ū�ˤ������Ǥ��롣


���������⤤�֤ʤ櫓�衢�����äơ������������ֺ¤μ��ȤǤ�(���ޤ����Ȥ�����������)�ۥåץե������ɥͥåȥ���Ȥ������ܥ��ĥޥ��ޥ����ˤĤ��Ʋ��⤷�Ƥ��Τ͡��פ����ˤ������ಽ���ȻפäƤ��櫓���������Ϥ��������͡����⤽���Լ��������顣


���ޥ��������������Ȥ��ȡ����֤��׻����Τ��Τ����äȸ�ΨŪ�ˤ����絬�ϲ����ʤ��Ⱥ��ξ����ߤ˻�����ǽ�ˤϤʤ��ʤ��ΤǤϤʤ����ȸĿ�Ū�ˤϻפ���


�����֤󡢾����ߤȤ����Τϡ��ޥ��������������ȤȤ���ư����˥塼�����ͥåȤ��������٤ε��ϤǤ��äƤ��뤳�Ȥ��绨�Ĥ˶���������ˡ�ʤΤǤϤʤ��������Ȥ����ȼ���Ū�ʾ����ߤ�Ʊ���Υޥ��������������ȥͥåȥ�������������ˤϺ��ο�ɴ�ܤε��Ϥη׻���ɬ�פʤ櫓�ǡ��������������ƥ�����Ū��GPU�����դʤ櫓�ǤϤʤ��Τ������������������ƥ������������ʤ����ʤ��ʤ���FPGA�Ȥ��Ǽ¸��Ȥ����Ƥ�������������


���Ŀ�Ū�ˤϤ����������ȤϤʤ��Ȥʤ��Ǥ��������Ȼפ��������褿�餹����̴���뤷���ʤˤ���GPU�нťѡ����ץȥ����нŤ������Ѥ��Ф��ơ���Ʊ���Υޥ��������������ȥ˥塼�����ͥåȤ�FPGA�ʤ�ASIC���˼��������Ƥ��ä��Τۤ�����ǽ���⤤(�Ȥ����Ȥ����ޤǤ����Τ������ʻ��֤������ꤽ������)�Τ��Ȥ����顢�¤��˲������ʤ�����


�������ʤ���Chainer��TensorFlow���ɤ��Ǥ��褯�ʤä��㤦�櫓�ǡ����������������褿���ڤ������龾�������ˤϤ��Ҵ�ĥ�äƤ�������������FPGA�Ǽ��������ʤ�8�ӥåȤ�Relu���������ʤ���ñ���������फ��1024�������饤�ե�������FPGA�˼��������и��������ͤȤ��Ƥϡ��������ˤʤ餼�Ҥ��äƤߤ����Τ��������ʻŻ��ʤ��ʤ������Ƥ��ʤ������ʤ���


�����������Ż��Ȥ��Ƥ�Chainer��TensorFlow��Torch��Keras���ȤäƤ����桹�Ȥ��Ƥϡ���������̴�Τ����������褿�餤���ʡ��Ȼפ��Ĥġ����ޤΤȤ���GPU�ǽ������䤹�������ߤ����餶���򤨤ʤ������⤢�����٤Ϲ��ꤷ�ʤ��Ȥʤ��ʤ����͡�


���Ȥ����櫓��UEI�ϰ���³�����سؽ��˶�̣�Τ��륨�󥸥˥������������Х��ȡ����󥿡������罸���Ƥ��ޤ������䡢�⤦�Ƥ��Ƥ��񤤤�����


�������������ʤ��ǡ������ˤ⽩�ո��ˤ��ᤤ�衣

�����������ξ��硢Python�Ͻ鿴�ԤǤⴿ��

���Ѿ��� | ��������UEI

http://www.uei.co.jp/recruit/