def test_mnist(): from mnist_loader import load_data_wrapper as load_mnist train_data, valid_data, test_data = load_mnist() # evaluate_knearestneighbor(train_data, valid_data, test_data) # evaluate_linear(train_data, valid_data, test_data) # evaluate_seq_nn(train_data, valid_data, test_data) evaluate_seq_cnn(train_data, valid_data, test_data, (28, 28))
def test_mnist(): from mnist_loader import load_data_wrapper as load_mnist train_data, valid_data, test_data = load_mnist() # evaluate_knearestneighbor(train_data, valid_data, test_data) # evaluate_linear(train_data, valid_data, test_data) # evaluate_seq_nn(train_data, valid_data, test_data) evaluate_seq_cnn(train_data, valid_data, test_data, (28,28))
for i in range(N): conf_matrix[L[i], C[i]] += 1 return accuracy, conf_matrix def plot_confusion_matrix(conf_matrix, figure_id, title): plt.figure(figure_id) (N, _) = conf_matrix.shape plt.imshow(conf_matrix, interpolation='nearest') plt.xticks(np.arange(0, N), map(str, range(N))) plt.yticks(np.arange(0, N), map(str, range(N))) plt.title(title) data = load_mnist() N_train = data["train_no"] #N_train = 20000 X_train = data["train_imgs"].squeeze()[:N_train, :] L_train = data["train_labels"][:N_train] T_train = np.zeros((N_train, L_train.max() + 1)) T_train[np.arange(N_train), L_train] = 1 N_test = data["test_no"] X_test = data["test_imgs"].squeeze() L_test = data["test_labels"] T_test = np.zeros((N_test, L_test.max() + 1)) T_test[np.arange(N_test), L_test] = 1 # ------------------------------------------------------------------------------
def sigmoid(z): return 1.0/(1.0+np.exp(-z)) def sigmoid_prime(z): return sigmoid(z)*(1.0-sigmoid(z)) def softmax(y): return np.exp(y)/np.sum(np.exp(y)) DATA_FILE = 'mnist.pkl.gz' LAYER_SIZES = [784, 100, 10] NUM_LAYERS = len(LAYER_SIZES)-1 TRAINING_ITER = 50000 ETA = 0.05 training_data, validation_data, test_data = load_mnist(data_path=DATA_FILE) weights = [np.random.randn(LAYER_SIZES[i+1], LAYER_SIZES[i]) for i in range(NUM_LAYERS)] biases = [np.zeros((LAYER_SIZES[i+1], 1)) for i in range(NUM_LAYERS)] ### TRAINING ### for iter in range(TRAINING_ITER): x, y = training_data[random.randint(0, len(training_data)-1)] x = x.reshape(x.size, 1) zs, activations = [], [] # FORWARD PASS # Store the input activations to each layer, as well as the resulting z values activation = x for i in range(NUM_LAYERS): activations.append(activation)
"""Investigating the effect network architecture has on MNIST performance.""" import numpy as np import network_library import mnist_loader # load the MNIST dataset using the mnist_loader file---the returned # data structure is a list containing the training data, the validation # data, and the test data. data = mnist_loader.load_mnist() # Set training data and training labels. The training dataset is a set # of 50,000 MNIST (hand-drawn digit) images. training_data = data[0] training_labels = data[1] # Set validation data and validation labels. The validation dataset is a # set of 10,000 MNIST (hand-drawn digit) images. validation_data = data[2] validation_labels = data[3] # Set test data and test labels. The test dataset is a # set of 10,000 MNIST (hand-drawn digit) images. test_data = data[4] test_labels = data[5] # Instantiate the first neural network. net1 = network_library.Network([784, 100, 100, 10], 0.6, 64, cost_function=network_library.QuadraticCost)
high=np.sqrt(1.0/dim1), size=(dim1, dim2)).astype('float32') def initialize_weights_xavier_uniform(dim1, dim2): return np.random.uniform(low=-np.sqrt(6.0/(dim1 + dim2)), high=np.sqrt(6.0/(dim1 + dim2)), size=(dim1, dim2)).astype('float32') def initialize_weights_he_normal(dim1, dim2): return np.sqrt(2.0 / dim1) * np.random.normal(size=(dim1, dim2)) # load datas x_train, t_train, x_test, t_test = load_mnist() # normalize x_train = x_train / 255 x_test = x_test / 255 # convert to one-hot t_train = np.eye(10)[t_train] # train valid split x_train, x_valid, t_train, t_valid = train_test_split(x_train, t_train, test_size=0.2) #x_train, t_train, x_test, t_test = x_train[0:101], t_train[0:101], x_test[0:101], t_test[0:101] # init weights and biases w1 = initialize_weights_he_normal(784, 100)
# -*- coding: utf-8 -*- import numpy as np from mnist_loader import load_mnist import matplotlib.pyplot as plt import utils from nn import NeuralNetwork from linear import Linear from relu import Relu from softmax import Softmax #%% 载入 mnist 数据集 X, y = load_mnist(dataset="training", path="mnist") testX, testy = load_mnist(dataset="testing", path="mnist") print(X.shape) print(y.shape) print(testX.shape) print(testy.shape) #%% 显示 mnist 数据集中图像 utils.show_mnist(X, y, 5, 5) #%% 定义常量 n_feature = 28 * 28 n_iter = 2 lr = 0.0001 #%% 处理数据集 # unroll feature X = X.reshape((60000, n_feature)) testX = testX.reshape((10000, n_feature))
import numpy as np import tensorflow as tf import matplotlib.pyplot as plt from mnist_loader import load_mnist, make_mnist_subset_categorical_labels from multi_network import Network from plotting import plot_average_split_mnist_scores training_data, validation_data, test_data = load_mnist() # Create data subsets train_images = [] train_labels = [] test_images = [] test_labels = [] for train_task in range(0, 10, 2): train_x, train_y = make_mnist_subset_categorical_labels( training_data, [train_task, train_task + 1]) test_x, test_y = make_mnist_subset_categorical_labels( test_data, [train_task, train_task + 1]) train_images.append(train_x) train_labels.append(train_y) test_images.append(test_x) test_labels.append(test_y) # Create 5-headed network: net = Network(5) net.learning_rate = 0.01 ############################################## RUN THE MODEL ######################################################## n_runs = 10
# random_img.py # process images by random indexing # libraries import numpy as np from mnist_loader import load_mnist import rimgs import matplotlib.pyplot as plt import utils limit_images = 100 # load images images, labels = load_mnist('training') print images.shape random_shuffle = np.random.permutation(np.r_[0:images.shape[0]]) images = images[random_shuffle[0:2 * limit_images], :, :] images_train = images[0:limit_images, :, :] images_test = images[limit_images:, :, :] print images.shape digits = [] for i in xrange(10): digits.append(str(i)) # initialize random indexing object s, t = 2, 3 # factored out number of bases for plotting purposes N, k, b = (256 * 10, 128 * 10, s * t) window = 2 sample_num = 10000 RIM = rimgs.RIImages(N, k, b) #print RIM.RI_letters.shape #print RIM.RI_letters
def train_mnist(): # prepare data training_data, test_data = mnist_loader.load_mnist() x_t, y_t = test_data x_tr, y_tr = training_data # shuffle training set perm = np.arange(x_tr.shape[1]) np.random.shuffle(perm) x_tr = x_tr[:, perm] y_tr = y_tr[:, perm] # distinguish validation set validation_set_size = 10000 x_v = x_tr[:, :validation_set_size] y_v = y_tr[:, :validation_set_size] x_tr = x_tr[:, validation_set_size:] y_tr = y_tr[:, validation_set_size:] # implement callback learning = [] def callback(epoch, test, time): acc_v, cost_v = test(x_v, y_v) acc_t, cost_t = test(x_tr, y_tr) learning.append([epoch, acc_v, cost_v, time, acc_t, cost_t]) print("Epoch: {0}\t | Validation: accuracy:{1} cost:{2:.3f}" " Training: accuracy:{3} cost:{4:.3f} {5:.3f}s".format( epoch, acc_v, cost_v, acc_t, cost_t, time)) # build network network = ann.ANN.NetworkBuilder() \ .addInputLayer(784) \ .addLayer(100, ut.sigmoid, ut.sigmoid_derivative) \ .addLayer(100, ut.sigmoid, ut.sigmoid_derivative) \ .addOutputLayer(10, ann.ANN.NetworkBuilder.softmax) \ .addRegularization(ann.ANN.NetworkBuilder.L2) \ .build() # start learning network.train(training_data=(x_tr, y_tr), epochs=35, learning_rate=0.5, batch_size=50, regularization_rate=5, callback=callback) # evaluate on test data acc, cost = network.test(x_t, y_t) print("Test: accuracy: {}/{} | cost: {}".format(acc, x_t.shape[1], cost)) plot_mnist_learning(learning) # load 28x28 gray-scale image and use network to recognize the digit recognize_digit(network, "./three.bmp") # serialize network print("Saving network: \"./net\"") ut.save(network, "./net") # load network print("Loading network: \"./net\"") network = ut.load("./net") # load 28x28 gray-scale image and use network to recognize the digit print("After loading:") recognize_digit(network, "./three.bmp") learning = [] # more training network.train(training_data=(x_tr, y_tr), epochs=20, learning_rate=0.01, batch_size=50, regularization_rate=5, callback=callback) # evaluate on test data acc, cost = network.test(x_t, y_t) print("Test: accuracy: {}/{} | cost: {}".format(acc, x_t.shape[1], cost)) # load 28x28 gray-scale image and use network to recognize the digit print("After more training") recognize_digit(network, "./three.bmp") plot_mnist_learning(learning)
tf.truncated_normal([512, label_cnt], stddev=0.1, dtype=tf.float16)) fc2_biases = tf.Variable(tf.constant(0.1, shape=[label_cnt], dtype=tf.float16)) logits = tf.matmul(hidden, fc2_weights) + fc2_biases loss = tf.reduce_mean( tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=labels)) regularizers = (tf.nn.l2_loss(fc1_weights) + tf.nn.l2_loss(fc1_biases) + tf.nn.l2_loss(fc2_weights) + tf.nn.l2_loss(fc2_biases)) loss += 5e-4 * regularizers optimizer = tf.train.MomentumOptimizer(0.1, 0.9).minimize(loss) train_prediction = tf.nn.softmax(logits) train_data, train_labels, validation_data, validation_labels = loader.load_mnist( ) train_size = train_labels.shape[0] start_time = time.time() with tf.Session() as sess: tf.global_variables_initializer().run() for step in xrange(int(num_epochs * train_size) // batch_size): offset = (step * batch_size) % (train_size - batch_size) batch_data = train_data[offset:(offset + batch_size), ...] batch_labels = train_labels[offset:(offset + batch_size)] feed_dict = {inputs: batch_data, labels: batch_labels} loss_result, _ = sess.run([loss, optimizer], feed_dict=feed_dict) if step % 100 == 0: elapsed_time = time.time() - start_time start_time = time.time() print('Step %d (epoch %.2f), %.1f ms' % (step, float(step) * batch_size / train_size,
def dataloader(dataset_name="mnist"): if dataset_name == "mnist": x, y = mnist_loader.load_mnist( 'C:/Users/DELL/Desktop/All_Files/Programs/MNIST') return x, y pass
# -*- coding: utf-8 -*- """ Created on Fri May 10 15:03:08 2019 @author: Chinedu Anigbogu """ from mnist_loader import load_mnist from cifar_10 import load_cifar_10_py #cifar_dir='your local cifar-10 directory' #mnist_dir='your local mnist directory' cifar_dir = r'C:\Users\Chinedu\Desktop\mnist\cifar-10-batches-py' mnist_dir = r'C:\Users\Chinedu\Desktop\mnist' # for mnist train_images, train_labels, test_images, test_labels = load_mnist(mnist_dir) # for ciar-10 train_data,train_labels,test_data,test_labels,train_filenames,\ test_filenames,label_names=load_cifar_10_py(cifar_dir)