chainer動かしてみた（作業中）

chainer動かしてみた時のメモ（作業中）

学習

import chainer
import chainer.links as L
import chainer.functions as F
from chainer import optimizers
from chainer import training
from chainer import iterators
from chainer import datasets
from chainer import serializers
from chainer.training import extensions

in_channels=1
out_size=10
uses_device=0
epoch=3
batch_size=20

class MNIST_Conv(chainer.Chain):
    def __init__(self):
        super(MNIST_Conv,self).__init__()
        with self.init_scope():
            self.conv1=L.Convolution2D(in_channels=in_channels,out_channels=8,
                                        stride=(1,1),ksize=(3,3),pad=(1,1))
            self.linear1=L.Linear(in_size=None,out_size=out_size)

    def __call__(self,x,t=None,train=True):
        h1=self.conv1(x)
        h2=F.relu(h1)
        h3=F.max_pooling_2d(h2,ksize=(2,2))
        h4=self.linear1(h3)
        return F.softmax_cross_entropy(h4,t) if train==True else F.softmax(h4)

def train_MNIST():
    model=MNIST_Conv()

    if uses_device>=0:
        chainer.cuda.get_device_from_id(uses_device).use()
        chainer.cuda.check_cuda_available()
        model.to_gpu()

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

    train_iter=iterators.SerialIterator(train,batch_size,shuffle=True)
    test_iter=iterators.SerialIterator(test,batch_size,repeat=False,shuffle=True)

    optimizer=optimizers.Adam()
    optimizer.setup(model)

    updater=training.StandardUpdater(train_iter,optimizer,device=uses_device)
    trainer=training.Trainer(updater,(epoch,"epoch"),out="result")
    trainer.extend(extensions.Evaluator(test_iter,model,device=uses_device))
    trainer.extend(extensions.LogReport(keys=None,
                    trigger=(1,"epoch"),postprocess=None,log_name="MINIST.log"))
    trainer.extend(extensions.ProgressBar())
    trainer.run()

    serializers.save_hdf5("./models/chapt02.hdf5",model)

if __name__=="__main__":
    train_MNIST()

推論

import chainer
import chainer.functions as F
import chainer.link as L
import chainer.training
from chainer import optimizers
from chainer import training
from chainer import datasets
from chainer import iterators
from chainer import serializers
from chainer.training import extensions
from PIL import Image
import numpy as np
import os
import glob

from chapt0201 import MNIST_Conv

uses_device =0

def infer_MNIST():
    model=MNIST_Conv()

    if uses_device >0:
        import cupy as cp
        chainer.cuda.get_device_from_id(0).use()
        chainer.cuda.check_cuda_available()
        model.to_gpu()
    else:
        cp=np

    serializers.load_hdf5("./models/chapt02.hdf5",model)
    targets=sorted(glob.glob("./test/*png"))

    for target in targets:
        image=Image.open(target).convert("L")
        pixels=cp.asarray(image).astype(cp.float32).reshape(1,1,28,28)
        pixels=pixels/255
        inf=model(pixels,train=False)

        result=inf.data[0]
        print(target,">>>",result.argmax(),"  ",result[result.argmax()])

if __name__=="__main__":
    infer_MNIST()