def test_classification():
# Make dataset
n_classes = 2
n_samples = 1000
n_features = 48
x, y = make_classification(n_samples=n_samples,
n_features=n_features,
n_classes=n_classes,
n_informative=n_classes * 2,
random_state=1)
x = x.astype(dp.float_)
y = y.astype(dp.int_)
n_train = int(0.8 * n_samples)
x_train = x[:n_train]
y_train = y[:n_train]
x_test = x[n_train:]
y_test = y[n_train:]
scaler = dp.StandardScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)
# Setup input
batch_size = 16
train_input = dp.SupervisedInput(x_train, y_train, batch_size=batch_size)
test_input = dp.Input(x_test)
# Setup neural network
weight_decay = 1e-03
net = dp.NeuralNetwork(
layers=[
dp.Affine(
n_out=32,
weights=dp.Parameter(dp.AutoFiller(),
weight_decay=weight_decay),
),
dp.ReLU(),
dp.Affine(
n_out=64,
weights=dp.Parameter(dp.AutoFiller(),
weight_decay=weight_decay),
),
dp.ReLU(),
dp.Affine(
n_out=n_classes,
weights=dp.Parameter(dp.AutoFiller()),
),
],
loss=dp.SoftmaxCrossEntropy(),
)
# Train neural network
learn_rule = dp.Momentum(learn_rate=0.01 / batch_size, momentum=0.9)
trainer = dp.GradientDescent(net, train_input, learn_rule)
trainer.train_epochs(n_epochs=10)
# Evaluate on test data
error = np.mean(net.predict(test_input) != y_test)
print('Test error rate: %.4f' % error)
assert error < 0.2
def train_minibatch(self, minibatch):
"""
Train function that transforms (state,action,reward,state) into (input, expected_output) for neural net
and trains the network
@param minibatch: list of arrays: prestates, actions, rewards, poststates
"""
prestates, actions, rewards, poststates = minibatch
prestates = dp.Input(prestates)
# predict Q-values for prestates, so we can keep Q-values for other actions unchanged
qvalues = self.nnet.predict(prestates)
# predict Q-values for poststates
post_qvalues = self.nnet.predict(poststates)
# take maximum Q-value of all actions
max_qvalues = np.max(post_qvalues, axis=1)
# update the Q-values for the actions we actually performed
# remember delta value for prioritized sweeping
for i, action in enumerate(actions):
qvalues[i][
action] = rewards[i] + self.discount_factor * max_qvalues[i]
train_input = dp.SupervisedInput(prestates.x,
qvalues,
batch_size=self.minibatch_size)
self.trainer.train(net, train_input)
dataset = dp.dataset.MNIST()
x_train, y_train, x_test, y_test = dataset.data(dp_dtypes=True)
# Bring images to BCHW format
x_train = x_train[:, np.newaxis, :, :]
x_test = x_test[:, np.newaxis, :, :]
# Normalize pixel intensities
scaler = dp.StandardScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)
# Prepare network inputs
batch_size = 128
train_input = dp.SupervisedInput(x_train, y_train, batch_size=batch_size)
test_input = dp.Input(x_test)
# Setup network
def pool_layer():
return dp.Pool(
win_shape=(2, 2),
strides=(2, 2),
border_mode='valid',
method='max',
)
def conv_layer(n_filters):
return dp.Convolution(
n_filters=n_filters,
y_train = y_train.astype('int')
# Normalize pixel intensities
scaler = dp.UniformScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)
# Shufflinig
ind = range(len(y_train))
np.random.shuffle(ind)
y_train = y_train[ind]
x_train = x_train[ind, :]
# Prepare autoencoder input
batch_size = 50
train_input = dp.Input(x_train, batch_size=batch_size)
# Setup autoencoders
sae = dp.StackedAutoencoder(layers=[
dp.DenoisingAutoencoder(
n_out=300,
weights=dp.Parameter(dp.AutoFiller()),
activation='sigmoid',
corruption=0.1,
),
dp.DenoisingAutoencoder(
n_out=100,
weights=dp.Parameter(dp.AutoFiller()),
activation='sigmoid',
corruption=0.1,
),
def play_games(self, nr_frames, epoch, train, epsilon=None):
"""
Main cycle: starts a game and plays number of frames.
@param nr_frames: total number of games allowed to play
@param train: true or false, whether to do training or not
@param epsilon: fixed epsilon, only used when not training
"""
frames_played = 0
game_scores = []
first_frame = self.ale.new_game()
if train: self.memory.add_first(first_frame)
if self.current_state == None:
self.current_state = np.empty((1, self.state_length, 84, 84),
dtype=np.float64)
for i in range(self.state_length):
self.current_state[0, i, :, :] = first_frame.copy()
else:
self.current_state.x[0, :-1, :, :] = self.current_state.x[0,
1:, :, :]
self.current_state.x[0, -1, :, :] = first_frame.copy()
game_score = 0
if train and epoch == 1:
self.current_state = dp.Input(self.current_state)
self.current_state.y_shape = (1, self.number_of_actions)
self.nnet._setup(self.current_state)
while frames_played < nr_frames:
if train:
epsilon = self.compute_epsilon(self.total_frames_trained)
if random.uniform(0, 1) < epsilon:
action = random.choice(range(self.number_of_actions))
else:
action = self.predict_action(self.current_state, train)
points, next_frame = self.ale.move(action)
# Changing points to rewards
if points > 0:
print " Got %d points" % points
reward = 1
elif points < 0:
print " Lost %d points" % points
reward = -1
else:
reward = 0
game_score += points
frames_played += 1
self.current_state.x[0, :-1, :, :] = self.current_state.x[0,
1:, :, :]
self.current_state.x[0, -1, :, :] = next_frame
if train:
self.memory.add(action, reward, next_frame)
self.total_frames_trained += 1
minibatch = self.memory.get_minibatch(self.minibatch_size)
self.train_minibatch(minibatch)
if self.ale.game_over:
print " Game over, score = %d" % game_score
# After "game over" increase the number of games played
game_scores.append(game_score)
game_score = 0
# And do stuff after end game
self.ale.end_game()
if train: self.memory.add_last()
first_frame = self.ale.new_game()
if train: self.memory.add_first(first_frame)
self.current_state.x[0, :-1, :, :] = self.current_state.x[
0, 1:, :, :]
self.current_state.x[0, -1, :, :] = first_frame.copy()
self.ale.end_game()
return game_scores
# Fetch CIFAR10 data
dataset = dp.dataset.CIFAR10()
x_train, y_train, x_test, y_test = dataset.data(dp_dtypes=True)
# Normalize pixel intensities
scaler = dp.StandardScaler()
scaler.fit(x_train)
x_train = scaler.transform(x_train)
x_test = scaler.transform(x_test)
# Prepare network inputs
batch_size = 128
train_input = dp.SupervisedInput(x_train, y_train, batch_size=batch_size)
test_input = dp.Input(x_test, batch_size=batch_size)
# Setup network
def conv_layer(n_filters):
return dp.Convolution(
n_filters=32,
filter_shape=(5, 5),
border_mode='full',
weights=dp.Parameter(dp.AutoFiller(gain=1.25), weight_decay=0.003),
)
def pool_layer():
return dp.Pool(
win_shape=(3, 3),
strides=(2, 2),
border_mode='same',
def test_classification():
# Make dataset
n_classes = 2
n_samples = 1000
n_features = 48
x, y = make_classification(
n_samples=n_samples, n_features=n_features, n_classes=n_classes,
n_informative=n_classes*2, random_state=1
)
n_train = int(0.8 * n_samples)
n_val = int(0.5 * (n_samples - n_train))
x_train = x[:n_train]
y_train = y[:n_train]
x_val = x[n_train:n_train+n_val]
y_val = y[n_train:n_train+n_val]
x_test = x[n_train+n_val:]
y_test = y[n_train+n_val:]
scaler = dp.StandardScaler()
x_train = scaler.fit_transform(x_train)
x_val = scaler.transform(x_val)
x_test = scaler.transform(x_test)
# Setup input
batch_size = 16
train_input = dp.SupervisedInput(x_train, y_train, batch_size=batch_size)
val_input = dp.Input(x_val)
test_input = dp.Input(x_test)
# Setup neural network
weight_decay = 1e-03
net = dp.NeuralNetwork(
layers=[
dp.FullyConnected(
n_out=32,
weights=dp.Parameter(dp.AutoFiller(),
weight_decay=weight_decay),
),
dp.Activation('relu'),
dp.FullyConnected(
n_out=64,
weights=dp.Parameter(dp.AutoFiller(),
weight_decay=weight_decay),
),
dp.Activation('relu'),
dp.FullyConnected(
n_out=n_classes,
weights=dp.Parameter(dp.AutoFiller()),
),
],
loss=dp.SoftmaxCrossEntropy(),
)
# Train neural network
def val_error():
return np.mean(net.predict(val_input) != y_val)
trainer = dp.StochasticGradientDescent(
min_epochs=10, learn_rule=dp.Momentum(learn_rate=0.01, momentum=0.9),
)
trainer.train(net, train_input, val_error)
# Evaluate on test data
error = np.mean(net.predict(test_input) != y_test)
print('Test error rate: %.4f' % error)
assert error < 0.2
