def load_mnist(dataset="train", digits=np.arange(10), path=".", size=60000):
train_set, test_set = data.load_mnist(f'{path}/mnist.pkl.gz')
if dataset == "train":
img, lbl = train_set
num, n_pixels = img.shape
n_dim = int(math.sqrt(n_pixels))
rows, cols = n_dim, n_dim
elif dataset == "test":
img, lbl = test_set
num, n_pixels = img.shape
n_dim = int(math.sqrt(n_pixels))
rows, cols = n_dim, n_dim
else:
raise ValueError("dataset must be 'test' or 'train'")
N = size * len(digits)
images = np.zeros((N, rows, cols), dtype='float32')
labels = np.zeros((N, 1), dtype='int8')
for i, label in enumerate(digits):
ind = []
for j, l in enumerate(lbl):
if len(ind) >= size:
break
if l == label:
ind.append(j)
for j in range(size): #int(len(ind) * size/100.)):
images[i * size + j] = np.array(img[ind[j]].reshape((rows, cols)))
labels[i * size + j] = lbl[ind[j]]
labels = np.array([label[0] for label in labels])
rand = np.random.permutation(N)
labels = labels[rand]
images = images[rand]
return images, labels
def one_hot(labels, c=None):
assert labels.ndim == 1
n = labels.shape[0]
c = len(np.unique(labels)) if c is None else c
y = np.zeros((n, c))
y[np.arange(n), labels] = 1
return y
rng = np.random.RandomState(9)
# --- load the data
(X_train, y_train), (X_test, y_test) = load_mnist()
X_train = 2 * X_train - 1 # normalize to -1 to 1
X_test = 2 * X_test - 1 # normalize to -1 to 1
train_targets = one_hot(y_train, 10)
test_targets = one_hot(y_test, 10)
# --- set up network parameters
n_vis = X_train.shape[1]
n_out = train_targets.shape[1]
# n_hid = 300
n_hid = 1000
# n_hid = 3000
# encoders = rng.normal(size=(n_hid, 11, 11))
from hunse_thesis.neurons import static_f_df, linear, dlinear, relu, drelu
from hunse_thesis.offline_learning import (Network, BPLearner, FALearner,
FALocalLearner, FASkipLearner,
make_flat_batch_fn,
make_random_batch_fn)
from hunse_thesis.offline_learning import (nll_cost_on_inds,
class_error_on_inds)
from hunse_thesis.utils import orthogonalize, initial_weights, initial_w
sns.set_style('white')
sns.set(context='paper', style='ticks', palette='dark')
# --- problem dataset
(trainX, trainY), (testX, testY) = load_mnist('~/data/mnist.pkl.gz')
labels = np.unique(trainY)
n_labels = len(labels)
# trainX, trainY = trainX[:100], trainY[:100] # quick training set
# trainX, trainY = trainX[:1000], trainY[:1000] # quick training set
# trainX, trainY = trainX[:10000], trainY[:10000] # quick training set
def preprocess(images):
images[:] *= 2
images[:] -= 1
preprocess(trainX), preprocess(testX)
from src.Neuron.LIF import LIF
from src.Log.DataLog import DataLog
from nengo_extras.data import load_mnist
from src.LearningRule.simplified_stdp import STDP
from src.Input.InputData import PresentInputWithPause
from src.Log.Heatmap import HeatMapSave, AllHeatMapSave
#############################
# load the data
#############################
img_rows, img_cols = 28, 28
input_nbr = 1000
Dataset = "Mnist"
(image_train, label_train), (image_test,
label_test) = load_mnist("mnist.pkl.gz")
image_train_filtered = []
label_train_filtered = []
for i in range(0, input_nbr):
image_train_filtered.append(image_train[i])
label_train_filtered.append(label_train[i])
print("actual input", len(label_train_filtered))
image_train_filtered = np.array(image_train_filtered)
label_train_filtered = np.array(label_train_filtered)
#############################
#############################
# load the data
#############################
try:
NetworkInfo = sys.argv[1]
except Exception:
print("Make sure to pass the network arguments !")
exit(0)
input_nbr = 10000
classes = 10
(image_train, label_train), (image_test, label_test) = load_mnist("mnist.pkl.gz")
image_test_filtered = []
label_test_filtered = []
for i in range(0,input_nbr):
image_test_filtered.append(image_test[i])
label_test_filtered.append(label_test[i])
image_test_filtered = np.array(image_test_filtered)
label_test_filtered = np.array(label_test_filtered)
#############################
model = nengo.Network("My network")
#############################
Encoder, ShallowNetwork, FASkipNetwork, FATwoStepNetwork)
from hunse_thesis.utils import initial_weights
from plot_online_mnist import show_all_plots, print_test_errors
def eye_encoders(d):
return Tile(np.vstack((np.eye(d), -np.eye(d))))
warnings.filterwarnings('ignore', message='This learning rate is very high')
# rng = np.random.RandomState(9)
rng = np.random.RandomState(8)
# rng = np.random
# --- data
mnist = load_mnist('~/data/mnist.pkl.gz')
(Xtrain, Ytrain), (Xtest, Ytest) = mnist
labels = np.unique(Ytrain)
n_labels = len(labels)
def preprocess(images):
images[:] *= 2
images[:] -= 1
preprocess(Xtrain), preprocess(Xtest)
Ttrain = one_hot_from_labels(Ytrain, classes=n_labels)
Ttest = one_hot_from_labels(Ytest, classes=n_labels)
# --- params
# dhids = [600, 300]
from nengo_extras.data import load_mnist, one_hot_from_labels
from nengo_extras.vision import Gabor, Mask, ciw_encoders
# from nengo_extras.vision import Gabor, Mask, ciw_encoders, cd_encoders_biases
import hunse_thesis.solvers
# from hunse_thesis.vision import (
# percentile_encoders_intercepts, scale_encoders_intercepts)
rng = np.random.RandomState(1)
# --- load data
s_in = (28, 28)
n_in = np.prod(s_in)
n_out = 10
train, test = load_mnist('~/data/mnist.pkl.gz')
# train = (train[0][:1000], train[1][:1000])
# train = (train[0][:10000], train[1][:10000])
train_images, train_labels = train
test_images, test_labels = test
for images in [train_images, test_images]:
images[:] = 2 * images - 1 # normalize to -1 to 1
train_targets = one_hot_from_labels(train_labels, classes=10)
test_targets = one_hot_from_labels(test_labels, classes=10)
assert train_images.shape[1] == n_in
assert train_targets.shape[1] == n_out
# --- network
def test_load_mnist(plt):
trainX = load_mnist()[0][0]
tile(trainX.reshape((-1, 28, 28)), ax=plt.gca())
from src.Neuron.LIF import LIF
#############################
# load the data
#############################
np.random.seed(0)
NetworkInfo = sys.argv[1]
input_nbr = 10000
class_input_nbr = 1000
classes = 10
(image_train, label_train), (image_test, label_test) = load_mnist()
image_test_filtered = []
label_test_filtered = []
class_image_filtered = []
class_label_filtered = []
for i in range(0,input_nbr):
image_test_filtered.append(image_test[i])
label_test_filtered.append(label_test[i])
image_test_filtered = np.array(image_test_filtered)
label_test_filtered = np.array(label_test_filtered)
for i in range(0,10):
def test_load_mnist(plt):
(trainX, _), (_, _) = load_mnist()
tile(trainX.reshape(-1, 28, 28))
