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)
