def main(): (x_train, t_train), (x_test, t_test) = load_mnist(flatten=False) network = DeepConvNet() trainer = Trainer(network, x_train, t_train, x_test, t_test, epochs=20, mini_batch_size=100, optimizer='Adam', optimizer_param={'lr':0.001}, evaluate_sample_num_per_epoch=1000) trainer.train() # パラメータの保存 network.save_params("deep_convnet_params.pkl") print("Saved Network Parameters!")
def gradient_check(): (x_train, t_train), (_, _) = \ load_mnist(normalize=True, one_hot_label=True) network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10) batch_size = 3 x_batch = x_train[:batch_size] t_batch = t_train[:batch_size] grad_numerical = network.numerical_gradient(x_batch, t_batch) grad_backprop = network.gradient(x_batch, t_batch) for key in grad_numerical.keys(): diff = np.average(np.abs(grad_backprop[key] - grad_numerical[key])) print(key + ": " + str(diff))
def train(): (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True) network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10) iters_num = 20000 train_size = x_train.shape[0] batch_size = 100 train_loss_list = [] train_acc_list = [] test_acc_list = [] iter_per_epoch = max(train_size / batch_size, 1) epoch_list = [] for i in range(iters_num): batch_mask = np.random.choice(train_size, batch_size) x_batch = x_train[batch_mask] t_batch = t_train[batch_mask] optimizer = Adam() network.train(x_batch, t_batch, optimizer) loss = network.loss(x_batch, t_batch) train_loss_list.append(loss) if i % iter_per_epoch == 0: epoch_list.append(i/iter_per_epoch) train_acc = network.accuracy(x_train, t_train) test_acc = network.accuracy(x_test, t_test) train_acc_list.append(train_acc) test_acc_list.append(test_acc) print("train accuracy : " + str(train_acc) + ", test accuracy : " + str(test_acc)) print("final loss : " + str(loss)) draw_acc_graph(epoch_list, train_acc_list, test_acc_list) draw_loss_graph(train_loss_list)
def get_minst_data(): (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True) return x_train, t_train, x_test, t_test
def get_data(): (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False) return x_test, t_test
if __name__ == '__main__': np.random.seed(2020) # 1차원 softmax 테스트 a = np.random.randint(10, size=5) print(a) print(softmax(a)) # 2차원 softmax 테스트 A = np.random.randint(10, size=(2, 3)) print(A) print(softmax(A)) # (Train/Test) 데이터 세트 로드. (X_train, y_train), (X_test, y_test) = load_mnist() print('X_test.shape :', X_test.shape) print('y_test.shape :', y_test.shape) # print(X_test[0]) # print(y_test[0]) # 신경망 생성 (W1, b1, ...) with open('sample_weight.pkl', 'rb') as f: network = pickle.load(f) print('network:', network.keys()) print('W1:', network['W1'].shape) print('W2:', network['W2'].shape) print('W3:', network['W3'].shape) batch_size = 100 y_pred = mini_batch(network, X_test, batch_size)
from PIL import Image import numpy as np import os import sys os.chdir( '/Users/edamame88/Projects/study/Deep01/deep-learning-from-scratch/ch03') sys.path.append(os.pardir) from dataset.mnist import load_mnist def img_show(img): pil_img = Image.fromarray(np.uint8(img)) pil_img.show() (x_train, t_train), (x_test, t_test) = \ load_mnist(flatten=True, normalize=False) img = x_train[0] label = t_train[0] print(label) img = img.reshape(28, 28) print(img.shape) img_show(img)
def getData(self): (x_train, y_train), (x_test, y_test) = load_mnist(False, True) return x_test, y_test
import sys, os sys.path.append(os.pardir) import numpy as np from dataset.mnist import load_mnist # 画像の表示モジュール from PIL import Image def img_show(img): pil_img = Image.fromarray(np.uint8(img)) pil_img.show() (x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False) img = x_train[0] label = t_train[0] print(label) # (784, ) print(img.shape) # Reshape from 784 to 1 * 28 * 28. img = img.reshape(28, 28) # (28, 28) print(img.shape) img_show(img)
def SGD_Two_layers(hidden=50): from TwoLayerNet import TwoLayerNet from dataset.mnist import load_mnist (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True); network = TwoLayerNet(input_size=784, hidden_size=hidden, output_size=10); optimizer = SGD(0.1); # hyper-parameter iters_num = 10000; train_size = x_train.shape[0]; batch_size = 100; # data memory during training train_loss_list = []; train_acc_list = []; test_acc_list = []; # epoch iter_per_epoch = max(train_size / batch_size, 1) for i in range(iters_num): batch_mask = np.random.choice(train_size, batch_size); x_batch = x_train[batch_mask]; t_batch = t_train[batch_mask]; # grad = network.numerical_gradient(x_batch, t_batch); grad = network.gradient(x_batch, t_batch) params = network.params; # update parameters by using SGD optimizer.update(params, grad); # record the train procedure loss = network.loss(x_batch, t_batch); train_loss_list.append(loss); if i % iter_per_epoch == 0: train_acc = network.accuracy(x_train, t_train) test_acc = network.accuracy(x_test, t_test) train_acc_list.append(train_acc) test_acc_list.append(test_acc) print("\n===========Iter_per_epoch===================") print("Iteration : {}".format(i)); print("train accuracy : {}".format(train_acc)); print("test accuracy : {}".format(test_acc)); print("============================================\n"); # Final Report train_acc = network.accuracy(x_train, t_train) test_acc = network.accuracy(x_test, t_test) print("\n===========Final Result==================="); print("The number of neurons in the hidden layer : {}".format(hidden)) print("train accuracy : {}".format(train_acc)); print("test accuracy : {}".format(test_acc)); print("============================================\n"); # plot the graph import matplotlib.pyplot as plt f, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 20)); x = np.arange(len(train_acc_list)); ax1.plot(x, train_acc_list, label='train acc') ax1.plot(x, test_acc_list, label='test acc', linestyle='--') ax1.set_xlabel("epochs"); ax1.set_ylabel("accuracy"); ax1.set_ylim(0, 1.0); ax1.legend(loc='lower right'); ax1.set_title("Accuracy"); num_itr = np.arange(len(train_loss_list)); ax2.plot(num_itr, train_loss_list); ax2.set_xlabel("iteration"); ax2.set_ylabel("loss"); ax2.set_ylim(0, 3.0); ax2.set_title("Loss per iteration"); plt.show()
import Ooptimizer as opt import numpy as np from GraphLayer import * from collections import OrderedDict from Common import * from TwoLayerNet_BackProp import * from dataset.mnist import load_mnist np.random.seed(1) (x_train, y_train), (x_test, y_test) = load_mnist(True, True, True) epoch = 200 x_test = x_test[:100] y_test = y_test[:100] inputSize = 784 hiddenSize = 50 outputSize = 10 network = Twolayernet_BackProp(inputSize, hiddenSize, outputSize) predictList = [] Losslist = [] AccList = [] for i in range(epoch): res = network.Predict(x_test) grad = network.BGradient(x_test, y_test)
# - 손으로 직접 쓴 숫자(필기체 숫자)들로 이루어진 데이터 셋 # - 0 ~ 9까지의 숫자 이미지로 구성되며, 60,000개의 트레이닝 데이터와 # 10,000개의 테스트 데이터로 이루어져 있음. # - 28x28 size import numpy as np from dataset.mnist import load_mnist from PIL import Image # Image 패키지는 Anaconde Prompt를 통해서 받아야 한다. def img_show(img): pil_img = Image.fromarray(np.uint8(img)) # uint8 : java에서 byte pil_img.show() # (이미지, 레이블) (x_train, t_train),(x_test, t_test) = \ load_mnist(flatten=True, normalize=False, one_hot_label=False) img = x_train[100] print(img.shape) # (784,) for i in range(10): img = x_train[i] label = t_train[i] print(label) print(img.shape) img.reshape(28, 28) # 형상을 원래 이미지의 크기로 변형 img_show(img)
# coding: utf-8 import os import sys sys.path.append(os.pardir) import numpy as np import pandas as pd from dataset.mnist import load_mnist import progressbar import bayesian_tools as tools # Load mnist Data (xTrain, tTrain), (xTest, tTest) = load_mnist(normalize=True) # Read Previously Trained Data for gaussian process regression train_history = pd.read_csv("Training Results.csv") x_gaussian = train_history.as_matrix( columns=["dropout_ratio", "weight_decay", "learning_rate"]) y_gaussian = train_history.as_matrix(columns=["test_acc"]) # Start Optimization iteration_count = 30 axes = np.linspace(0, 0.2, num=15) #todo : There needs to be more effective way to explore through grids search_grid = tools.create_3d_grid(axes) training_history = [] with progressbar.ProgressBar(max_value=iteration_count) as bar: for i in np.arange(iteration_count): # Update best accuracy for each iteration best_accuracy = np.argmax(y_gaussian)
def MultiLayerNet_MNIST_example(): from dataset.mnist import load_mnist import Optimizer as op (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True) network = MultiLayerNet(input_size=784, hidden_size_list=[150, 100], output_size=10, activation="relu", weight_init_std='relu', weight_decay_lambda=0, use_dropout=True, dropout_ratio=0.5, use_batchNorm=True) # hyper-parameter iters_num = 10000 train_size = x_train.shape[0] batch_size = 100 learning_rate = 0.1 optimizer = op.SGD(learning_rate) # data memory during training train_loss_list = [] train_acc_list = [] test_acc_list = [] # epoch iter_per_epoch = max(train_size / batch_size, 1) network.showNetwork() for i in range(iters_num): batch_mask = np.random.choice(train_size, batch_size) x_batch = x_train[batch_mask] t_batch = t_train[batch_mask] # grad = network.numerical_gradient(x_batch, t_batch); grad = network.gradient(x_batch, t_batch) params = network.params # update parameters by SGD optimizer.update(params, grad) # for key in network.params.keys(): # network.params[key] -= learning_rate * grad[key]; # record the train procedure loss = network.loss(x_batch, t_batch) train_loss_list.append(loss) if i % iter_per_epoch == 0: train_acc = network.accuracy(x_train, t_train) test_acc = network.accuracy(x_test, t_test) train_acc_list.append(train_acc) test_acc_list.append(test_acc) print("\n===========Iter_per_epoch===================") print("Iteration : {}".format(i)) print("train accuracy : {}".format(train_acc)) print("test accuracy : {}".format(test_acc)) print("============================================\n") # Final Report train_acc = network.accuracy(x_train, t_train) test_acc = network.accuracy(x_test, t_test) print("\n===========Final Result===================") print("The number of neurons in the hidden layer : {}".format( network.hidden_size_list)) print("train accuracy : {}".format(train_acc)) print("test accuracy : {}".format(test_acc)) print("============================================\n") # plot the graph import matplotlib.pyplot as plt f, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 20)) x = np.arange(len(train_acc_list)) ax1.plot(x, train_acc_list, label='train acc') ax1.plot(x, test_acc_list, label='test acc', linestyle='--') ax1.set_xlabel("epochs") ax1.set_ylabel("accuracy") ax1.set_ylim(0, 1.0) ax1.legend(loc='lower right') ax1.set_title("Accuracy") num_itr = np.arange(len(train_loss_list)) ax2.plot(num_itr, train_loss_list) ax2.set_xlabel("iteration") ax2.set_ylabel("loss") ax2.set_ylim(0, 3.0) ax2.set_title("Loss per iteration") plt.show() print("Save the network information....................") network.save_params("MultiLayer_params_SGD_01.pkl") print("saved parameters!!!!")
# self.x_col.dot(self.W_col) out = out.reshape(n, oh, ow, -1).transpose(0, 3, 1, 2) return out if __name__ == '__main__': # Convolution을 생성 W = np.zeros( (1, 1, 4, 4), dtype=np.uint8) # (filter 개수, color 수, fh, fw) # dtype: 8bit 부호없는 정수 W[0, 0, 1, :] = 1 b = np.zeros(1) conv = Convolution(W, b) # Convolution class의 생성자 호출 # MNIST 데이터를 forward (x_train, y_train), (x_test, y_test) = load_mnist(normalize=False, flatten=False) # 다운로드 받은 이미지 파일을 ndarray로 변환해서 forward input = x_train[0:1] # 4차원 데이터를 뽑아내려면 slicing을 사용! print('input:', input.shape) out = conv.forward(input) print('out:', out.shape) img = out.squeeze() # 차원의 원소가 1개이면 해당 차원을 지운다 print('img:', img.shape) plt.imshow(img, cmap='gray') plt.show() img = Image.open('pengsoo.jpg') img_pixel = np.array(img)
import numpy as np import matplotlib.pyplot as plt from ch05.e10_twolayer import TwoLayerNetwork from ch06.e05_Adam import Adam from dataset.mnist import load_mnist if __name__ == '__main__': (X_train, Y_train), (X_test, Y_test) = load_mnist() neural_net = TwoLayerNetwork(input_size=784, hidden_size=32, output_size=10) train_losses = [] iterations = 2_000 batch_size = 128 train_size = X_train.shape[0] np.random.seed(111) adam = Adam() for i in range(iterations): batch_mask = np.random.choice(train_size, batch_size) X_batch = X_train[batch_mask] Y_batch = Y_train[batch_mask] gradients = neural_net.gradient(X_batch, Y_batch) adam.update(neural_net.params, gradients) loss = neural_net.loss(X_batch, Y_batch) train_losses.append(loss)
# coding: utf-8 import sys, os sys.path.append(os.pardir) # 親ディレクトリのファイルをインポートするための設定 import numpy as np import matplotlib.pyplot as plt from dataset.mnist import load_mnist from two_layer_net import TwoLayerNet # データの読み込み (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True) network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10) iters_num = 10000 # 繰り返しの回数を適宜設定する train_size = x_train.shape[0] batch_size = 100 learning_rate = 0.1 train_loss_list = [] train_acc_list = [] test_acc_list = [] iter_per_epoch = max(train_size / batch_size, 1) for i in range(iters_num): batch_mask = np.random.choice(train_size, batch_size) x_batch = x_train[batch_mask] t_batch = t_train[batch_mask] # 勾配の計算 grad = network.numerical_gradient(x_batch, t_batch)
def hand_craft(old_X): new_X = list() # 변환한 data를 담을 list를 초기화 for n in range(old_X.shape[0]): # data의 개수 만큼 반복한다. temp = list() # 변환한 data를 담을 list를 초기화 for i in range(0, old_X[n].shape[0], 4): # feature 을 4개씩 나눠준다 sum = 0 # 값들의 합을 구한다 for j in range(4): sum += old_X[n][i + j] # 실수 형태의 data를 실수로 받기위해 그대로 더한다 temp.append(sum) new_X.append(temp) return np.array(new_X) # list 를 numpy 형식으로 바꿔준다 (x_train, t_train), (x_test, t_test) = \ load_mnist(normalize=True, flatten=True) label_name = np.array(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']) hc_x_train = hand_craft(x_train) # 기존의 data 를 넣어 feature 이 변화된 형태의 data 를 받는다 hc_x_test = hand_craft(x_test) # 기존의 data 를 넣어 feature 이 변화된 형태의 data 를 받는다 K_list = [3] # feature 가 많기 때문에 시간이 오래걸려 K의 값을 3만 시뮬레이션 해본다 넣는다. size = 50 sample = np.random.randint(0, t_test.shape[0], size) for K in K_list: # list 에 있는 K값 모두에 대해서 test 를 진행한다 knn_iris = KNN( K, hc_x_train, t_train, label_name) # K, train 값들과 target 의 이름을 넘겨 KNN class 를 생성한다.
def get_data(): # Return MNIST data. # (訓練画像, 訓練ラベル), (テスト画像, テストラベル) # normarize=Trueで正規化(0.0~1.0の間に値を収めてくれる) (x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=True, one_hot_label=False) return x_test, t_test
import sys, os sys.path.append(os.pardir) import numpy as np from dataset.mnist import load_mnist from PIL import Image def img_show(img): pil_img = Image.fromarray(np.uint(img)) pil_img.show() (x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False) #1차원 배열로 저장, 정규화X print(x_train.shape) # 학습데이터 print(t_train.shape) # 학습데이터 레이블(정답) print(x_test.shape) # 테스트데이터 print(t_test.shape) # 테스트데이터 레이블(정답) img = x_train[0] #0번째 훈련 이미지를 가져옴 label = t_train[0] #0번째 훈련 레이블을 가져옴 print(label) # 5 print(img.shape) #(784, ) - 1차원 배열 형태 img = img.reshape(28, 28) #원래 이미지의 모양으로 변형 print(img.shape) #(28, 28) img_show(img)
# coding: utf-8 import sys, os sys.path.append(os.pardir) import numpy as np import matplotlib.pyplot as plt from dataset.mnist import load_mnist from common.multi_layer_net import MultiLayerNet from common.optimizer import SGD, Adam dataset_dir = os.path.dirname(os.path.abspath('__file__')) save_file = dataset_dir + "/mnist.pkl" (x_train, t_train), (x_test, t_test) = load_mnist(dataset_dir, save_file, normalize=True) # 적은 데이터만 사용 x_train = x_train[:1000] t_train = t_train[:1000] max_epochs = 20 train_size = x_train.shape[0] batch_size = 100 learning_rate = 0.01 def __train(weight_init_std): bn_network = MultiLayerNet(input_size=784, hidden_size_list=[100, 100, 100, 100, 100], output_size=10, weight_init_std=weight_init_std, use_batchnorm=True)
def get_data(): (x_train, t_train), (x_test, t_test) = mnist.load_mnist(normalize=True) return x_test, t_test
Created on Mon Feb 25 15:04:43 2019 @author: """ import sys, os sys.path.append(os.pardir) from dataset.mnist import load_mnist import numpy as np from common.functions import softmax, cross_entropy_error (x_train,y_train),(x_test,y_test) = \ load_mnist(normalize=True, one_hot_label=True) class simpleNet: def __init__(self): self.w = np.random.randn(2, 3) def predict(self, x): return np.dot(x, self.w) def loss(self, x, t): z = self.predict(self.w, x) y = softmax(z) loss = cross_entropy_error(y, t) return loss
if __name__ == '__main__': np.random.seed(2020) # 1차원 softmax 테스트 a = np.random.randint(10, size=5) print(a) print(softmax(a)) # 2차원 softmax 테스트 A = np.random.randint(10, size=(2, 3)) print(A) print(softmax(A)) # (Train/Test) 데이터 세트 로드. (X_train, y_train), (X_test, y_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False) print('X_test.shape:', X_test.shape) print('y_test.shape:', y_test.shape) # 신경망 생성 (W1, b1, ...) with open('sample_weight.pkl', 'rb') as file: network = pickle.load(file) W1, W2, W3 = network['W1'], network['W2'], network['W3'] b1, b2, b3 = network['b1'], network['b2'], network['b3'] print('network:', network.keys()) print('W1:', network['W1'].shape) print('W2:', network['W2'].shape) print('W3:', network['W3'].shape) batch_size = 77
# coding: utf-8 import os import sys file_dir = os.path.dirname(__file__) # abs file dir file_pdir = os.path.join(os.path.split(file_dir)[0]) # abs pre file dir print(file_pdir) sys.path.append(file_pdir) # 親ディレクトリのファイルをインポートするための設定 import numpy as np import matplotlib.pyplot as plt from dataset.mnist import load_mnist from common.multi_layer_net_extend import MultiLayerNetExtend from common.trainer import Trainer (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True) # 過学習を再現するために、学習データを削減 x_train = x_train[:300] t_train = t_train[:300] # Dropuoutの有無、割り合いの設定 ======================== use_dropout = True # Dropoutなしのときの場合はFalseに dropout_ratio = 0.2 # ==================================================== network = MultiLayerNetExtend(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100], output_size=10, use_dropout=use_dropout, dropout_ration=dropout_ratio) trainer = Trainer(network, x_train,
def get_data(): (x_train, t_train), (x_test, t_test) = \ load_mnist(normalize=True,flatten=True) return (x_test, t_test)
import sys, os sys.path.append("/Users/aualrxse/git/ME/Deep") # 親ディレクトリのファイルをインポートするための設定 import numpy as np from dataset.mnist import load_mnist (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True) print(x_train.shape) print(t_train.shape) train_size = x_train.shape[0] batch_size = 10 batch_mask = np.random.choice(train_size, batch_size) x_batch = x_train[batch_mask] t_batch = t_train[batch_mask]
import tensorflow as tf from dataset.mnist import load_mnist (x_train, y_train), (x_test, y_test) = load_mnist(flatten=True, normalize=True, one_hot_label=True) train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train)) train_data = train_data.repeat().shuffle(60000).batch(50) train_data_iter = iter(train_data) class CNN(tf.keras.Model): def __init__(self): super(CNN, self).__init__() self.conv_layer1 = tf.keras.layers.Conv2D(filters=32, kernel_size=5, strides=1, padding='same', activation='relu') self.pool_layer1 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2) self.conv_layer2 = tf.keras.layers.Conv2D(filters=64, kernel_size=5, strides=1, padding='same', activation='relu') self.pool_layer2 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2) self.flatten_layer = tf.keras.layers.Flatten() self.fc_layer = tf.keras.layers.Dense(1024, activation='relu')
import sys, os sys.path.append(os.pardir) import numpy as np import pickle from dataset.mnist import load_mnist (x_train, t_train), (x_test, t_test) = \ load_mnist(normalize=True, one_hot_label=True) print(x_train.shape) print(t_train.shape) train_size = x_train.shape[0] batch_size = 10 batch_mask = np.random.choice(train_size,batch_size) x_batch = x_train[batch_mask] t_batch = t_train[batch_mask] print(x_batch) print(t_batch)
# coding: utf-8 import sys, os sys.path.append(os.pardir) # 부모 디렉터리의 파일을 가져올 수 있도록 설정 import numpy as np from dataset.mnist import load_mnist from PIL import Image def img_show(img): pil_img = Image.fromarray(np.uint8(img)) pil_img.show() (x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False) img = x_train[0] label = t_train[0] print(label) # 5 print(img.shape) # (784,) img = img.reshape(28, 28) # 형상을 원래 이미지의 크기로 변형 print(img.shape) # (28, 28) img_show(img)
for key,type in weight_init_types.items(): neural_nets[key] = MultiLayerNet(input_size= 784, hidden_size_list= [100, 100, 100, 100], # 4개의 레이어 그리고 각 레이어의 뉴런 갯수 output_size= 10, weight_init_std = type) # activation = 'sigmoid') # the default activation is relu, but when changed to sigmoid, the result was really bad train_losses[key] = [] # 빈 리스트 생성 - 실험(학습)하면서 손실값들을 저장 # there are two keys: optimizers and weight_init_type # need to arrange on this #MNIST train/test 데이터 로드 (X_train, Y_train), (X_test, Y_test) = load_mnist(one_hot_label = True) iterations = 2_000 # 학습 횟수 batch_size = 128 # 1번 학습에 사용할 샘플 개수 (미니 배치) # optimizers = Sgd(learning_rate = 0.01) optimizers = Adam(lr = 0.01) # optimizer or how we set the parameter # 초기값이 중요한 역할을 할수도 있고, 어떤 최적화 알고리즘을 사용을 하느냐에 따라서 (regardless of initial values), 학습되는 양? 이 다를 수도 있다 # optimizer with Adam resulted in horrible # optimizers = dict() # optimizers['SGD'] = Sgd(learning_rate = 0.01) #파라미터 최적화 알고리즘 # optimizers['Momentum'] = Momentum(lr = 0.01) # optimizers['Adagrad'] = AdaGrad(lr = 0.01) # optimizers['ADAM'] = Adam(lr = 0.01) # optimizers['RMSprop'] = RMSprop(lr = 0.01)
def get_data(): (x_train,t_train),(x_test,t_test)=load_mnist(flatten=True,normalize=False) return x_test,t_test
# coding: utf-8 import sys, os sys.path.append(os.pardir) import numpy as np import matplotlib.pyplot as plt from dataset.mnist import load_mnist from PIL import Image def img_show(img): pil_img = Image.fromarray(np.uint8(img)) pil_img.show() (x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False, one_hot_label = False) pp = [] j = 0 for i in range(len(t_test)): if t_test[i] == 5: pp.append(i) else: pass type(pp) len(pp) j = 0 for i in pp: j += 1 if j > 70: break img = x_test[i]
# coding: utf-8 import sys, os sys.path.append(os.pardir) # 부모 디렉터리의 파일을 가져올 수 있도록 설정 import numpy as np import matplotlib.pyplot as plt from deep_convnet import DeepConvNet from dataset.mnist import load_mnist (x_train, t_train), (x_test, t_test) = load_mnist(flatten=False) network = DeepConvNet() network.load_params("deep_convnet_params.pkl") print("calculating test accuracy ... ") #sampled = 1000 #x_test = x_test[:sampled] #t_test = t_test[:sampled] classified_ids = [] acc = 0.0 batch_size = 100 for i in range(int(x_test.shape[0] / batch_size)): tx = x_test[i * batch_size:(i + 1) * batch_size] tt = t_test[i * batch_size:(i + 1) * batch_size] y = network.predict(tx, train_flg=False) y = np.argmax(y, axis=1) classified_ids.append(y) acc += np.sum(y == tt)
# coding: utf-8 import sys, os sys.path.append(os.pardir) # 親ディレクトリのファイルをインポートするための設定 import numpy as np import matplotlib.pyplot as plt from dataset.mnist import load_mnist from simple_convnet import SimpleConvNet from common.trainer import Trainer # データの読み込み (x_train, t_train), (x_test, t_test) = load_mnist(flatten=False) # 処理に時間のかかる場合はデータを削減 #x_train, t_train = x_train[:5000], t_train[:5000] #x_test, t_test = x_test[:1000], t_test[:1000] max_epochs = 20 network = SimpleConvNet(input_dim=(1,28,28), conv_param = {'filter_num': 30, 'filter_size': 5, 'pad': 0, 'stride': 1}, hidden_size=100, output_size=10, weight_init_std=0.01) trainer = Trainer(network, x_train, t_train, x_test, t_test, epochs=max_epochs, mini_batch_size=100, optimizer='Adam', optimizer_param={'lr': 0.001}, evaluate_sample_num_per_epoch=1000) trainer.train() # パラメータの保存 network.save_params("params.pkl") print("Saved Network Parameters!")
from dataset.mnist import load_mnist from PIL import Image from image_print import ImagePrint import random #from simple_convnet import SimpleConvNet #from trainer import Trainer graph = ImagePrint( 28, 28, 5, 6, 1, 100) # Picture Width, Height / Picture Count X, Y / Space / BG Color (x_train, t_train), (x_test, t_test) = load_mnist(flatten=False) #normalization : default, TRUE count = x_train.shape[0] count_out = 11 print("Study Image Count :", count) num = random.randint(0, count - count_out) for i in range(count_out): print("#{} label:{}".format(num + i, t_train[num + i])) graph.input_image(i, x_train[num + i, 0].reshape(-1), 255) graph.img_show() """ max_epochs = 20
# coding: utf-8 import sys, os sys.path.append(os.pardir) # 親ディレクトリのファイルをインポートするための設定 import numpy as np import matplotlib.pyplot as plt from dataset.mnist import load_mnist from common.multi_layer_net_extend import MultiLayerNetExtend from common.optimizer import SGD, Adam (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True) # 学習データを削減 x_train = x_train[:1000] t_train = t_train[:1000] max_epochs = 20 train_size = x_train.shape[0] batch_size = 100 learning_rate = 0.01 def __train(weight_init_std): bn_network = MultiLayerNetExtend(input_size=784, hidden_size_list=[100, 100, 100, 100, 100], output_size=10, weight_init_std=weight_init_std, use_batchnorm=True) network = MultiLayerNetExtend(input_size=784, hidden_size_list=[100, 100, 100, 100, 100], output_size=10, weight_init_std=weight_init_std) optimizer = SGD(lr=learning_rate) train_acc_list = [] bn_train_acc_list = []
from PyQt5.QtWidgets import QLabel, QMessageBox, QPushButton, QFrame from PyQt5.QtGui import QPainter, QPen, QPixmap, QColor, QImage from PyQt5.QtCore import Qt, QPoint, QSize from simple_convnet import SimpleConvNet from common.functions import softmax from deep_convnet import DeepConvNet MODE_MNIST = 1 # MNIST随机抽取 MODE_WRITE = 2 # 手写输入 Thresh = 0.5 # 识别结果置信度阈值 # 读取MNIST数据集 (_, _), (x_test, _) = load_mnist(normalize=True, flatten=False, one_hot_label=False) # 初始化网络 # 简单CNN """ conv - relu - pool - affine - relu - affine - softmax """ network = SimpleConvNet(input_dim=(1, 28, 28), conv_param={ 'filter_num': 30, 'filter_size': 5, 'pad': 0, 'stride': 1 },
import os import sys import numpy as np from PIL import Image sys.path.append(os.pardir) from dataset.mnist import load_mnist def img_show(img): pil_img = Image.fromarray(np.uint8(img)) pil_img.show() (x_train, t_train), (x_test, t_test) = \ load_mnist(flatten=True, normalize=False) print(x_train.shape) print(t_train.shape) print(x_test.shape) print(t_test.shape) img = x_train[0] label = t_train[0] print(label) print(img.shape) img = img.reshape(28,28) print(img.shape) img_show(img)
def get_train_data(): (x_train, t_train), (x_test, t_test) = \ load_mnist(flatten=True, one_hot_label=True) return x_train, t_train