def nonLinearTest():
# Read in training data
print("Reading in data...")
train_params = {"nEpochs": 100, "nBatch": 600}
addFeatures = 20
nSamples = None
nClasses = 2
train_data = readDataFromCsv(
"/Users/stefanjeske/Downloads/mnist/train_data.csv", np.float,
nSamples, ',')
train_labels_temp = readDataFromCsv(
"/Users/stefanjeske/Downloads/mnist/train_label.csv", np.int, nSamples,
',')
train_data /= 10
train_labels = np.squeeze(train_labels_temp)
# Get the feature space
nSamples, nD = train_data.shape
print(f"Number of samples: {nSamples}; Number of Dimensions: {nD}")
# Create a new network and add layers
print("Creating neural network...")
net = netw.NeuralNet()
net.add_layer(md.Linear(nD, nD + addFeatures))
net.add_layer(md.ReLU(nD + addFeatures))
net.add_layer(md.Linear(nD + addFeatures, nClasses))
net.add_layer(md.Softmax(nD))
net.init_weights(method="glorot")
net.train(train_data, train_labels, train_params, method="minibatch")
valid_data = readDataFromCsv(
"/Users/stefanjeske/Downloads/mnist/valid_data.csv", np.float,
nSamples, ',')
valid_labels_temp = readDataFromCsv(
"/Users/stefanjeske/Downloads/mnist/valid_label.csv", np.int, nSamples,
',')
valid_data /= 10
valid_labels = np.squeeze(valid_labels_temp)
nValSamples, nDim = valid_data.shape
classify = net.fprop(valid_data)
errors = nValSamples - np.count_nonzero(
valid_labels == np.argmax(classify, axis=1))
print(f"Total numer of missclassified data points: {errors}")
def make_model(args):
''' Create the neural network model as required '''
model = args.model
theano_rng = theano.tensor.shared_randomstreams.RandomStreams(0)
rng = None if args.marginalised else theano_rng
if model == 'autoencoder':
# pure autoencoder model, typically used for pretraining
layers = make_layers(args.layer_files, args.additional_layers, False)
model = models.StackedAutoencoder(layers, args.corruption_level, rng)
elif model == 'deep_autoencoder':
# autoencoder, except trains multiple layers at a time
layers = make_layers(args.layer_files, args.additional_layers, False)
model = models.DeepAutoencoder(layers, args.corruption_level, rng)
elif model == 'softmax':
# pure multilayer perceptron model with softmax layer on bottom
layers = make_layers(args.layer_files, args.additional_layers, True)
model = models.Softmax(layers, args.iterations)
elif model == 'adapting':
# create the policy
policy = getattr(policies, args.policy)
# self adapting with a policy
layers = make_layers(args.layer_files, args.additional_layers, True)
model = models.AdaptingCombinedObjective(layers, args.corruption_level,
rng, args.iterations,
args.lam, args.mi_batch_size,
args.pool_size, policy())
elif model == 'combined':
# pure multilayer perceptron model with softmax layer on bottom
layers = make_layers(args.layer_files, args.additional_layers, True)
model = models.CombinedObjective(layers, args.corruption_level, rng,
args.lam, args.iterations)
else:
raise ValueError(args.model + ' is not a known model')
# initialise the model
model.process(T.matrix('x'), T.ivector('y'))
return model
def train(args):
import models
import numpy as np
np.random.seed(1234)
if args.dataset == 'digits':
n_dim, n_out, n_channels = 8, 10, 1
X_train, y_train, X_val, y_val = data.load_digits()
elif args.dataset == 'mnist':
n_dim, n_out, n_channels = 28, 10, 1
X_train, y_train, X_val, y_val, _, _ = data.load_mnist()
elif args.dataset == 'svhn':
n_dim, n_out, n_channels = 32, 10, 3
X_train, y_train, X_val, y_val = data.load_svhn()
X_train, y_train, X_val, y_val = data.prepare_dataset(X_train, y_train, X_val, y_val)
elif args.dataset == 'cifar10':
n_dim, n_out, n_channels = 32, 10, 3
X_train, y_train, X_val, y_val = data.load_cifar10()
X_train, y_train, X_val, y_val = data.prepare_dataset(X_train, y_train, X_val, y_val)
elif args.dataset == 'random':
n_dim, n_out, n_channels = 2, 2, 1
X_train, y_train = data.load_noise(n=1000, d=n_dim)
X_val, y_val = X_train, y_train
else:
raise ValueError('Invalid dataset name: %s' % args.dataset)
print 'dataset loaded, dim:', X_train.shape
# set up optimization params
p = { 'lr' : args.lr, 'b1': args.b1, 'b2': args.b2 }
# create model
if args.model == 'softmax':
model = models.Softmax(n_dim=n_dim, n_out=n_out, n_superbatch=args.n_superbatch,
opt_alg=args.alg, opt_params=p)
elif args.model == 'mlp':
model = models.MLP(n_dim=n_dim, n_out=n_out, n_superbatch=args.n_superbatch,
opt_alg=args.alg, opt_params=p)
elif args.model == 'cnn':
model = models.CNN(n_dim=n_dim, n_out=n_out, n_chan=n_channels, model=args.dataset,
n_superbatch=args.n_superbatch, opt_alg=args.alg, opt_params=p)
elif args.model == 'kcnn':
model = models.KCNN(n_dim=n_dim, n_out=n_out, n_chan=n_channels, model=args.dataset,
n_superbatch=args.n_superbatch, opt_alg=args.alg, opt_params=p)
elif args.model == 'resnet':
model = models.Resnet(n_dim=n_dim, n_out=n_out, n_chan=n_channels,
n_superbatch=args.n_superbatch, opt_alg=args.alg, opt_params=p)
elif args.model == 'vae':
model = models.VAE(n_dim=n_dim, n_out=n_out, n_chan=n_channels, n_batch=args.n_batch,
n_superbatch=args.n_superbatch, opt_alg=args.alg, opt_params=p,
model='bernoulli' if args.dataset in ('digits', 'mnist')
else 'gaussian')
elif args.model == 'convvae':
model = models.ConvVAE(n_dim=n_dim, n_out=n_out, n_chan=n_channels, n_batch=args.n_batch,
n_superbatch=args.n_superbatch, opt_alg=args.alg, opt_params=p,
model='bernoulli' if args.dataset in ('digits', 'mnist')
else 'gaussian')
elif args.model == 'convadgm':
model = models.ConvADGM(n_dim=n_dim, n_out=n_out, n_chan=n_channels, n_batch=args.n_batch,
n_superbatch=args.n_superbatch, opt_alg=args.alg, opt_params=p,
model='bernoulli' if args.dataset in ('digits', 'mnist')
else 'gaussian')
elif args.model == 'sbn':
model = models.SBN(n_dim=n_dim, n_out=n_out, n_chan=n_channels,
n_superbatch=args.n_superbatch, opt_alg=args.alg, opt_params=p)
elif args.model == 'adgm':
model = models.ADGM(n_dim=n_dim, n_out=n_out, n_chan=n_channels, n_batch=args.n_batch,
n_superbatch=args.n_superbatch, opt_alg=args.alg, opt_params=p,
model='bernoulli' if args.dataset in ('digits', 'mnist')
else 'gaussian')
elif args.model == 'hdgm':
model = models.HDGM(n_dim=n_dim, n_out=n_out, n_chan=n_channels, n_batch=args.n_batch,
n_superbatch=args.n_superbatch, opt_alg=args.alg, opt_params=p)
elif args.model == 'dadgm':
model = models.DADGM(n_dim=n_dim, n_out=n_out, n_chan=n_channels,
n_superbatch=args.n_superbatch, opt_alg=args.alg, opt_params=p)
elif args.model == 'dcgan':
model = models.DCGAN(n_dim=n_dim, n_out=n_out, n_chan=n_channels,
n_superbatch=args.n_superbatch, opt_alg=args.alg, opt_params=p)
elif args.model == 'ssadgm':
X_train_lbl, y_train_lbl, X_train_unl, y_train_unl \
= data.split_semisup(X_train, y_train, n_lbl=args.n_labeled)
model = models.SSADGM(X_labeled=X_train_lbl, y_labeled=y_train_lbl, n_out=n_out,
n_superbatch=args.n_superbatch, opt_alg=args.alg, opt_params=p)
X_train, y_train = X_train_unl, y_train_unl
else:
raise ValueError('Invalid model')
# train model
model.fit(X_train, y_train, X_val, y_val,
n_epoch=args.epochs, n_batch=args.n_batch,
logname=args.logname)
def init_net_2a(**kwargs):
# Read in training data
print("Reading in data...")
train_params = {"nEpochs": 100, "nBatch": 600}
nEpochs = 100
nBatch = 600
nSamples = None
nClasses = 10
train_data = readDataFromCsv(
"/Users/stefanjeske/Downloads/mnist/mnist-train-data.csv", np.float,
nSamples)
train_data /= 255.
train_labels_temp = readDataFromCsv(
"/Users/stefanjeske/Downloads/mnist/mnist-train-labels.csv", np.int,
nSamples)
train_labels = np.squeeze(train_labels_temp)
# Get the feature space
nSamples, nD = train_data.shape
# Create a new network and add layers
print("Creating neural network...")
net = netw.NeuralNet()
net.add_layer(md.Linear(nD, 200))
net.add_layer(md.ReLU(200))
net.add_layer(md.Linear(200, nClasses))
net.add_layer(md.Softmax(nD))
net.init_weights(method="glorot")
# Load model if specified and availiable
if ('load_model' in kwargs and kwargs['load_model'] == True):
if ('model_path' in kwargs):
print("Loading neural network...")
with open(kwargs['model_path'], 'rb') as output:
net = pkl.load(output)
else:
print("Please specify a path to the model")
else:
# Train the network
print("Training neural network...")
for epoch in range(0, nEpochs):
#print("Training in Epoch {0}".format(epoch))
# Use random permutation of the data
indices = np.random.permutation(np.arange(nSamples))
for batch in range(0, int(np.ceil(float(nSamples) / nBatch))):
batch_indices = indices[np.arange(
batch * nBatch, min((batch + 1) * nBatch, nSamples))]
mean_err = net.train_net(train_data[batch_indices, :],
train_labels[batch_indices], nClasses,
len(batch_indices))
print("At Epoch: {0}\nMean error: {1}".format(epoch, mean_err))
# Save the model if desired
if ('save_model' in kwargs and kwargs['save_model'] == True):
if ('model_path' in kwargs):
print(f"Writing neural network to: {kwargs['model_path']}")
with open(kwargs['model_path'], 'wb') as output:
pkl.dump(net, output)
else:
print("Please specify a path to the model")
valid_data = readDataFromCsv(
"/Users/stefanjeske/Downloads/mnist/mnist-valid-data.csv", np.float,
nSamples)
valid_data /= 255.
valid_labels_temp = readDataFromCsv(
"/Users/stefanjeske/Downloads/mnist/mnist-valid-labels.csv", np.int,
nSamples)
valid_labels = np.squeeze(valid_labels_temp)
nValSamples, nDim = valid_data.shape
classify = net.fprop(valid_data)
errors = nValSamples - np.count_nonzero(
valid_labels == np.argmax(classify, axis=1))
print(f"Total numer of missclassified data points: {errors}")