from __future__ import print_function
import argparse

import chainer
import chainer.functions as F
import chainer.links as L
import chainer.initializers as I
from chainer import training
from chainer.training import extensions
from PIL import Image
import numpy as np

class MLP(chainer.Chain):
    def __init__(self, n_units, n_out):
        w = I.Normal(scale=0.05) # モデルパラメータの初期化
        super(MLP, self).__init__(
            conv1=L.Convolution2D(1, 16, 5, 1, 0), # 1層目の畳み込み層（フィルタ数は16）
            conv2=L.Convolution2D(16, 32, 5, 1, 0), # 2層目の畳み込み層（フィルタ数は32）
            l3=L.Linear(None, n_out, initialW=w), #クラス分類用
        )
    def __call__(self, x):
        h1 = F.max_pooling_2d(F.relu(self.conv1(x)), ksize=2, stride=2) # 最大値プーリングは2×2，活性化関数はReLU
        h2 = F.max_pooling_2d(F.relu(self.conv2(h1)), ksize=2, stride=2) 
        y = self.l3(h2)
        return y
"""
自分で用意した手書き文字画像をモデルに合うように変換する処理
"""
def convert_cnn(img):    
    data = np.array(Image.open(img).convert('L').resize((28, 28)), dtype=np.float32)  # ファイルを読込み，リサイズして配列に変換        
    data = (255.0 - data) / 255.0 # 白黒反転して正規化
    data = data.reshape(1, 1, 28, 28) # データの形状を変更
    return data

def main():
    inputimage = '3.png'           # 入力する画像
    modelfile = 'result/MLP.model' # 学習済みモデルファイル  
    unit = 1000                    # ユニット数

    print('自分の手書き文字を学習したモデルで評価してみるプログラム')
    print('# 入力画像ファイル: {}'.format(inputimage))
    print('# 学習済みモデルファイル: {}'.format(modelfile))
    print('')

    # モデルのインスタンス作成    
    model = L.Classifier(MLP(unit, 10))    
    # モデルの読み込み
    chainer.serializers.load_npz(modelfile, model)

    # 入力画像を28x28のグレースケールデータ（0-1に正規化）に変換する
    img = convert_cnn(inputimage)
    x = chainer.Variable(np.asarray(img)) # 配列データをchainerで扱う型に変換
    
    y = model.predictor(x) # フォワード
    c = F.softmax(y).data.argmax()    
    print('判定結果は{}です。'.format(c))        

if __name__ == '__main__':
    main()

from __future__ import print_function
import argparse

import chainer
import chainer.functions as F
import chainer.links as L
import chainer.initializers as I
from chainer import training
from chainer.training import extensions

class MLP(chainer.Chain):
    def __init__(self, n_units, n_out):
        w = I.Normal(scale=0.05) # モデルパラメータの初期化
        super(MLP, self).__init__(
            conv1=L.Convolution2D(1, 16, 5, 1, 0), # 1層目の畳み込み層（フィルタ数は16）
            conv2=L.Convolution2D(16, 32, 5, 1, 0), # 2層目の畳み込み層（フィルタ数は32）
            l3=L.Linear(None, n_out, initialW=w), #クラス分類用
        )
    def __call__(self, x):
        h1 = F.max_pooling_2d(F.relu(self.conv1(x)), ksize=2, stride=2) # 最大値プーリングは2×2，活性化関数はReLU
        h2 = F.max_pooling_2d(F.relu(self.conv2(h1)), ksize=2, stride=2) 
        y = self.l3(h2)
        return y

def main():
    parser = argparse.ArgumentParser(description='Chainer example: MNIST')
    parser.add_argument('--batchsize', '-b', type=int, default=100, help='Number of images in each mini-batch')
    parser.add_argument('--epoch', '-e', type=int, default=20, help='Number of sweeps over the dataset to train')
    parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)')
    parser.add_argument('--out', '-o', default='result', help='Directory to output the result')
    parser.add_argument('--resume', '-r', default='', help='Resume the training from snapshot')
    parser.add_argument('--unit', '-u', type=int, default=1000, help='Number of units')
    #args = parser.parse_args()
    args = parser.parse_args(args=[])     # Jupyter用

    print('GPU: {}'.format(args.gpu))
    print('# unit: {}'.format(args.unit))
    print('# Minibatch-size: {}'.format(args.batchsize))
    print('# epoch: {}'.format(args.epoch))
    print('')

    train, test = chainer.datasets.get_mnist(ndim=3) # ndim=3を引数で与えるだけでOK
    model = L.Classifier(MLP(args.unit, 10), lossfun=F.softmax_cross_entropy)
    if args.gpu >= 0:
        chainer.cuda.get_device(args.gpu).use()
        model.to_gpu()
    optimizer = chainer.optimizers.Adam()
    optimizer.setup(model)
    train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
    test_iter = chainer.iterators.SerialIterator(test, args.batchsize, repeat=False, shuffle=False)
    updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)

    trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
    trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
    trainer.extend(extensions.dump_graph('main/loss'))
    trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
    trainer.extend(extensions.LogReport())
    trainer.extend( extensions.PlotReport(['main/loss', 'validation/main/loss'], 'epoch', file_name='loss.png'))
    trainer.extend( extensions.PlotReport(['main/accuracy', 'validation/main/accuracy'], 'epoch', file_name='accuracy.png'))
    trainer.extend(extensions.PrintReport( ['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time']))
    trainer.extend(extensions.ProgressBar())

    if args.resume:
        chainer.serializers.load_npz(args.resume, trainer)

    trainer.run()
    model.to_cpu()

    modelname = args.out + "/MLP.model"
    print('save the trained model: {}'.format(modelname))
    chainer.serializers.save_npz(modelname, model)

if __name__ == '__main__':
    main()

in_data = ["1", "2", "3"]

out_data = []
for d in in_data:
  out_data.append(int(d))

print(out_data)    # 出力 [1, 2, 3]

in_data = ["1", "2", "3"]

out_data = map(int, in_data)

print(list(out_data))     # 出力 [1, 2, 3]

in_data1 = [1, 2, 3]
in_data2 = [1, 2, 3]

out_data = map(lambda x,y:x+y, in_data1, in_data2)
print(list(out_data))   # 出力 [2, 4, 6]

in_data1 = [1, 2, 3]
in_data2 = [1, 2]

out_data = map(lambda x,y:x+y, in_data1, in_data2)
print(list(out_data))   # 出力 [2, 4]

in_data = ['a.txt', 'b.doc', 'c.txt', 'd.jpg']

def is_txt(x):
  return x.endswith('.txt')

out_data = filter(is_txt, in_data)

print(list(out_data))  # 出力 ['a.txt', 'c.txt']

in_data = ['a.txt', 'b.doc', 'c.txt', 'd.jpg']

out_data = filter(lambda x: x.endswith('.txt'), in_data)

print(list(out_data))  # 出力 ['a.txt', 'c.txt']

from functools import reduce

in_data = [1, 2, 3]

out_data = reduce(lambda x, y: x + y, in_data)

print(out_data)  # 出力 6

from functools import reduce

in_data = [1, 2, 3]

out_data = reduce(lambda x, y: x + y, in_data, 10)

print(out_data)  # 出力 16

import random

# BMIを算出し、体型を３パターンで返す
def calc_bmi(height, weight):
    bmi = weight / (height / 100) ** 2
    if bmi < 18.5:
        return '痩せ'
    elif bmi < 25:
        return '普通'
    else:
        return '肥満'

# データ作成 ← 手順①
lst_label = []
lst_height_weight = []
for i in range(10000):
    height = random.randint(100, 200)   # 100cm～200cmの身長を生成
    weight = random.randint(30, 100)    # 30kg～60kgの体重を生成
    label = calc_bmi(height, weight)

    lst_height_weight.append([height, weight])
    lst_label.append(label)

from sklearn import model_selection, svm, metrics
import matplotlib.pyplot as plt
import pandas as pd

# 学習データとテストデータに分ける ← 手順②
#   テストデータの割合はtest_sizeで指定（0.0～1.0）
data_train, data_test, label_train, label_test = \
    model_selection.train_test_split(lst_height_weight, lst_label, test_size=0.2)

# データを学習 ← 手順③
clf = svm.SVC()
clf.fit(data_train, label_train)

# データを予測 ← 手順④
predict = clf.predict(data_test)

# 結果確認 ← 手順⑤
print('正解率=', metrics.accuracy_score(label_test, predict))
print('レポート=\n', metrics.classification_report(label_test, predict))

import pandas as pd
from sklearn import svm, metrics, model_selection

# アヤメデータを読み込む
csv = pd.read_csv('iris.csv')

# データとラベルに分割
data = csv[['SepalLength', 'SepalWidth', 'PetalLength', 'PetalWidth']]
label = csv['Name']

# クロスバリデーション（交差検証）を行う
clf = svm.SVC()
score = model_selection.cross_val_score(clf, data, label, cv=5) # cv=5は5分割の意
print('各正解率', score)
print('正解率', score.mean())