def run(self, nb_epoch=10, batch_size=128, verbose=1):
data = self.data
model = self.model
fig = self.fig
history = self.fit(nb_epoch=nb_epoch,
batch_size=batch_size,
verbose=verbose)
score = model.evaluate(data.X_test, data.Y_test, verbose=0)
print('Confusion Matrix')
Y_test_pred = model.predict(data.X_test, verbose=0)
y_test_pred = np.argmax(Y_test_pred, axis=1)
print(metrics.confusion_matrix(data.y_test, y_test_pred))
print('Test Socre: ', score[0])
print('Test Accuracy: ', score[1])
suffix = sfile.unique_filename('datatime')
foldname = 'output_' + suffix
os.makedirs(foldname)
plot.save_history_history('history_history.npy',
history.history,
fold=foldname)
model.save_weights(os.path.join(foldname, 'dl_model.h5'))
print('Output result are save in ', foldname)
if fig:
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plot.plot_acc(history)
plt.subplot(1, 2, 2)
plot.plot_loss(history)
plt.show()
self.history = history
return foldname
def train(num_fold):
isBest = True
data_frame = pd.read_csv(config.TRAIN_FACIAL_LANDMARKS_CSV_PATH,
header=None)
data_frame = preprocess.customFacialLandmarks(data_frame,
config.CLASS_LABEL)
X = data_frame.iloc[:, :-1].copy().values
Y = data_frame.iloc[:, -1].copy().values.reshape(-1, 1)
X_train, X_test, Y_train, Y_test = return_split(X, Y)
model = model_dispatcher.return_model(num_fold)
Y_train_enc, Y_test_enc = conver_to_ohe(Y_train, Y_test)
print(Y_train_enc.shape, Y_test_enc.shape)
mc, reduce_lr = return_callbacks(num_fold, isBest)
opt = return_opt('adam', learning_rate=0.01)
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['accuracy'])
history = model.fit(X_train,
Y_train_enc,
epochs=100,
validation_data=(X_test, Y_test_enc),
batch_size=config.BATCH_SIZE,
callbacks=[mc, reduce_lr])
plot.plot_loss(history)
plot.plot_accuracy(history)
def main():
x_train, y_train, x_test, y_test = data.mnist(one_hot=True)
# Define Deep Neural Network structure (input_dim, num_of_nodes)
layers = [[x_train.shape[1], 256], [256, 128], [128, 64]]
# Initialize a deep neural network
dnn = DNN(MODEL_FOLDER, os_slash, layers, params)
pre_epochs = 100
train_epochs = 100
# Create auto-encoders and train them one by one by stacking them in the DNN
pre_trained_weights = dnn.pre_train(x_train, pre_epochs)
# Then use the pre-trained weights of these layers as initial weight values for the MLP
history = dnn.train(x_train,
y_train,
train_epochs,
init_weights=pre_trained_weights)
plot.plot_loss(history, loss_type='MSE')
predicted, score = dnn.test(x_test, y_test)
print("Test accuracy: ", score[1])
dnn.model.save_weights(MODEL_FOLDER + os_slash + "final_weights.h5")
dnn.model.save(MODEL_FOLDER + os_slash + "model.h5")
save_results(score[1])
def main():
x_train, y_train, x_test, y_test = data.mnist()
params = {
"epochs": 70,
"num_hid_nodes": int(x_train.shape[1] * 0.9),
"weight_init": [0.0, 0.1],
"activations": 'relu', #relu is much better performance
"lr": 0.15,
"decay": 1e-6,
"momentum": 0.1,
}
# noise to training
x_train_noise = np.copy(x_train).astype(float)
level = 0.2
cols = x_train.shape[1]
for row in range(x_train.shape[0]):
noise = np.random.normal(0, np.sqrt(level), cols)
x_train_noise[row, :] = x_train_noise[row, :] + noise
# noise to test
x_test_noise = np.copy(x_test).astype(float)
cols = x_test.shape[1]
for row in range(x_test.shape[0]):
noise = np.random.normal(0, np.sqrt(level), cols)
x_test_noise[row, :] = x_test_noise[row, :] + noise
auto_enc1 = Autoencoder(**params)
history = auto_enc1.train(x_train_noise, x_train, x_test)
plot.plot_loss(history, loss_type='MSE')
x_reconstr = auto_enc1.test(x_test_noise, binary=True)
plot_traintest(x_test_noise, y_test, x_reconstr)
def fine_tune(num_fold, data):
#InceptionResNetV2 - 774:
#Xception - 126
print('Fine-Tuning')
model = None
train_data = None
val_data = None
isBest = True
train_data, val_data = data[num_fold - 1][0], data[num_fold - 1][1]
model = model_dispatcher.return_model(config.MODELS[num_fold - 1])
model = load_model(get_model_name(num_fold))
#LAYERS_TO_TRAIN = some_arbitrary_value
print(model.summary())
for layers in model.layers[1].layers[config.LAYERS_TO_TRAIN[config.
MODELS[num_fold
- 1]]:]:
layers.trainable = True
print(model.summary())
mc, reduce_lr = return_callbacks(num_fold, isBest)
opt = return_opt('adam', learning_rate=1e-5)
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['accuracy'])
history = model.fit(train_data,
validation_data=val_data,
epochs=20,
callbacks=[mc, reduce_lr],
steps_per_epoch=train_data.__len__())
plot.plot_loss(history)
plot.plot_accuracy(history)
def model(features,
labels,
experiment,
lr=0.0001,
batch_size=32,
epochs=500,
verbose=True):
x_train, x_test, y_train, y_test = train_test_split(features,
labels,
test_size=0.20,
stratify=labels,
random_state=SEED)
leaky_relu = tf.keras.layers.LeakyReLU(alpha=0.1)
input_layer = keras.Input(shape=(11, ))
x = layers.Dense(128, activation=leaky_relu)(input_layer)
x = layers.Dense(64, activation=leaky_relu)(x)
x = layers.Dropout(0.2)(x)
x = layers.Dense(64, activation=leaky_relu)(x)
x = layers.Dense(32, activation=leaky_relu)(x)
x = layers.LayerNormalization()(x)
x = layers.Dense(num_classes)(x)
output_layer = layers.Softmax()(x)
model = keras.Model(inputs=input_layer,
outputs=output_layer,
name='spotify_nn')
if verbose:
#keras.utils.plot_model(model, './model_diagram.png', show_shapes=True)
model.summary()
optimizer = tf.keras.optimizers.Adam(learning_rate=lr)
model.compile(optimizer=optimizer,
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=['accuracy'])
history = model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
validation_split=0.2)
plot_acc(history, num_classes, experiment)
plot_loss(history, num_classes, experiment)
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
if verbose:
print('\nTest accuracy: {}'.format(test_acc))
preds = model.predict(x_test)
preds = tf.argmax(preds, axis=-1)
confusion_matrix = tf.math.confusion_matrix(y_test,
preds,
num_classes=num_classes)
plot_cm(confusion_matrix, classes, num_classes, experiment)
def contpred(cfg):
train = cfg.mode == 'train'
# Collect data
if not train:
log.info(f"Collecting new trials")
exper_data = collect_data(cfg)
test_data = collect_data(cfg)
log.info("Saving new default data")
torch.save((exper_data, test_data),
hydra.utils.get_original_cwd() + '/trajectories/reacher/' + 'raw' + cfg.data_dir)
log.info(f"Saved trajectories to {'/trajectories/reacher/' + 'raw' + cfg.data_dir}")
# Load data
else:
log.info(f"Loading default data")
# raise ValueError("Current Saved data old format")
# Todo re-save data
(exper_data, test_data) = torch.load(
hydra.utils.get_original_cwd() + '/trajectories/reacher/' + 'raw' + cfg.data_dir)
if train:
prob = cfg.model.prob
traj = cfg.model.traj
ens = cfg.model.ensemble
delta = cfg.model.delta
log.info(f"Training model P:{prob}, T:{traj}, E:{ens}")
log_hyperparams(cfg)
if cfg.training.num_traj:
train_data = exper_data[:cfg.training.num_traj]
else:
train_data = exper_data
if traj:
dataset = create_dataset_traj(exper_data, control_params=cfg.model.training.control_params,
train_target=cfg.model.training.train_target, threshold=0.95)
else:
dataset = create_dataset_step(train_data, delta=delta)
model = DynamicsModel(cfg)
train_logs, test_logs = model.train(dataset, cfg)
setup_plotting({cfg.model.str: model})
plot_loss(train_logs, test_logs, cfg, save_loc=cfg.env.name + '-' + cfg.model.str, show=False)
log.info("Saving new default models")
f = hydra.utils.get_original_cwd() + '/models/reacher/'
if cfg.exper_dir:
f = f + cfg.exper_dir + '/'
if not os.path.exists(f):
os.mkdir(f)
f = f + cfg.model.str + '.dat'
torch.save(model, f)
def training(x_train, x_test, epochs=1, batch_size=32):
#Loading Data
batches = x_train.shape[0] / batch_size
# Creating GAN
generator = create_generator()
discriminator = create_discriminator()
gan = create_gan(generator, discriminator)
# Adversarial Labels
y_valid = np.ones(batch_size) * 0.9
y_fake = np.zeros(batch_size)
discriminator_loss, generator_loss = [], []
for epoch in range(1, epochs + 1):
print('-' * 15, 'Epoch', epoch, '-' * 15)
g_loss = 0
d_loss = 0
for _ in tqdm(range(int(batches))):
# Random Noise and Images Set
noise = generate_noise(batch_size)
image_batch = x_train[np.random.randint(0,
x_train.shape[0],
size=batch_size)]
# Generate Fake Images
generated_images = generator.predict(noise)
# Train Discriminator (Fake and Real)
discriminator.trainable = True
d_valid_loss = discriminator.train_on_batch(image_batch, y_valid)
d_fake_loss = discriminator.train_on_batch(generated_images,
y_fake)
d_loss += (d_fake_loss + d_valid_loss) / 2
# Train Generator
noise = generate_noise(batch_size)
discriminator.trainable = False
g_loss += gan.train_on_batch(noise, y_valid)
discriminator_loss.append(d_loss / batches)
generator_loss.append(g_loss / batches)
if epoch % PLOT_FRECUENCY == 0:
plot_images(epoch, generator)
plot_loss(epoch, generator_loss, discriminator_loss)
plot_test(epoch, x_test, generator)
generator.save('Save_model/generator.h5')
discriminator.save('Save_model/discriminator.h5')
gan.save('Save_model/gan.h5')
def main():
x_train, y_train, x_test, y_test = data.mnist()
params = {
"epochs": 50,
"num_hid_nodes": int(x_train.shape[1] * 0.9),
"weight_init": [0.0, 0.1],
"activations": 'sigmoid', #relu is much better performance
"lr": 0.15,
"decay": 1e-6,
"momentum": 0.1,
}
auto_enc1 = Autoencoder(**params)
history = auto_enc1.train(x_train, x_train, x_test)
plot.plot_loss(history, loss_type='MSE')
x_reconstr = auto_enc1.test(x_test, binary=True)
plot_traintest(x_test, y_test, x_reconstr)
def train(self, images, epochs, batch_size):
gan = self.__build()
batch_count = int(images.shape[0] / batch_size)
for e in range(1, epochs + 1):
for _ in tqdm(range(batch_count)):
noise = np.random.normal(0,
1,
size=[batch_size, self.random_dim])
image_batch = images[np.random.randint(0,
images.shape[0],
size=batch_size)]
# Generate fake MNIST images
generated_images = self.generator.predict(noise)
# Combine generated generated images and training images
X = np.concatenate([image_batch, generated_images])
# Labels for training and generated images
y_dis = np.zeros(2 * batch_size)
# 0 is fake, 1 is real
# Label smoothing (see: https://github.com/aleju/papers/blob/master/neural-nets/Improved_Techniques_for_Training_GANs.md)
# All images from 0 to batch_size are (caused by concatenation) real
y_dis[:batch_size] = 0.9
y_dis[batch_size:] = 0.1
# Train discriminator
d_loss = self.discriminator.train_on_batch(X, y_dis)
# Train generator
noise = np.random.normal(0,
1,
size=[batch_size, self.random_dim])
y_gen = np.ones(batch_size)
g_loss = gan.train_on_batch(noise, y_gen)
self.discriminator_losses.append(d_loss)
self.generator_losses.append(g_loss)
plot_images(e, self.generator, self.random_dim, self.img_dir)
self.save_models(self.model_path, e)
plot_loss(e, self.discriminator_losses, self.generator_losses,
self.loss_dir)
def main():
batch_size = 128
epoch = 15
data = DATA()
model = LeNet(data.input_shape, data.num_classes)
hist = model.fit(data.x_train,
data.y_train,
batch_size=batch_size,
epochs=epoch,
validation_split=0.2)
score = model.evaluate(data.x_test, data.y_test, batch_size=batch_size)
print()
print('Test Loss= ', score)
plot_loss(hist)
plt.show()
def run_hc_tsne(
Z_init, tree, alpha, margin, config, score_logger, seed=2020, rerun=False
):
Z1_name = f"{Z_dir}/Z1_{seed}.z"
Z1_test_name = f"{Z_dir}/Z1_test_{seed}.z"
loss_name = f"{score_dir}/loss-{name_suffix}.json"
loss_logger = LossLogger(loss_name)
if rerun or not os.path.exists(Z1_name):
print("\n[DEBUG]Run Hierarchical TSNE with ", config["Z_new"])
Z1 = hc_tsne(
X_train,
initialization=Z_init,
tree=tree,
alpha=alpha,
margin=margin,
loss_logger=loss_logger,
random_state=seed,
**config["hc"],
**config["Z_new"],
)
Z1_test = Z1.transform(X_test)
loss_logger.dump()
joblib.dump(np.array(Z1), Z1_name)
joblib.dump(np.array(Z1_test), Z1_test_name)
else:
Z1 = joblib.load(Z1_name)
Z1_test = joblib.load(Z1_test_name)
fig_name = f"{plot_dir}/HC-{name_suffix}.png"
scatter(Z1, None, y_train, None, tree=tree, out_name=fig_name)
loss_logger.load(loss_name)
plot_loss(loss_logger.loss, out_name=f"{plot_dir}/loss-{name_suffix}.png")
if score_logger is not None:
evaluate_scores(
X_train, y_train, X_test, y_test, Z1, Z1_test, "hc-tsne", score_logger
)
def run(self, epochs=400):
d = self.data
X_train, X_test = d.X_train, d.X_test
y_train, y_test = d.y_train, d.y_test
X, y = d.X, d.y
m = self.model
h = m.fit(X_train, y_train, epochs=epochs, validation_data=[X_test, y_test], verbose=2)
plot.plot_loss(h)
plt.title('History of training')
plt.show()
yp = m.predict(X_test)
print('Loss : ', m.evaluate(X_test, y_test))
plt.plot(yp, label='Prediction')
plt.plot(y_test, label='Original')
plt.legend(loc=0)
plt.title('Validation Results')
plt.show()
yp = m.predict(X_test).reshape(-1)
print('Loss : ',m.evaluate(X_test, y_test))
print(yp.shape, y_test.shape)
df = pd.DataFrame()
df['Sample'] = list(range(len(y_test))) * 2
df['Normalized #Passengers'] = np.concatenate([y_test, yp], axis=0)
df['Type'] = ['Original'] * len(y_test) + ['Prediction'] * len(yp)
plt.figure(figsize=(7,5))
sns.barplot(x='Sample', y='Normalized #Passengers', hue='Type', data=df)
plt.ylabel('Normalized #Passengers')
plt.show()
yp = m.predict(X)
plt.plot(yp, label='Prediction')
plt.plot(y, label='Original')
plt.legend(loc=0)
plt.title('All Results')
plt.show()
def train_net(model, loss, config, inputs, labels, batch_size, disp_freq):
iter_counter = 0
loss_list = []
acc_list = []
for input, label in data_iterator(inputs, labels, batch_size):
target = onehot_encoding(label, 10)
iter_counter += 1
# forward net
output = model.forward(input)
# calculate loss
loss_value = loss.forward(output, target)
# generate gradient w.r.t loss
grad = loss.backward(output, target)
# backward gradient
model.backward(grad)
# update layers' weights
model.update(config)
acc_value = calculate_acc(output, label)
loss_list.append(loss_value)
acc_list.append(acc_value)
if iter_counter % disp_freq == 0:
total_loss = np.mean(loss_list)
total_acc = np.mean(acc_list)
plot_loss(total_loss, total_acc)
msg = ' Training iter %d, batch loss %.4f, batch acc %.4f' % (
iter_counter, total_loss, total_acc)
loss_list = []
acc_list = []
LOG_INFO(msg)
model.add(layers.Dense(46, activation='softmax'))
# 验证
x_val = x_train[:1000]
partial_x_train = x_train[1000:]
# y_val = one_hot_train_labels[:1000]
# partial_y_train = one_hot_train_labels[1000:]
# model.compile(optimizer='rmsprop',
# loss='categorical_crossentropy',
# metrics=['accuracy'])
partial_y_train = train_labels[1000:]
y_val = train_labels[:1000]
model.compile(optimizer='rmsprop', loss='sparse_categorical_crossentropy', metrics=['acc'])
print(model.summary())
history = model.fit(partial_x_train,
partial_y_train,
epochs=20,
batch_size=512,
validation_data=(x_val, y_val))
import plot
plot.plot_accuracy(history)
plot.plot_loss(history)
save_best_only=True)
earlystopper = keras.callbacks.EarlyStopping(monitor='val_loss',
patience=10,
verbose=0)
GRU6_json = GRU6.to_json()
with open("GRU6.json", "w") as jason_file:
jason_file.write(GRU6_json)
time_callback = TimeHistory()
GRU6_history = GRU6.fit_generator(
train,
epochs=100,
validation_data=valid,
verbose=0,
callbacks=[checkpointer, earlystopper, time_callback])
plot_loss(GRU6_history, 'GRU6 - Train & Validation Loss')
print('time for 10 epochs in seconds:', total_time(10, time_callback.times))
prediction = GRU6.predict_generator(test)
pr_y = np.zeros((1, len(prediction)))
t_y = np.zeros((1, len(test)))
for num in range(len(prediction)):
pr_y[:, num] = prediction[num][0]
t_y[:, num] = (test[num][1])[0][0]
plt.plot(t_y, pr_y, 'ro')
plt.xlabel('True Values')
plt.ylabel('Predictions')
plt.axis('equal')
plt.show()
print('reward:', rewards_c.shape)
# print(len(rewards))
reward_batch = np.sum(rewards)
with critic_sess.as_default():
with critic_sess.graph.as_default():
# critic_sess.run(tf.global_variables_initializer())
baselines, _, loss_, m = critic_sess.run(
[training_logits_, train_op_, l_, masks_], {
input_data_: target_batch,
targets_: translate_logits,
rewards_: rewards_c,
lr_: learning_rate,
target_sequence_length_: lens,
source_sequence_length_: targets_lengths,
keep_prob_: keep_probability
})
# print(m)
print('baseline:', baselines)
print(baselines.shape)
print('critic loss:', loss_)
# print(baselines.shape)
loss_list.append((count, loss_))
saver.save(critic_sess, save_path_critic)
print('Model Trained and Saved')
util.save_params(save_path_critic, 'params_critic_sup.p')
plot_loss(loss_list)
def train():
print('Starting Training')
data_frame = pd.read_csv(config.TRAIN_CSV_PATH)
Y = data_frame[['Label']].copy()
num_fold = 1
data = dict()
isBest = False
for train_idx, val_idx in return_split(Y):
if (num_fold in config.LIST_OF_FOLD_EXCEPTIONS):
import train_facialLandmarks
train_facialLandmarks.train(num_fold)
else:
train_df = data_frame.iloc[train_idx]
val_df = data_frame.iloc[val_idx]
train_datagen, val_datagen = return_gen(num_fold)
train_data = train_datagen.flow_from_dataframe(
dataframe=train_df,
directory=None,
x_col="Image",
y_col="Label",
target_size=(config.TARGET_SIZE[config.MODELS[num_fold -
1]][0],
config.TARGET_SIZE[config.MODELS[num_fold -
1]][1]),
class_mode="categorical",
shuffle=True,
batch_size=config.BATCH_SIZE,
seed=42)
val_data = val_datagen.flow_from_dataframe(
dataframe=val_df,
directory=None,
x_col="Image",
y_col="Label",
target_size=(config.TARGET_SIZE[config.MODELS[num_fold -
1]][0],
config.TARGET_SIZE[config.MODELS[num_fold -
1]][1]),
class_mode="categorical",
shuffle=True,
batch_size=config.BATCH_SIZE,
seed=42)
print(train_data.class_indices)
model = model_dispatcher.return_model(num_fold)
mc, reduce_lr = return_callbacks(num_fold, isBest)
opt = return_opt('adam', learning_rate=0.01)
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['accuracy'])
history = model.fit(train_data,
validation_data=val_data,
epochs=1,
callbacks=[mc, reduce_lr],
steps_per_epoch=train_data.__len__())
plot.plot_loss(history)
plot.plot_accuracy(history)
model = load_model(get_model_name(num_fold, isBest))
results = model.evaluate(val_data)
results = dict(zip(model.metrics_name, results))
data[num_fold] = [train_data, val_data]
num_fold += 1
tf.keras.backend.clear_session()
if (num_fold > len(config.MODELS)):
break
return data
import numpy as np import dataset as ds from neural_networks import NeuralNetwork from layers import InputLayer, OutputLayer, DenseLayer from functions._init_functions import init_functions from functions._activation_functions import activation_functions, activation_functions_derivatives from functions._loss_functions import loss_functions import plot as plt data = ds.MLCupDataset() data = ds.MLCupDataset() model = NeuralNetwork() model.add(InputLayer(10)) model.add(DenseLayer(50, fanin=10, activation="sigmoid")) model.add(DenseLayer(30, fanin=50, activation="sigmoid")) model.add(OutputLayer(2, fanin=30)) # configuration 322, line 324 model.compile(1143, 600, 0.03, None, 0.000008, 0.3, "mean_squared_error") loss = model.fit(data.train_data_patterns, data.train_data_targets) print(loss[-1]) plt.plot_loss(loss)
def training(epochs=1, batch_size=32):
#Loading Data
#x_train = load_imgs("./data256/*png")
# Rescale -1 to 1
#x_train = x_train / 127.5 - 1.
train_datagen = ImageDataGenerator()
train_generator = train_datagen.flow_from_directory('imgs/',
batch_size=batch_size,
shuffle=True)
batches = 12385. / batch_size
# Creating GAN
generator = create_generator()
discriminator = create_discriminator()
gan = create_gan(generator, discriminator)
# Adversarial Labels
y_valid = np.ones(batch_size) * 0.9
y_fake = np.zeros(batch_size)
discriminator_loss, generator_loss = [], []
for epoch in range(1, epochs + 1):
print('-' * 15, 'Epoch', epoch, '-' * 15)
g_loss = 0
d_loss = 0
for _ in tqdm(range(int(batches - 1))):
# Random Noise and Images Set
noise = generate_noise(batch_size)
image_batch, _ = train_generator.next()
image_batch = image_batch / 127.5 - 1.
if image_batch.shape[0] == batch_size:
# Generate Fake Images
generated_images = generator.predict(noise)
# Train Discriminator (Fake and Real)
discriminator.trainable = True
d_valid_loss = discriminator.train_on_batch(
image_batch, y_valid)
d_fake_loss = discriminator.train_on_batch(
generated_images, y_fake)
d_loss += (d_fake_loss + d_valid_loss) / 2
# Train Generator
noise = generate_noise(batch_size)
discriminator.trainable = False
g_loss += gan.train_on_batch(noise, y_valid)
train_generator.on_epoch_end()
discriminator_loss.append(d_loss / batches)
generator_loss.append(g_loss / batches)
if epoch % PLOT_FRECUENCY == 0:
plot_images(epoch, generator)
plot_loss(epoch, generator_loss, discriminator_loss)
save_path = "./models"
if not os.path.exists(save_path):
os.makedirs(save_path)
discriminator.save(save_path + "/discrim_%s.h5" % epoch)
generator.save(save_path + "/generat_%s.h5" % epoch)
gan.save(save_path + "/gan_%s.h5" % epoch)
save_images(generator)
#Forward Propagation
out, net_in, net_in_bias = forwardprop.forward(num_layers,
out[0].shape[0],
net_in_bias, out,
net_in, theta)
#Backpropagation
error, dtheta, theta = backprop.back(num_layers, out[0].shape[0],
error, out, hidden, net_in_bias,
theta, dtheta, alpha, temp_Y)
out, _, _, _, _, _, _ = initialize.init(X, num_layers, hidden, num_batches)
out, _, _ = forwardprop.forward(num_layers, num_trainset, net_in_bias, out,
net_in, theta)
loss[epoch] = performance_metrics.loss(Y, out[num_layers - 1], Y.shape[0])
#plot.plot_boundary(X, Y_nb, out, num_layers, net_in_bias, net_in, theta, epoch, Z, xx, yy)
out, _, _, _, _, _, _ = initialize.init(X, num_layers, hidden, num_batches)
out, _, _ = forwardprop.forward(num_layers, num_trainset, net_in_bias, out,
net_in, theta)
print performance_metrics.confusion_matrix(Y, out[num_layers - 1], num_class)
print "Accuracy: " + str(performance_metrics.accuracy(Y, out[num_layers - 1]))
print "Precision: " + str(
performance_metrics.precision(Y, out[num_layers - 1], num_class))
print "Recall: " + str(
performance_metrics.recall(Y, out[num_layers - 1], num_class))
print "Error: " + str(performance_metrics.sum_error(error, num_layers))
#plot.plot_boundary(X, Y_nb, out, num_layers, net_in_bias, net_in, theta, 0)
plot.plot_loss(np.arange(num_epochs), loss)
from sys import argv
import numpy as np
#iner
from neuron import generate_network, get_neighborhood, get_route
from plot import plot_neuron_chain, plot_route, plot_loss
from opts import OPT
from dataloader import dataloader
import pandas as pd
from path import Path
from som import SOM
import matplotlib.pyplot as plt
def main():
pass
if __name__ == '__main__':
args = OPT().args()
SOM(args)
plot_loss(input_dir=args.out_dir)
plot_route(input_dir=args.out_dir)
plot_neuron_chain(input_dir=args.out_dir)
model = models.Sequential()
model.add(layers.Dense(64, activation='relu', input_shape=(10000, )))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(46, activation='softmax'))
# 验证
x_val = x_train[:1000]
partial_x_train = x_train[1000:]
# y_val = one_hot_train_labels[:1000]
# partial_y_train = one_hot_train_labels[1000:]
# model.compile(optimizer='rmsprop',
# loss='categorical_crossentropy',
# metrics=['accuracy'])
partial_y_train = train_labels[1000:]
y_val = train_labels[:1000]
model.compile(optimizer='rmsprop',
loss='sparse_categorical_crossentropy',
metrics=['acc'])
print(model.summary())
history = model.fit(partial_x_train,
partial_y_train,
epochs=20,
batch_size=512,
validation_data=(x_val, y_val))
import plot
plot.plot_accuracy(history)
plot.plot_loss(history)
rewards_all /= 10
print('Epoch {:>3} Batch {:>4}/{} - Actor Loss: {:>6.4f} - Critic Loss: {:>6.4f} - Train Reward: {:>6.4f} - Valid Reward: {:>6.4f}'
.format(epoch_i, batch_i, len(source_int_text) // batch_size, loss_actor, loss_critic, reward_batch, rewards_all))
loss_list.append((count, loss_actor))
loss_list_critic.append((count, loss_critic))
reward_list.append((count, reward_batch))
reward_valid_list.append((count, rewards_all))
with train_sess.as_default():
with train_sess.graph.as_default():
# Save Model
saver_actor = tf.train.Saver()
saver_actor.save(train_sess, save_path)
with critic_sess.as_default():
with critic_sess.graph.as_default():
# Save Model
saver_critic = tf.train.Saver()
saver_critic.save(critic_sess, save_path_critic)
# plot
plot_loss(loss_list, "actor loss", "img/actor_loss.jpg")
plot_loss(loss_list_critic, "critic loss", "img/critic_loss.jpg")
plot_loss(reward_valid_list, "training reward", "img/training_reward.jpg")
#save model
util.save_params(save_path, 'params_actor_reinforce.p')
util.save_params(save_path_critic, 'params_critic_sup.p')
if batch_i % display_step == 0 and batch_i > 0:
rewards_all = 0
for batch_j, (valid_sources_batch, valid_targets_batch, valid_sources_lengths, valid_targets_lengths) in enumerate(
util.get_batches(valid_source, valid_target, batch_size,
source_vocab_to_int['<PAD>'],
target_vocab_to_int['<PAD>'])):
batch_valid_logits = sess.run(
inferencing_logits,
{input_data: valid_sources_batch,
source_sequence_length: valid_sources_lengths,
target_sequence_length: valid_targets_lengths,
keep_prob: 1.0})
rewards_v, pre_logits = util.get_bleu(valid_targets_batch, batch_valid_logits)
rewards_v = np.sum(rewards_v) / batch_size
rewards_all += rewards_v
rewards_all /= 10
print('Epoch {:>3} Batch {:>4}/{} - Loss: {:>6.4f} - Valid bleu: {:>6.4f}'
.format(epoch_i, batch_i, len(source_int_text) // batch_size, loss, rewards_all))
# Save Model
saver = tf.train.Saver()
saver.save(sess, save_path)
print('Model Trained and Saved')
plot_loss(loss_list, "pretrain loss", "img/pretrain_loss.jpg")
# Save parameters for checkpoint# Save p
util.save_params(save_path, 'params_actor_sup.p')
def lorenz(cfg):
# Lorenz paramters and initial conditions
sigma, beta, rho = cfg.lorenz.sigma, cfg.lorenz.beta, cfg.lorenz.rho
u0, v0, w0 = cfg.lorenz.ex.u0, cfg.lorenz.ex.v0, cfg.lorenz.ex.w0
# Maximum time point and total number of time points
tmax, n = cfg.lorenz.tmax, cfg.lorenz.n
# Integrate the Lorenz equations on the time grid t
t = np.linspace(0, tmax, n)
f = odeint(sim_lorenz, (u0, v0, w0), t, args=(sigma, beta, rho))
x, y, z = f.T
num_traj = cfg.lorenz.num_traj
if cfg.collect_data:
data_X = np.zeros((1, 3))
data_Seq = []
new_init = np.random.uniform(low=[-25, -25, -25],
high=[25, 25, 25],
size=(num_traj, 3))
for row in new_init:
u, v, w = row # row[0], row[1], row[2]
f = odeint(sim_lorenz, (u, v, w), t, args=(sigma, beta, rho))
x, y, z = f.T
l = DotMap()
l.states = f
# Add parameters the way that the generation object is
# TODO take generic parameters rather than only PD Target
l.P = cfg.lorenz.beta
l.D = cfg.lorenz.rho
l.target = cfg.lorenz.sigma
data_Seq.append(l)
if cfg.plot: plot_lorenz(data_Seq, cfg, predictions=None)
if cfg.save_data:
log.info("Saving new default data")
torch.save((data_Seq),
hydra.utils.get_original_cwd() +
'/trajectories/lorenz/' + 'raw' + cfg.data_dir)
log.info(f"Saved trajectories to {cfg.data_dir}")
else:
data_Seq = torch.load(hydra.utils.get_original_cwd() +
'/trajectories/lorenz/' + 'raw' + cfg.data_dir)
# Analysis
from dynamics_model import DynamicsModel
from reacher_pd import create_dataset_step, create_dataset_traj
from plot import plot_loss
prob = cfg.model.prob
traj = cfg.model.traj
ens = cfg.model.ensemble
if traj:
dataset = create_dataset_traj(data_Seq, threshold=0.95)
else:
dataset = create_dataset_step(data_Seq)
if cfg.train_models:
model = DynamicsModel(cfg)
train_logs, test_logs = model.train(dataset, cfg)
plot_loss(train_logs,
test_logs,
cfg,
save_loc=cfg.env.name + '-' + cfg.model.str,
show=True)
if cfg.save_models:
log.info("Saving new default models")
torch.save(
model,
hydra.utils.get_original_cwd() + '/models/lorenz/' +
cfg.model.str + '.dat')
models = {}
for model_type in cfg.models_to_eval:
models[model_type] = torch.load(hydra.utils.get_original_cwd() +
'/models/lorenz/' + model_type +
".dat")
mse_evald = []
for i in range(cfg.num_eval):
traj_idx = np.random.randint(num_traj)
traj = data_Seq[traj_idx]
MSEs, predictions = test_models([traj], models)
MSE_avg = {key: np.average(MSEs[key], axis=0) for key in MSEs}
mse = {key: MSEs[key].squeeze() for key in MSEs}
mse_sub = {key: mse[key][mse[key] < 10**5] for key in mse}
pred = {key: predictions[key] for key in predictions}
mse_evald.append(mse)
#
# plot_states(traj.states, pred, save_loc="Predictions; traj-" + str(traj_idx), idx_plot=[0,1,2], show=False)
# plot_mse(mse_sub, save_loc="Error; traj-" + str(traj_idx), show=False)
plot_lorenz([traj], cfg, predictions=pred)
plot_mse_err(mse_evald, save_loc="Err Bar MSE of Predictions", show=True)
def noise_experiment(args, test_size=0.3):
du = DataUtils(args.name)
pos, neg, bk, clauses, lang = du.load_data()
pos_train, pos_test = train_test_split(pos,
test_size=test_size,
random_state=seed)
neg_train, neg_test = train_test_split(neg,
test_size=test_size,
random_state=seed)
noise_rates = [
0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.30, 0.35, 0.40, 0.45, 0.50
]
baseline_auc = [1.0, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]
datasets = get_datasets_with_noise(pos_train, neg_train, noise_rates)
AUCs = []
AUC_stds = []
MSEs = []
MSE_stds = []
N = 5 # how many times to perform weight learn
if args.name == 'member':
T_beam = 3
N_beam = 3
elif args.name == 'subtree':
T_beam = 3
N_beam = 15
else:
T_beam = 5
N_beam = 10
N_max = 50
for i, (pos_train, neg_train) in enumerate(datasets):
ilp_train = ILPProblem(pos_train, neg_train, bk, lang, name=args.name)
print('NOISE RATE: ', noise_rates[i])
ilp_train.print()
CG = ClauseGenerator(ilp_train,
infer_step=args.T,
max_depth=1,
max_body_len=1)
solver = ILPSolver(ilp_train,
C_0=clauses,
CG=CG,
m=args.m,
infer_step=args.T)
clauses_, Ws_list, loss_list_list = solver.train_N(N=N,
gen_mode='beam',
N_max=N_max,
T_beam=T_beam,
N_beam=N_beam,
epoch=args.epoch,
lr=args.lr,
wd=0.0)
v_list, facts = solver.predict_N(pos_test, neg_test, clauses_, Ws_list)
auc_list = np.array(
[compute_auc(pos_test, neg_test, v_, facts) for v_ in v_list])
auc_mean = np.mean(auc_list)
auc_std = np.std(auc_list)
AUCs.append(auc_mean)
AUC_stds.append(auc_std)
mse_list = np.array(
[compute_mse(pos_test, neg_test, v_, facts) for v_ in v_list])
mse_mean = np.mean(mse_list)
mse_std = np.std(mse_list)
MSEs.append(mse_mean)
MSE_stds.append(mse_std)
for j in range(N):
loss_path = 'imgs/noise/loss/' + args.name + \
'[noise:' + str(noise_rates[i]) + ']-' + str(j) + '.pdf'
plot_loss(
loss_path, loss_list_list[j],
args.name + ':[noise:' + str(noise_rates[i]) + ']-' + str(j))
# plot AUC with baseline
path_auc = 'imgs/noise/' + args.name + '_AUC.pdf'
path_mse = 'imgs/noise/' + args.name + '_MSE.pdf'
print(AUC_stds)
print(MSE_stds)
plot_line_graph_baseline_err(
path=path_auc,
xs=noise_rates,
ys=AUCs,
err=AUC_stds,
xlabel='Proportion of mislabeled training data',
ylabel='AUC',
title=args.name,
baseline=baseline_auc)
# plot MSR with std
plot_line_graph_err(path=path_mse,
xs=noise_rates,
ys=MSEs,
err=MSE_stds,
xlabel='Proportion of mislabeled training data',
ylabel='Mean-squared test error',
title=args.name)
def main():
args = get_args()
global m
print("Using "+args.arch_file+" DNN architecture")
m = __import__(args.arch_file)
print("Using GPU", args.gpu_id)
torch.cuda.set_device(args.gpu_id)
tmp = torch.ByteTensor([0])
tmp.cuda()
int_model_dir = args.dirout+'/intermediate_models/'
plot_dir = args.dirout+'/train_stats/plots/'
loss_file = args.dirout+'/train_stats/train_loss.txt'
cv_loss_file = args.dirout+'/train_stats/cv_loss.txt'
print("loading datset")
dataset = m.TrainSet(args.data_dir, args.train_copy_location)
dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, collate_fn=dataset.collator, num_workers=1)
if args.cv_data_dir:
cv_dataset = m.TrainSet(args.cv_data_dir)
cv_dataloader = DataLoader(cv_dataset, batch_size=args.batch_size, collate_fn=cv_dataset.collator)
print("initializing model")
if args.model_config:
kwargs = dict()
for line in open(args.model_config):
kwargs[line.split('=')[0]] = line.rstrip().split('=')[1]
model = m.SepDNN(args.gpu_id, **kwargs)
else:
model = m.SepDNN(args.gpu_id)
model.cuda()
optimizer = optim.Adam(model.parameters(), lr=args.learning_rate)
print("using lr="+str(args.learning_rate))
epoch_losses = [[], []]
epoch_cv_losses = [[], []]
lossF = open(loss_file, 'a')
if args.cv_data_dir:
cv_lossF = open(cv_loss_file, 'a')
if args.start_epoch == 0:
torch.save(model.state_dict(), int_model_dir+'init.mdl')
else:
model.load_state_dict(torch.load(int_model_dir+str(args.start_epoch).zfill(3)+'.mdl', map_location=lambda storage, loc: storage.cuda()))
load_losses(loss_file, epoch_losses)
if args.cv_data_dir:
load_losses(cv_loss_file, epoch_cv_losses)
print("training")
for epoch in range(args.start_epoch, args.num_epochs):
epoch_loss = 0.0
epoch_norm = 0
for i_batch, sample_batch in enumerate(dataloader):
loss, norm = m.compute_loss(model, epoch, sample_batch)
epoch_loss += loss.detach().cpu().numpy() * norm.detach().cpu().numpy()
epoch_norm += norm.detach().cpu().numpy()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 0.25)
optimizer.step()
if args.cv_data_dir and epoch % 5 == 4:
cv_epoch_loss = 0.0
cv_epoch_norm = 0
model.eval()
with torch.no_grad():
for i_batch_cv, sample_batch_cv in enumerate(cv_dataloader):
if i_batch_cv == 0:
cv_loss, cv_norm = m.compute_cv_loss(model, epoch, sample_batch_cv, plot_dir+'epoch'+str(epoch+1).zfill(3))
else:
cv_loss, cv_norm = m.compute_cv_loss(model, epoch, sample_batch_cv)
cv_epoch_loss += cv_loss.detach().cpu().numpy() * cv_norm.detach().cpu().numpy()
cv_epoch_norm += cv_norm.detach().cpu().numpy()
model.train()
print("For epoch: "+str(epoch+1).zfill(3)+" cv set loss is: "+str(cv_epoch_loss/cv_epoch_norm))
cv_lossF.write(str(epoch+1).zfill(3)+' '+str(cv_epoch_loss/cv_epoch_norm)+'\n')
cv_lossF.flush()
epoch_cv_losses[0].append(epoch+1)
epoch_cv_losses[1].append(cv_epoch_loss/cv_epoch_norm)
print("For epoch: "+str(epoch+1).zfill(3)+" loss is: "+str(epoch_loss/epoch_norm))
lossF.write(str(epoch+1).zfill(3)+' '+str(epoch_loss/epoch_norm)+'\n')
lossF.flush()
epoch_losses[0].append(epoch+1)
epoch_losses[1].append(epoch_loss/epoch_norm)
if epoch % 5 == 4:
print("Saving model for epoch "+str(epoch+1).zfill(3))
torch.save(model.state_dict(), int_model_dir+str(epoch+1).zfill(3)+'.mdl')
os.system("mkdir -p "+plot_dir+'epoch'+str(epoch+1).zfill(3))
plot.plot_loss(epoch_losses, epoch_cv_losses, plot_dir+'epoch'+str(epoch+1).zfill(3)+'/Loss_'+str(epoch_losses[0][0]).zfill(3)+'-'+str(epoch+1).zfill(3)+'.png')
sys.stdout.flush()
torch.save(model.state_dict(), args.dirout+'/final.mdl')
plot.plot_loss(epoch_losses, epoch_cv_losses, plot_dir+'Loss_'+str(epoch_losses[0][0]).zfill(3)+'-'+str(args.num_epochs).zfill(3)+'.png')
# print some metrics
train_samples_size = len(train_loader) * BATCH_SIZE
valid_samples_size = len(valid_loader) * BATCH_SIZE
loss_train_epoch = loss_train / train_samples_size
loss_valid_epoch = loss_valid / valid_samples_size
error_train_epoch = 100 - 100 * (acc_train / train_samples_size)
error_valid_epoch = 100 - 100 * (acc_valid / valid_samples_size)
error_history.append((error_train_epoch, error_valid_epoch))
loss_history.append((loss_train_epoch, loss_valid_epoch))
print(
'Epoch: {} train loss: {:.5f} valid loss: {:.5f} train error: {:.2f} % valid error: {:.2f} %'
.format(epoch, loss_train_epoch, loss_valid_epoch, error_train_epoch,
error_valid_epoch))
# check if model is better
if error_valid_epoch < best_error[1]:
best_error = (epoch, error_valid_epoch)
snapshot(SAVED_MODELS_DIR, RUN_TIME, RUN_NAME, True, epoch,
error_valid_epoch, model.state_dict(),
model.optimizer.state_dict())
# check that the model is not doing worst over the time
if best_error[0] + PATIENCE < epoch:
print('Overfitting. Stopped at epoch {}.'.format(epoch))
break
epoch += 1
plot_loss(RUN_TIME, RUN_NAME, loss_history)
plot_error(RUN_TIME, RUN_NAME, error_history)
