# -*- coding: utf-8 -*-

"""

Created on Wed Jul 25 21:14:45 2018

@author: Mikihiro Ikura

"""

# In[]

import argparse

import chainer

import chainer.links as L

import os

import numpy

import matplotlib.pyplot as plt

import numpy as np

from chainer import training

from chainer.training import extensions

#from chainer.training import triggers

from chainer.datasets import get_cifar100

from chainer.datasets import get_cifar10

from chainer.datasets import tuple_dataset

from chainer import serializers

from chainer.datasets import split_dataset_random

from chainer.cuda import to_cpu

from chainer import cuda

from PIL import Image

import VGG_chainer

#import Mynet

# In[]

#datasetの作成関数

#bicycle:0 motorcycle:1 train:2 automobile:3 person:4

#cifar10 →　automobile

#cifar100 → bicycle motorcycle train

#person →　/dataset/PedCut2013_SegmentationDataset

def make_datasets():

return trains,tests

# In[]

batchsize = 256

learnrate = 0.05

epoch = 300

gpu = 0

out = 'result'

resume = ''

# In[]

class_labels = 5

train_val ,test= make_datasets()

# model = L.Classifier(VGG16Net.VGG16Net(class_labels))

train_size = int(len(train_val) * 0.9)

train, valid = split_dataset_random(train_val, train_size, seed=0)

model = L.Classifier(VGG_chainer.VGG(class_labels))

#GPUのセットアップ

if gpu >= 0:

# Make a specified GPU current

chainer.backends.cuda.get_device_from_id(gpu).use()

model.to_gpu(gpu) # Copy the model to the GPU

xp = cuda.cupy

optimizer = chainer.optimizers.MomentumSGD(lr=learnrate).setup(model)

optimizer.add_hook(chainer.optimizer.WeightDecay(0.0005))

# In[]

train_iter = chainer.iterators.SerialIterator(train, batchsize)

valid_iter = chainer.iterators.SerialIterator(valid, batchsize,

repeat=False, shuffle=False)

stop_trigger = (epoch,'epoch')

updater = training.updaters.StandardUpdater(train_iter,optimizer,device=gpu)

trainer = training.Trainer(updater,stop_trigger,out=out)

# Evaluate the model with the test dataset for each epoch

trainer.extend(extensions.Evaluator(valid_iter, model, device=gpu))

# Dump a computational graph from 'loss' variable at the first iteration

# The "main" refers to the target link of the "main" optimizer.

trainer.extend(extensions.dump_graph('main/loss'))

# Write a log of evaluation statistics for each epoch

trainer.extend(extensions.LogReport())

trainer.extend(extensions.PrintReport(

['epoch', 'main/loss', 'validation/main/loss',

'main/accuracy', 'validation/main/accuracy', 'elapsed_time']))

# Print a progress bar to stdout

trainer.extend(extensions.ProgressBar())

trainer.extend(extensions.PlotReport(['main/loss', 'validation/main/loss'], x_key='epoch', file_name='loss.png'))

trainer.extend(extensions.PlotReport(['main/accuracy', 'validation/main/accuracy'], x_key='epoch', file_name='accuracy.png'))

# In[]

trainer.run()

# In[]

model.to_cpu()

serializers.save_npz('trained_model_cpu4',model)

# In[]

model = L.Classifier(VGG_chainer.VGG(5))

serializers.load_npz('trained_model',model)

# In[]

test_iter = chainer.iterators.MultiprocessIterator(test, batchsize, False, False)

test_evaluator = extensions.Evaluator(test_iter, model, device=gpu)

results = test_evaluator()

print('Test accuracy:', results['main/accuracy'])

# In[]

gpu_id = 0 # CPUで計算をしたい場合は、-1を指定してください

if gpu_id >= 0:

model.to_gpu(gpu_id)

# 1つ目のテストデータを取り出します

x, t = test[40] # tは使わない

# どんな画像か表示してみます

plt.imshow(x.transpose(1,2,0))

plt.show()

# ミニバッチの形にする（複数の画像をまとめて推論に使いたい場合は、サイズnのミニバッチにしてまとめればよい）

print('元の形：', x.shape, end=' -> ')

x = x[None, ...]

print('ミニバッチの形にしたあと：', x.shape)

# ネットワークと同じデバイス上にデータを送る

x = model.xp.asarray(x)

# モデルのforward関数に渡す

with chainer.using_config('train', False), chainer.using_config('enable_backprop', False):

y = model.predictor(x)

# Variable形式で出てくるので中身を取り出す

y = y.array

# 結果をCPUに送る

#y = to_cpu(y)

# 予測確率の最大値のインデックスを見る

pred_label = y.argmax(axis=1)

print('ネットワークの予測:', pred_label[0])

# In[]

model = L.Classifier(VGG_chainer.VGG(5))

serializers.load_npz('trained_model_cpu4',model)

# In[]

#gpu_id = 0 # CPUで計算をしたい場合は、-1を指定してください

#

#if gpu_id >= 0:

# model.to_gpu(gpu_id)

model.to_cpu()

cnt = 0

cnt_num = 1000

# 1つ目のテストデータを取り出します

for i in range(cnt_num):

x, t = test[i] # tは使わない

# # どんな画像か表示してみます

# plt.imshow(x.transpose(1,2,0))

# plt.show()

# ミニバッチの形にする（複数の画像をまとめて推論に使いたい場合は、サイズnのミニバッチにしてまとめればよい）

print('元の形：', x.shape, end=' -> ')

x = x[None, ...]

# print('ミニバッチの形にしたあと：', x.shape)

# ネットワークと同じデバイス上にデータを送る

x = model.xp.asarray(x)

# モデルのforward関数に渡す

with chainer.using_config('train', False), chainer.using_config('enable_backprop', False):

y = model.predictor(x)

# Variable形式で出てくるので中身を取り出す

y = y.array

# 結果をCPUに送る

#y = to_cpu(y)

# 予測確率の最大値のインデックスを見る

pred_label = y.argmax(axis=1)

print('ネットワークの予測:', pred_label[0],' 実際の結果:',t)

if(pred_label[0]==t):

cnt = cnt+1

print('final accuracy: ',cnt,'/',cnt_num)

# In[]

#gpu_id = 0 # CPUで計算をしたい場合は、-1を指定してください

#

#if gpu_id >= 0:

# model.to_gpu(gpu_id)

model.to_cpu()

cnt = 0

cnt_num = 500

# 1つ目のテストデータを取り出します

x_data = Image.open('./dataset/from_vtest/example4.jpg').convert('RGB')

pilImg = Image.fromarray(numpy.uint8(x_data))#PIL dataに変換

img_resize = pilImg.resize((32, 32))#画像サイズ変換32*32*3

imgArray = numpy.asarray(img_resize)#numpy ndarrayに変換

imgArray2 = imgArray.astype(np.float32)/256#float32の配列に変換 256で割る

img_re = np.reshape(imgArray2,(1,3,32,32))#学習データ用に変換する1*3*32*32

img_cuda = model.xp.asarray(img_re)#

# モデルのforward関数に渡す

with chainer.using_config('train', False), chainer.using_config('enable_backprop', False):

y = model.predictor(img_cuda)

# Variable形式で出てくるので中身を取り出す

y = y.array

# 結果をCPUに送る

#y = to_cpu(y)

# 予測確率の最大値のインデックスを見る

pred_label = y.argmax(axis=1)

print('ネットワークの予測:', pred_label[0])