def _build_net():
model = keras.Sequential()
# model.add(keras.Input(shape=(3,224,224)))
# group 1 224>112
model.add(
keras.layers.Conv2D(filters=64,
kernel_size=[3, 3],
strides=(1, 1),
padding="same",
data_format='channels_first',
name='conv1_1',
input_shape=(3, 224, 224)))
model.add(keras.layers.ReLU(name='relu1_1'))
model.add(
keras.layers.Conv2D(filters=64,
kernel_size=[3, 3],
strides=(1, 1),
padding="same",
data_format='channels_first',
name='conv1_2'))
model.add(keras.layers.ReLU(name='relu1_2'))
model.add(
keras.layers.MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
name='pool1',
data_format='channels_first'))
# group 2 112>56
model.add(
keras.layers.Conv2D(filters=128,
kernel_size=[3, 3],
strides=(1, 1),
padding="same",
data_format='channels_first',
name='conv2_1'))
model.add(keras.layers.ReLU(name='relu2_1'))
model.add(
keras.layers.Conv2D(filters=128,
kernel_size=[3, 3],
strides=(1, 1),
padding="same",
data_format='channels_first',
name='conv2_2'))
model.add(keras.layers.ReLU(name='relu2_2'))
model.add(
keras.layers.MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
name='pool2',
data_format='channels_first'))
# group 3 56>28
model.add(
keras.layers.Conv2D(filters=256,
kernel_size=[3, 3],
strides=(1, 1),
padding="same",
data_format='channels_first',
name='conv3_1'))
model.add(keras.layers.ReLU(name='relu3_1'))
model.add(
keras.layers.Conv2D(filters=256,
kernel_size=[3, 3],
strides=(1, 1),
padding="same",
data_format='channels_first',
name='conv3_2'))
model.add(keras.layers.ReLU(name='relu3_2'))
model.add(
keras.layers.Conv2D(filters=256,
kernel_size=[3, 3],
strides=(1, 1),
padding="same",
data_format='channels_first',
name='conv3_3'))
model.add(keras.layers.ReLU(name='relu3_3'))
model.add(
keras.layers.MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
name='pool3',
data_format='channels_first'))
# group 4 28>14
model.add(
keras.layers.Conv2D(filters=512,
kernel_size=[3, 3],
strides=(1, 1),
padding="same",
data_format='channels_first',
name='conv4_1'))
model.add(keras.layers.ReLU(name='relu4_1'))
model.add(
keras.layers.Conv2D(filters=512,
kernel_size=[3, 3],
strides=(1, 1),
padding="same",
data_format='channels_first',
name='conv4_2'))
model.add(keras.layers.ReLU(name='relu4_2'))
model.add(
keras.layers.Conv2D(filters=512,
kernel_size=[3, 3],
strides=(1, 1),
padding="same",
data_format='channels_first',
name='conv4_3'))
model.add(keras.layers.ReLU(name='relu4_3'))
model.add(
keras.layers.MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
name='pool4',
data_format='channels_first'))
# group 5 14>7
model.add(
keras.layers.Conv2D(filters=512,
kernel_size=[3, 3],
strides=(1, 1),
padding="same",
data_format='channels_first',
name='conv5_1'))
model.add(keras.layers.ReLU(name='relu5_1'))
model.add(
keras.layers.Conv2D(filters=512,
kernel_size=[3, 3],
strides=(1, 1),
padding="same",
data_format='channels_first',
name='conv5_2'))
model.add(keras.layers.ReLU(name='relu5_2'))
model.add(
keras.layers.Conv2D(filters=512,
kernel_size=[3, 3],
strides=(1, 1),
padding="same",
data_format='channels_first',
name='conv5_3'))
model.add(keras.layers.ReLU(name='relu5_3'))
model.add(
keras.layers.MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
name='pool5',
data_format='channels_first'))
# fc6
model.add(keras.layers.Flatten(data_format='channels_last', name='f6'))
# here i assume both caffe flatten the tensor using row major oder
# see https://en.wikipedia.org/wiki/Row-_and_column-major_order
#
# in other word, using the indices of the last axis as the indicator, the flattened sequence is
#
# 0,1,2,...,n,0,1,2,...,n
#
# NOT
#
# 0,0,0,...,0,1,1,1,...,n
#
# the test run of this model seems confirmed this assumption
model.add(keras.layers.Dense(4096, name='fc6'))
model.add(keras.layers.ReLU(name='relu6'))
model.add(keras.layers.Dropout(0.5, name='drop6'))
model.add(keras.layers.Dense(4096, name='fc7'))
model.add(keras.layers.ReLU(name='relu7'))
model.add(keras.layers.Dropout(0.5, name='drop7'))
model.add(keras.layers.Dense(365, name='fc8a'))
model.add(keras.layers.Softmax(axis=-1, name='prob'))
return model
from __future__ import print_function
import keras
import tensorflow as tf
import numpy as np
import json
tmpx = json.load(open('x1.json', 'r'))
tmpy = json.load(open('y1.json', 'r'))
x = np.array(tmpx)
y = np.array(tmpy)
model = keras.Sequential([
keras.layers.Dense(8000, input_shape=(5180, )),
keras.layers.Dense(7000),
keras.layers.Dense(5180, activation='softmax')
])
model.compile(loss="binary_crossentropy",
optimizer="Adam",
metrics=['accuracy'])
model.fit(x, y, batch_size=64, epochs=5)
jsonstr = model.to_json()
open("model2.json", 'w').write(jsonstr)
model.save_weights('weight2.h5')
nb_frames=10,
batch_size=4,
input_shape=(224, 224),
data_augmentation=image_aug)
val_generator = MotionFlowDataGenerator(
path=r'/home/coala/mestrado/datasets/UCF101/',
split='val',
nb_frames=10,
batch_size=4,
input_shape=(224, 224)
# data_augmentation=image_aug
)
# test model
model = keras.Sequential()
model.add(
keras.applications.VGG16(include_top=False,
input_shape=(224, 224, 20),
weights=None))
td = keras.layers.TimeDistributed(input_shape=(5, 224, 224, 20),
layer=model)
model = keras.Sequential()
model.add(td)
# model.add(keras.layers.Conv3D(filters=256, kernel_size=(2, 2, 2), strides=2))
model.add(keras.layers.MaxPool3D())
model.add(keras.layers.Flatten())
model.add(keras.layers.Dropout(.5))
model.add(keras.layers.Dense(4096, activation='relu', name='fc1'))
model.add(keras.layers.Dropout(.5))
model.add(keras.layers.Dense(4096, activation='relu', name='fc2'))
#plt.imshow(train_images[1])
#plt.colorbar()
#plt.grid(False)
#plt.show()
#Data preprocessing - this squishes all data between 0 and 1, want data as small as possible so nueral network works faster
train_images = train_images / 255.0
test_images = test_images / 255.0 #if you forget to reprocess test images model wont fit so do both
model = keras.Sequential(
[ #sequantial is basic, info passes from left to right sequencially
keras.layers.Flatten(
input_shape=(28, 28)
), # input layer (1), flatten allows us to take in 28 by 28 shape and flatten it into pixels
keras.layers.Dense(
128, activation='relu'
), # hidden layer (2), dense means neurons in previouse layer are connected to all in this one relu -rectify linear unit (lots of different ones)
keras.layers.Dense(
10, activation='softmax'
) # output layer (3), 10 because only 10 classes, softmax makes sure all values of neurons add to 1 and are between 0 and 1
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(
train_images, train_labels, epochs=2
) # we pass the data, labels and epochs and watch the magic! Less epochs is usually better to not overtune to the training data
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=1)
sp = f.add_subplot(rows, cols, i+1)
sp.axis('Off')
if titles is not None:
sp.set_title(titles[i], fontsize=16)
plt.imshow(ims[i], interpolation=None if interp else 'none')
#it grabs total of 2 as batchsize is 2 from which some of them are cats others are dogs
images , lables = next(train_batches)
plots(ims = images, titles = lables)
#noOfBatches = totalNumberOfSamples / batchSize
#NoOfBachesOfSamples to yield from generator before declaring one epcoh is finish
model = k.Sequential([
k.layers.Conv2D(filters=32,kernel_size=(3,3), activation="relu", input_shape = (224,224,3)),
k.layers.Flatten(),
k.layers.Dense(2,activation="softmax")])
model.compile(k.optimizers.Adam(lr=0.0001),loss="categorical_crossentropy",metrics = ["accuracy"])
model.fit_generator(train_batches,steps_per_epoch=12/2,validation_data=valid_batches,
validation_steps=4/1,epochs=5,verbose=2)
images = []
lables = []
for i in np.arange(4):
test_images , test_lables = next(test_batches)
plots(ims= test_images ,titles=test_lables)
images.append(test_images)
lables.append(test_lables)
import tensorflow as tf
from future import print_function
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Activation
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K
x = [2, 3, 7, 8, 9, 10]
y = [11, 12, 13, 14, 15, 16]
print(x)
print(y)
modelr = keras.Sequential([
keras.layers.Dense(80, activation=tf.nn.relu, input_shape=[1]),
keras.layers.Dense(80, activation=tf.nn.relu),
keras.layers.Dense(80, activation=tf.nn.relu),
keras.layers.Dense(80, activation=tf.nn.relu),
keras.layers.Dense(80, activation=tf.nn.relu),
keras.layers.Dense(1)
])
modelr.compile(loss='mean_squared_error',
optimizer='adam',
metrics=['mean_absolute_error', 'mean_squared_error'])
modelr.fit(x, y, epochs=9)
def __init__(self, full_dataset, batch_size=1024, latent_dim=5, num_pattern=200, num_labels=10):
"""
Objects which are shared across many agents
(e.g. vae, ...)
"""
self.handle = tf.placeholder(tf.string, shape=[])
self.batch_size = batch_size
self.latent_dim = latent_dim
self.num_pattern = num_pattern
self.num_labels = num_labels
self.iterator = tf.data.Iterator.from_string_handle(self.handle, full_dataset.batch(self.batch_size).output_types,
full_dataset.batch(self.batch_size).output_shapes)
x_train_ph, z_mean_ph, z_log_var_ph, y_train_ph = self.iterator.get_next()
# x_train_ph = tf.placeholder(tf.float32, shape=[None, x_train.shape[1]])
# y_train_ph = tf.placeholder(tf.float32, shape=[None,])
# z_mean_ph = tf.placeholder(tf.float32, shape=[None, z_train.shape[1]])
# z_log_var_ph = tf.placeholder(tf.float32, shape=[None, z_log_var_train.shape[1]])
z_cov = tf.matrix_diag(tf.exp(z_log_var_ph + 1e-10))
# Train the latent classifier ==================================================================================
print('Training latent classifier...')
self.latent_clf = keras.Sequential([
keras.layers.InputLayer(input_tensor=z_mean_ph, input_shape=(self.latent_dim,)),
keras.layers.Dense(128, activation=tf.nn.relu),
keras.layers.Dense(10, activation=tf.nn.softmax)
])
latent_loss = K.sparse_categorical_crossentropy(y_train_ph, self.latent_clf.output, from_logits=True)
self.latent_train_step = tf.train.AdamOptimizer().minimize(latent_loss)
# Train the specialized classifiers ================================================================================
print('Training specialized classifiers...')
self.scale_to_unconstrained = tfb.Chain([
# step 3: flatten the lower triangular portion of the matrix
tfb.Invert(tfb.FillTriangular(validate_args=True)),
# step 2: take the log of the diagonals
tfb.TransformDiagonal(tfb.Invert(tfb.Exp(validate_args=True))),
# # step 1: decompose the precision matrix into its Cholesky factors
# tfb.Invert(tfb.CholeskyOuterProduct(validate_args=True)),
])
# random_init = False
# if random_init:
# means = tf.Variable(initial_value=tf.random_uniform(means_.shape), trainable=True, dtype=tf.float32)
# scales_unconstrained = tf.Variable(
# initial_value=scale_to_unconstrained.forward(np.linalg.cholesky(covariances_)),
# trainable=True, dtype=tf.float32)
# scales_unconstrained = tf.Variable(initial_value=tf.random_uniform(scales_unconstrained.shape),
# trainable=True,
# dtype=tf.float32)
# scales = scale_to_unconstrained.inverse(scales_unconstrained)
# else:
# means = tf.Variable(initial_value=means_, trainable=True, dtype=tf.float32)
# scales_unconstrained = tf.Variable(
# initial_value=scale_to_unconstrained.forward(np.linalg.cholesky(covariances_)),
# trainable=True, dtype=tf.float32)
# scales = scale_to_unconstrained.inverse(scales_unconstrained)
self.means = tf.get_variable(name='gmm_means', shape=(self.num_pattern, self.latent_dim), trainable=True, dtype=tf.float32)
self.scales_unconstrained = tf.get_variable(
name='gmm_scale',
shape=(self.num_pattern, (self.latent_dim*self.latent_dim + self.latent_dim) / 2),
trainable=True,
dtype=tf.float32
)
scales = self.scale_to_unconstrained.inverse(self.scales_unconstrained)
covariances = tf.matmul(scales, tf.linalg.transpose(scales))
p = tfp.distributions.MultivariateNormalTriL(
loc=self.means,
scale_tril=scales + tf.eye(self.latent_dim, self.latent_dim, batch_shape=(self.num_pattern,)) * 1e-5,
validate_args=True
)
S_label_pattern = tfp.monte_carlo.expectation(
f=lambda x: self.latent_clf(x),
samples=p.sample(1),
log_prob=p.log_prob,
use_reparametrization=(p.reparameterization_type == tfp.distributions.FULLY_REPARAMETERIZED)
)
coeffs = Bhattacharyya_coeff(z_mean_ph, z_cov, self.means, covariances)
coeffs = tf.reshape(coeffs, [tf.shape(x_train_ph)[0], self.num_pattern, 1])
coeffs_sum = tf.reduce_sum(coeffs, axis=[1, 2])
coeffs = tf.tile(coeffs, [1, 1, self.num_labels])
# S_label_pattern = tf.reshape(S_label_pattern, [1, self.num_pattern, self.num_labels])
# S_label_pattern = tf.tile(S_label_pattern, [tf.shape(x_train_ph)[0], 1, 1])
S_label_x = coeffs * S_label_pattern + (1 - coeffs) * (1 / self.num_labels)
# Combine specialized classifiers to obtained recomposed model =====================================================
coeffs_sum = tf.reshape(coeffs_sum, [tf.shape(x_train_ph)[0], 1, 1])
L_label_x = (coeffs / coeffs_sum) * S_label_x
L_label_x = tf.reduce_sum(L_label_x, axis=1)
# Construct loss function and optimizer ============================================================================
# true_pred_ph = tf.placeholder(tf.float32, shape=[None, true_pred.shape[1]])
# loss = tf.reduce_mean(
# tf.reduce_mean(tf.square(tf.log(tf.clip_by_value(L_label_x, 1e-10, 1.0)) - true_pred_ph), axis=1))
# loss = tf.debugging.check_numerics(
# loss,
# 'loss'
# )
# optimizer = tf.train.AdamOptimizer()
# # opt = optimizer.minimize(loss, var_list=[scales_unconstrained, means])
# grads_and_vars = optimizer.compute_gradients(loss, var_list=[self.scales_unconstrained, self.means])
# # clipped_grads_and_vars = [(tf.clip_by_norm(g, 1), v) for g, v in grads_and_vars if g is not None]
# grads_and_vars = [(tf.debugging.check_numerics(g, 'gradient'), v) for g, v in grads_and_vars]
# opt = optimizer.apply_gradients(grads_and_vars)
self.S_label_pattern = S_label_pattern
black_box_model = keras.Sequential([
Conv2D(32,
kernel_size=(3, 3),
activation='relu',
kernel_initializer='he_normal',
input_shape=input_shape),
Conv2D(32,
kernel_size=(3, 3),
activation='relu',
kernel_initializer='he_normal'),
MaxPool2D((2, 2)),
Dropout(0.20),
Conv2D(64, (3, 3),
activation='relu',
padding='same',
kernel_initializer='he_normal'),
Conv2D(64, (3, 3),
activation='relu',
padding='same',
kernel_initializer='he_normal'),
MaxPool2D(pool_size=(2, 2)),
Dropout(0.25),
Conv2D(128, (3, 3),
activation='relu',
padding='same',
kernel_initializer='he_normal'),
Dropout(0.25),
Flatten(),
Dense(128, activation='relu'),
BatchNormalization(),
Dropout(0.25),
Dense(num_classes, activation='softmax'),
])
def model_initial_search(data, test_fraction, random_state, layers,
cumulative_time, params):
X, Y, input_dim, output_dim = dp.data_info(data)
proj_name = data["proj_name"]
X_train, X_test, Y_train, Y_test = train_test_split(
X, Y, test_size=test_fraction, random_state=random_state)
activation_functions = params["activation_functions"]
units = params["units"]
iterations = (len(units) * len(activation_functions))**(
layers + 1) * len(activation_functions)
inner_iterations = (len(units) * len(activation_functions))**layers
options = make_combo(option1=activation_functions, option2=units)
af_combs = make_pairwise_list(max_depth=layers, options=options)
print(f'{layers}\t{options}\t{iterations} iterations required')
best_R = 0.0
best_param = []
iteration_n = 1
for n in range(layers):
best_param.append(['none', 'none'])
for inner_iteration in range(inner_iterations):
for option_in in options:
inner_list = []
for k in range(layers):
inner_list.append(af_combs[inner_iteration][k])
for activation_out in activation_functions:
print(inner_list)
print(f"running iteration {iteration_n}")
parameter_list = []
parameter_list.append(option_in)
parameter_list.extend(inner_list)
parameter_list.append(activation_out)
print(
f"create input layer with activation of {option_in[0]} and units of {option_in[1]}"
)
model = keras.Sequential()
model.add(
keras.layers.Dense(option_in[1],
input_dim=input_dim,
activation=option_in[0]))
for i in range(len(inner_list)):
print(
f"create hidden layer {i+1} of activation {inner_list[i][0]} and units {inner_list[i][1]}"
)
model.add(keras.layers.BatchNormalization(momentum=0.9))
model.add(
keras.layers.Dense(inner_list[i][1],
activation=inner_list[i][0]))
print(
f"create output layer with activation of {activation_out} and units of {output_dim}"
)
model.add(
keras.layers.Dense(output_dim, activation=activation_out))
model.compile(loss='mean_squared_error',
optimizer='adam',
metrics=[R_squared])
earlystop = keras.callbacks.EarlyStopping(
monitor='val_R_squared',
min_delta=0.0001,
patience=20,
mode='auto')
collection_folder = './Results/%s_collection%d' % (proj_name,
layers)
if not os.path.exists(collection_folder):
os.makedirs(collection_folder)
output_folder = './Results/%s_collection%d/intermediate_output%d' % (
proj_name, layers, iteration_n)
if not os.path.exists(output_folder):
os.makedirs(output_folder)
filepath = output_folder + "/weights-{epoch:02d}-{val_R_squared:.2f}.hdf5"
checkpoint = keras.callbacks.ModelCheckpoint(
filepath,
monitor='val_R_squared',
verbose=1,
save_best_only=False,
save_weights_only=True,
mode='auto',
period=10)
callbacks_list = [earlystop, checkpoint]
start = time.time()
history = model.fit(X_train,
Y_train,
epochs=300,
batch_size=10,
callbacks=callbacks_list,
validation_split=0.2,
verbose=0)
end = time.time()
cumulative_time += (end - start)
print('it already took %0.2f seconds' % (cumulative_time))
scores = model.evaluate(X_test, Y_test, verbose=0)
if not os.path.exists("./Results/results%d.txt" % (layers)):
f = open("./Results/results%d.txt" % (layers), "w+")
else:
f = open("./Results/results%d.txt" % (layers), "a+")
f.write("For this combination %s, R is %0.2f\r\n" %
(parameter_list, scores[1]))
if scores[1] > best_R:
best_param = parameter_list
best_R = scores[1]
else:
pass
f.write("The best_R for now is %0.4f and combination is %s " %
(best_R, best_param))
iteration_n += 1
x = {
"layer_number": layers,
"starting_n": iteration_n - 1,
"best_R": best_R,
"best_param": best_param,
"cumulative_time": cumulative_time
}
print(x)
pr.check_write(x, 'latest.json')
print("")
print("")
f.close()
print(best_param)
print(best_R)
print('Training process has been finished')
print('model took %0.2f seconds to train' % (cumulative_time))
return best_param, best_R
def main():
global errors
# print opening header
print()
tuna.print_tuna()
print( "\nstocktuna by Justin Bodnar\n" )
print( "Can we teach computers to speculate?\n" )
# main program infinite loop
choice = 420
while int(choice) > 0:
choice = 0
# main menu text
print( "Menu" )
print( "0. EXIT" )
print( "1. Create new data sets" )
print( "2. Extend data set" )
print( "3. List and analyze available data sets" )
print( "4. Train a model on a data set" )
print( "5. View a random data point and tag" )
print( "6. Graph a random data point and tag (uses MatPlotLib)" )
print( "7. Watch a model make 10,000 predictions" )
# get user chice
choice = int(input( "\nEnter choice: "))
# EXIT
if choice == 0:
print( "\nEXITING\n" )
exit()
# choice == 1
# create new data set
elif choice == 1:
# get user parameters
level = int(input("Enter data level: "))
size = int(input("Enter size of dataset: "))
n = int(input("Enter the number of days to look at: "))
d = int(input("Enter number of days invested: "))
filename = str(level)+"-"+str(size)+"-"+str(n)+"-"+str(d)
# create data set
data, tags = create_data_set(level, size, n, d)
# output
print( "Dataset saved as ./datasets/"+ filename+"_tags and ./datasets/"+ filename+"_data" )
print( "Filename: level-size-n-d_[data|tags]" )
# wait for user input
pause = input( "Press enter to continue" )
# choice == 2
# extend a data set
elif choice == 2:
# try-catch block
try:
# get user input
dataset_filename, level, size, n, d = cli_choose_dataset()
# check for 0 datasets
if level < 0:
print( "NO DATASETS AVAILABLE. BUILD ONE TO CONTINUE." )
continue
# get user input
number_of_data_to_add = int(input("Enter number of data points to add: "))
size_of_new_dataset = number_of_data_to_add + size
# unpickle lists
data = pickle.load( open( dataset_filename + "_data", "rb" ) )
tags = pickle.load( open( dataset_filename + "_tags", "rb" ) )
# get new list
newData, newTags = create_data_set(int(level), number_of_data_to_add, int(n), int(d))
# append lists
data += newData
tags += newTags
# make new filename
new_filename = str(level) + "-" + str(size_of_new_dataset) + "-" + str(n) + "-" + str(d)
# repickle list
pickle.dump( data, open( "./datasets/"+new_filename+"_data", "wb" ) )
pickle.dump( tags, open( "./datasets/"+new_filename+"_tags", "wb" ) )
# print errors
except Exception as e:
if errors:
print( e )
print(tuna.print_exception())
pass
# choice == 3
# analyze available data sets
elif choice == 3:
# get user input
dataset_filename, level, size, n, d = cli_choose_dataset()
# check for 0 datasets
if level < 0:
print( "NO DATASETS AVAILABLE. BUILD ONE TO CONTINUE." )
continue
# try to unpickle dataset file
try:
# unpickle
data_set = pickle.load( open( dataset_filename+"_data", "rb" ) )
# get length of dim 2
min = 99999999
max = -1
# loop through dim 1, checking each entry alonog dim 2 for size
for data_point in data_set:
# check for min or max
if len(data_point) > max:
max = len(data_point)
if len(data_point) < min:
min = len(data_point)
# print output
print( "\nName: ", dataset_filename )
print( "Dim 1:", len(data_set), "(size)")
if min == max:
print( "Dim 2:", min, "(n)" )
else:
print( "Data set irregular with bounds (", min, ",", max, ")" )
print( "Fixing with lower bound", min, "as new dim2 size" )
# loop through dim 1, creating new dataset of proper dim 2 size
regularized_data_set = []
for data_point in data_set:
regularized_data_set.append( data_point[-min:] )
# replace the old dataset with the regularized one
data_set = regularized_data_set
# get new stats
min = 999999
max = -1
# for each data_point
for data_point in data_set:
# check for new min or max
if len(data_point) < min:
min = len(data_point)
if len(data_point) > max:
max = len(data_point)
# print new datset stats
if min == max:
print( "New dim 2:", min )
print( "Repickling. Please rerun this function to confirm updates" )
pickle.dump( data_set, open( "./datasets/"+file, "wb" ) )
else:
print( "Data set STILL irregular with bounds (", min, ",", max, ")" )
# print errors
except Exception as e:
if errors:
print( e )
print(print_exception())
pass
print()
# wait for user to press enter
pause = input( "Press enter to continue." )
# choice == 4
# build model from data set
elif choice == 4:
# try to unpickle data set and train classifier
try:
# get user input
dataset_filename, level, size, n, d = cli_choose_dataset()
# check for 0 datasets
if level < 0:
print( "NO DATASETS AVAILABLE. BUILD ONE TO CONTINUE." )
continue
# get user input
print( "Using 3-layer neural network" )
epochs = int(input("Enter number of epochs: "))
layer1 = int(input("Enter number of nodes for Layer 1: "))
layer2 = int(input("Enter number of nodes for Layer 2: "))
layer3 = int(input("Enter number of nodes for Layer 3: "))
# create model filename
model_filename = dataset_filename.split("/")[1] + "-" + str(layer1) + "-" + str(layer2) + "-" + str(layer3)
# unpickle the data and tags lists
tags = pickle.load( open( dataset_filename+"_tags", "rb" ) )
data = pickle.load( open( dataset_filename+"_data", "rb" ) )
# print output
print("tags initial size:", len(tags))
print("data initial size:", len(data))
# split data into training/testing
size = int( len(data)*(0.75) )
train_data = np.array( data[1:size] )
train_tags = np.array( tags[1:size] )
test_data = np.array( data[size:] )
test_tags = np.array( tags[size:] )
# print output
print("tags training size:", len(train_tags))
print("data training size:", len(train_data))
print("tags testing size:", len(test_tags))
print("data testing size:", len(test_data))
# train model
model = keras.Sequential()
model.add( keras.layers.Dense( layer1, input_dim=len(data[0]) ) )
model.add( keras.layers.Dense( layer2, input_dim=26 ) )
model.add( keras.layers.Dense( layer3, input_dim=13 ) )
model.add( keras.layers.Dense(2, activation=tf.nn.softmax) )
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
model.fit(train_data, train_tags, epochs=epochs)
# calculate test loss and est acc
test_loss, test_acc = model.evaluate(test_data, test_tags)
print('Test accuracy:', test_acc)
print( "Save model? Y or N" )
save_choice = input( "\nEnter choice: ")
if save_choice is "Y" or save_choice is "y":
# save model
model.save("./models/"+model_filename)
# print output
print( "Model saved" )
print( "Filename: " + model_filename )
print( "Filename: level-size-n-d-epochs-layer1-layer2-layer3\n" )
# print errors
except Exception as e:
if errors:
print( e )
print(tuna.print_exception())
pass
# pause for user input
pause = input( "Press enter to continue" )
# choice == 5
# grab and view random datum
elif choice == 5:
level = int(input("\nEnter data level: "))
n = int(input("Enter number of days to look at before investing: "))
d = int(input("Enter number of days to have been invested: "))
random_investment( level, n, d, True )
# choice == 6
# build model from data set
elif choice == 6:
level = int(input("\nEnter data level: "))
n = int(input("Enter number of days to look at before investing: "))
d = int(input("Enter number of days to have been invested: "))
stock_ticker, data, dates, tag = random_investment( level, n, d, False )
graph_data_set( stock_ticker, data, dates, level, n, d, tag )
# choice == 7
# watch model make predictions
elif choice == 7:
# get model choice
model_filename, level, size, n, d, layer1, layer2, layer3 = cli_choose_model()
# get how many predictions
count = int(input( "How many predictions to make? "))
# check for no models
if level < 0:
standyby = input( "NO MODELS TO LOAD. PRESS ENTER TO CONTINUE" )
continue
cli_make_predictions( count, model_filename, level, n, d )
# choice != VALID
else:
pause = input("Invalid choice\nPress enter to continue.")
warnings.filterwarnings('ignore')
inputs = np.random.uniform(size=(10, 3, 30, 30))
params = {
'kernel_h': 5,
'kernel_w': 5,
'pad': 0,
'stride': 2,
'in_channel': inputs.shape[1],
'out_channel': 64,
}
layer = Convolution(params)
out = layer.forward(inputs)
keras_model = keras.Sequential()
keras_layer = layers.Conv2D(filters=params['out_channel'],
kernel_size=(params['kernel_h'], params['kernel_w']),
strides=(params['stride'], params['stride']),
padding='valid',
data_format='channels_first',
input_shape=inputs.shape[1:])
keras_model.add(keras_layer)
sgd = optimizers.SGD(lr=0.01)
keras_model.compile(loss='mean_squared_error', optimizer='sgd')
weights = np.transpose(layer.weights, (2, 3, 1, 0))
keras_layer.set_weights([weights, layer.bias])
keras_out = keras_model.predict(inputs, batch_size=inputs.shape[0])
print('Relative error (<1e-6 will be fine): ', rel_error(out, keras_out))
# %% [markdown]
def main():
fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images,
test_labels) = fashion_mnist.load_data()
print("Data Info:")
print("train img shape: " + str(train_images.shape))
print("Len: " + str(len(train_labels)))
print("Train Labels: " + str(train_labels))
print("Test img shape: " + str(test_images.shape))
print("Len: " + str(len(test_labels)))
print("--------------------")
#Normalize data
train_images = train_images / 255.0
test_images = test_images / 255.0
#Create model
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(1024, activation=tf.nn.relu),
keras.layers.Dropout(0.5),
keras.layers.Dense(512, activation=tf.nn.sigmoid),
keras.layers.Dropout(0.5),
keras.layers.Dense(10, activation=tf.nn.softmax)
])
#Compile model
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
workers = mp.cpu_count()
batch_size = 512
model.fit_generator(generator=SeqGen(train_images,
train_labels,
batch_size=batch_size),
epochs=10,
verbose=1,
workers=workers)
#Evaluate model
test_loss, test_acc = model.evaluate(test_images, test_labels)
print('Test accuracy:', test_acc)
#Make predictions
predictions = model.predict(test_images)
print("Prediction: " + str(predictions[0]))
#Plot results
num_rows = 5
num_cols = 3
num_images = num_rows * num_cols
plt.figure(figsize=(2 * 2 * num_cols, 2 * num_rows))
for i in range(num_images):
plt.subplot(num_rows, 2 * num_cols, 2 * i + 1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(num_rows, 2 * num_cols, 2 * i + 2)
plot_value_array(i, predictions, test_labels)
plt.show()
model = keras.Sequential([
keras.layers.Conv2D(input_shape=(21, 21, 8),
filters=16,
kernel_size=3,
padding='same',
activation='selu',
strides=(2, 2)),
keras.layers.BatchNormalization(),
keras.layers.Dropout(0.5),
keras.layers.Conv2D(filters=128,
kernel_size=5,
padding='same',
activation='selu',
strides=(2, 2)),
keras.layers.BatchNormalization(),
keras.layers.Dropout(0.5),
keras.layers.Conv2D(filters=256,
kernel_size=5,
padding='same',
activation='selu',
strides=(2, 2)),
keras.layers.BatchNormalization(),
keras.layers.Dropout(0.5),
#keras.layers.Conv2D(filters=32, kernel_size=3,padding='same',activation='selu',strides=(2,2)),
#keras.layers.BatchNormalization(),
#keras.layers.Dropout(0.5),
#keras.layers.Conv2D(filters=128, kernel_size=3,padding='same',activation='selu',strides=(2,2)),
#keras.layers.BatchNormalization(),
keras.layers.Flatten(),
keras.layers.Dense(units=n_node, activation='sigmoid'),
keras.layers.Dropout(drate),
keras.layers.Dense(units=1, activation='linear')
])
def main(dim=84):
global Local, LOGGER
LOGGER.info('starting main for {} dimensions'.format(dim))
# read data
train = pd.read_hdf("train.h5", "train")
test = pd.read_hdf("test.h5", "test")
index = test.index
X = train.drop(['y'], axis=1).values
y = train.pop('y').values
test = test.values
X = StandardScaler().fit_transform(X)
test = StandardScaler().fit_transform(test)
enc_dim = dim # enc_dim: dimension to encode to
# create input layer
i_layer = Input(shape=(120, ))
# create intermediate encoding layer
interm_dim = 480
interm_enc = Dense(interm_dim, activation='sigmoid')(i_layer)
# create encoded layer
# e_layer = Dense(enc_dim, activation = 'relu')(i_layer)
e_layer = Dense(enc_dim, activation='sigmoid')(interm_enc)
# create intermediate decoding layer
interm_dec = Dense(interm_dim, activation='sigmoid')(e_layer)
# create decoded layer
d_layer = Dense(120)(interm_dec)
# create auto-encoder, the model that maps input straight to output
auto_encoder = Model(i_layer, d_layer)
# encoder: map input to lower dimension
encoder = Model(i_layer, e_layer)
# # create model for decoding
# enc_input = Input(shape = (enc_dim,))
# dec_layer = auto_encoder.layers[-1]
# decoder = Model(enc_input, dec_layer(enc_input))
# now let's train!
# NOTE: we encode our entire X!
auto_encoder.compile(optimizer='adadelta', loss='binary_crossentropy')
auto_encoder.fit(X, X, epochs=500)
# and now we can encode our data:
X = encoder.predict(X)
test = encoder.predict(test)
# update user
print('encoding done!')
# now we do regular prediction on encoded data, if the local-flag is set to True
X_train, X_test, y_train, y_test = (train_test_split(
X, y, test_size=0.33, random_state=42) if Local else
(X, y, test, test))
# Model 2 from earlier
model = keras.Sequential([
keras.layers.Dense(120, activation=tf.nn.relu, input_dim=enc_dim),
keras.layers.Dense(120, activation=tf.nn.tanh),
keras.layers.Dropout(0.25),
keras.layers.Dense(120, activation=tf.nn.relu),
keras.layers.Dense(120, activation=tf.nn.relu),
keras.layers.Dropout(0.5),
keras.layers.Dense(5, activation=tf.nn.softmax)
])
model.name = 'model2'
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
#
model.fit(X_train, y_train, epochs=1000)
LOGGER.info('Done, {} now'.format('evaluating' if Local else 'predicting'))
if Local:
# if local is set to True: evluate on local data
results = model.evaluate(X_test, y_test)
print("done :D")
print(results)
LOGGER.info('evaluation done, results:')
LOGGER.info(results)
now = dt.now()
LOGGER.info(
'timestamp: ' +
'{}, {}, {}\n\n'.format(now.month, now.day, now.hour, now.minute))
else:
# otherwise predict test-set and print to csv
y_pred = model.predict_classes(test)
resf = pd.DataFrame({'Id': index, 'y': y_pred})
# get the filename:
# import datetime.datetime as dt
now = dt.now()
filename = 'Results_task3_{}_{}_{}_{}.csv'.format(
now.month, now.day, now.hour, now.minute)
resf.to_csv(filename, index=False)
print('Done')
def __init__(self):
self.model = keras.Sequential()
self.plot_losses = PlotLossesCallback()
self.save_model_img = 'image/convolutional_neural_network_model_cifar10.png'
self.save_model_file = 'model/convolutional_neural_network_model_cifar10.h5'
import keras
from keras.models import load_model
import cv2
import numpy as np
from libs.hdf5datasetgeneratormultilabel import HDF5DatasetGenerator
from libs.hdf5datasetwriter import HDF5DatasetWriter
model = load_model("ResNet50")
model1 = keras.Sequential()
model.pop()
model.pop()
for layer in model.layers:
model1.add(layer)
model = model1
print(model.summary())
BATCH_SIZE = 32
trainGen = HDF5DatasetGenerator("hdf5/train2.hdf5", BATCH_SIZE, classes=5)
valGen = HDF5DatasetGenerator("hdf5/val.hdf5", BATCH_SIZE, classes=5)
print(trainGen.db["images"].shape[0])
print(valGen.db["images"].shape[0])
train_dataset = HDF5DatasetWriter((trainGen.db["images"].shape[0], 2048),
"hdf5/train_features_ResNet50.hdf5",
dataKey="features",
bufSize=1000)
features = model1.predict(trainGen.db["images"])
#f1=[]
#for feature in features:
# f1.append(feature.flatten())
#features=np.array(f1)
print(features.shape)
train_images.shape
train_images = train_images / 255.0
test_images = test_images / 255.0
plt.figure(figsize=(10, 10))
for i in range(25):
plt.subplot(5, 5, i + 1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(train_images[i], cmap=plt.cm.binary)
plt.xlabel(class_names[train_labels[i]])
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(784, activation=tf.nn.relu),
keras.layers.Dense(392, activation=tf.nn.relu),
keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adadelta',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=20)
test_loss, test_acc = model.evaluate(test_images, test_labels)
print('Test accuracy:', test_acc)
model.save('my_model.h5')
print("Saved model to disk")
def app():
# 数据集加载
imdb = keras.datasets.imdb
(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)
logger.info("Raw train entries: {}, labels: {}".format(len(train_data), len(train_labels)))
logger.info("Raw test entries: {}, labels: {}".format(len(test_data), len(test_labels)))
print()
# 获取数据集的 词汇索引字典
d_word_index = imdb.get_word_index()
# l_words = ['\t'.join([str(word), str(w_index)]) for word, w_index in d_word_index.items()][:10]
# some_words = "\n".join(l_words)
# print(f"{some_words}")
# 新增 词汇符号 进入词汇索引字典，并调整词汇索引
# print(decode_text(d_word_index, train_data[0])) # 文本原文(调整词汇索引前，貌似转换的内容不对)
# print()
d_word_index = {k: (v + 3) for k, v in d_word_index.items()}
d_word_index["<PAD>"] = 0
d_word_index["<START>"] = 1
d_word_index["<UNK>"] = 2 # unknown
d_word_index["<UNUSED>"] = 3
# 查看具体的文本数据情况
# print(train_data[0]) # 文本数字化情况
print(decode_text(d_word_index, train_data[0])) # 文本原文
# print(f"train_data[0] len: {len(train_data[0])}") # 不同文本的单词长度可能不同
# print(f"train_data[1] len: {len(train_data[1])}")
# 将原始文本数据，进行 预处理编码
train_data = keras.preprocessing.sequence.pad_sequences(train_data, value=d_word_index["<PAD>"], padding='post',
maxlen=256)
test_data = keras.preprocessing.sequence.pad_sequences(test_data, value=d_word_index["<PAD>"], padding='post',
maxlen=256)
logger.info("Train shape: {}, Test shape: {}".format(train_data.shape, test_data.shape))
# 创建交叉验证集
x_val = train_data[:10000]
y_val = train_labels[:10000]
partial_x_train = train_data[10000:]
partial_y_train = train_labels[10000:]
# 模型设计
# 输入形状是用于电影评论的词汇数目（10,000 词）
vocab_size = 10000
model = keras.Sequential()
model.add(keras.layers.Embedding(vocab_size, 16))
model.add(keras.layers.GlobalAveragePooling1D())
model.add(keras.layers.Dense(16, activation='relu'))
model.add(keras.layers.Dense(1, activation='sigmoid'))
model.summary() # 查看模型结构
# 设置模型训练参数
optimizer = "adam"
loss_fnc = "binary_crossentropy"
metrics = ["accuracy"]
model.compile(optimizer=optimizer, loss=loss_fnc, metrics=metrics)
# 进行模型训练
history = model.fit(partial_x_train,
partial_y_train,
epochs=40,
batch_size=512,
validation_data=(x_val, y_val),
verbose=1)
# 模型训练过程状态
show_image(history)
# 模型评估
results = model.evaluate(test_data, test_labels, verbose=2)
print(results)
pass
X = df2[df2.columns[:-1]]
X.shape
#Scaling the data
transformer = RobustScaler().fit(X)
X = transformer.transform(X)
X
###validation split
X, valX, Y, valY = train_test_split(X, Y, test_size=0.2, random_state=0)
X.shape
model = keras.Sequential([
keras.layers.Dense(1000, activation='relu', input_dim=32),
keras.layers.Dense(800, activation='relu'),
keras.layers.Dense(640, activation='relu'),
keras.layers.Dense(580, activation='relu'),
keras.layers.Dense(330, activation='relu'),
keras.layers.Dense(250, activation='relu'),
keras.layers.Dense(100, activation='relu'),
keras.layers.Dense(42, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
plot_model(model,
to_file='model_plot.png',
show_shapes=True,
show_layer_names=True)
with tf.device('/device:GPU:0'):
resnet = keras.applications.resnet50.ResNet50(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None)
from keras.layers import Dropout, Flatten, Dense
#########################################################
# Locking First 51 Layer # Non Trainable
#########################################################
for layer in resnet.layers[:51]:
layer.trainable = False
#########################################################
# Creating Model
#########################################################
top_model = keras.Sequential()
top_model.add(resnet)
top_model.add(Dense(512, activation="relu"))
top_model.add(Dense(256, activation="relu"))
top_model.add(Dense(64, activation="relu"))
top_model.add(Dense(1, activation="tanh"))
#########################################################
# Load Weights From early trained models if you want
#########################################################
#checkpoint_folder="gdrive/My Drive/Self-Driving-Car-Data/CheckPointModel/"
#top_model.load_weights(checkpoint_folder+"saved-model-{epoch:02d}-{val_acc:.2f}.hdf5")
#########################################################
# Defining Root Mean Squared Error Function
#########################################################
def call(self, x):
return keras.layers.Add()([x, keras.Sequential(self.layers)(x)])
import keras
import numpy as np
import tensorflow as tf
model = keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])])
model.compile(optimizer='sgd', loss='mean_squared_error')
xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)
#model.fit(xs, ys, epochs=500)
#print(model.predict([10.0]))
#Main model function
class Model(object):
def __init__(self):
self.w = tf.Variable(10.0)
self.b = tf.Variable(10.0)
def __call__(self, x):
return self.w * x + self.b
model = Model()
xs = [-1.0, 0.0, 1.0, 2.0, 3.0, 4.0]
ys = [-3.0, -1.0, 1.0, 3.0, 5.0, 7.0]
print(model(xs))
#Loss function
def loss(predicted_Y, target_Y):
df.groupby('station_id')['air_data_value'].sum()
df['air_data_value'].describe()
df = df.drop(columns = 'station_id')
df = df.drop(columns = 'stime')
df = df.drop(columns = 'UGRD')
df = df.drop(columns = 'VGRD')
df = df.drop(columns = 'air_data_value')
X = df.drop(columns = ('PM_buckets'))
y = df['PM_buckets']
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.2,random_state = 1)
model = keras.Sequential([
keras.Input((5)),
layers.Dense(128,activation = 'relu'),
layers.Dense(32,activation = 'relu'),
layers.Dense(1)
])
model.summary()
model.compile(optimizer = 'adam', loss = 'mean_squared_error',metrics = "accuracy")
model.evaluate(X_test,y_test)
y_pred = model.predict(X_test)
print(":".join([str(c), str(x)]))
result = reply_df.query('Label == '+ str(compatible_class))
print(result['Words'])
"""# モデルの作成(Keras)"""
import keras
import tensorflow as tf
import numpy as np
import numpy as np
#--モデルの作成--#
ips = classify_dictionary.shape[1] # 辞書の単語数をshapeに変換
l = np.unique(classify_label) #ラベルの個数を取得
model_keras = keras.Sequential()
#隠れ層(input_shapeは辞書の長さの変数、アウトプットは使われたラベルの個数とする)
model_keras.add(keras.layers.Dense(32, input_shape=(ips,)))
model_keras.add(keras.layers.Dense(16, activation=tf.nn.relu))
model_keras.add(keras.layers.Dense(l.shape[0], activation=tf.nn.sigmoid))
model_keras.summary()
#--モデルのコンパイル--#
model_keras.compile(optimizer=tf.train.AdamOptimizer(),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
#--学習--#
history = model_keras.fit(classify_dictionary,
classify_label,
epochs=300,
y_train = None
x_dev = None
y_dev = None
x_test = None
y_test = None
dataset_predict = np.loadtxt("test.csv", delimiter=",", skiprows=1)
x_predict = None
# hyperparameters
input_dim = None # TODO
epochs = 5
batch_size = 32
# initialize
model = K.Sequential()
# architecture
model.add(K.layers.Dense(units=1, activation='sigmoid', input_dim=input_dim))
# loss
model.compile(loss=K.losses.categorical_crossentropy,
optimizer=K.optimizers.Adam)
# train: x_train and y_train are Numpy arrays
model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size) # TODO
# evaluate: dev set
loss_and_metrics_dev = model.evaluate(x_dev, y_dev, batch_size=batch_size)
# evaluate: test set
netDetailsItem = []
layers = []
if layer2 == 0:
layers.append(
keras.layers.Dense(layer1, input_dim=2, activation="tanh"))
layers.append(keras.layers.Dense(1, activation="linear"))
else:
layers.append(
keras.layers.Dense(layer1, input_dim=2, activation="tanh"))
layers.append(keras.layers.Dense(layer2, activation="tanh"))
layers.append(keras.layers.Dense(1, activation="linear"))
modell = keras.Sequential(layers)
print(modell.summary())
model = NetSlice.NetSlice(modell, 'keras', data)
routineSettings = {"CompileAll": True, "SaveAll": None}
trainRoutine = [{
"Compile": [
keras.optimizers.Adam(lr=0.1), 'mean_squared_error',
['binary_accuracy', 'categorical_accuracy']
],
"Train": [100, None, 0]
}, {
"Compile": [
keras.optimizers.Adam(lr=0.01), 'mean_squared_error',
def on_train_begin(self, logs={}):
self.losses = []
self.accuracys = []
def on_batch_end(self, batch, logs={}):
self.losses.append(logs.get('loss'))
self.accuracys.append(logs.get('accuracy'))
(train_x, train_y), (test_x, test_y) = fashion_mnist.load_data()
train_x = train_x.reshape(-1, 28 * 28)
test_x = test_x.reshape(-1, 28 * 28)
model = keras.Sequential([
keras.layers.Dense(28 * 28, input_shape=(28 * 28, ), activation='relu'),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(32, activation='softmax')
])
model.compile(
optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'],
)
history = LossHistory()
model.fit(train_x, train_y, epochs=5, batch_size=500, callbacks=[history])
test_loss, test_acc = model.evaluate(
test_x,
test_y,
verbose=2,
def hyperas_build_hani(same_train_paths, diff_train_paths, same_val_paths,
diff_val_paths, same_test_paths, diff_test_paths):
"""
A template function for Hyperas to execute tests
"""
import keras
K = keras.backend
KL = keras.layers
# generators
training_generator = LFWDataLoader(same_train_paths,
diff_train_paths,
shuffle=True)
validation_generator = LFWDataLoader(same_val_paths, diff_val_paths)
input_shape = (250, 250, 1)
from datetime import datetime
from os.path import isdir, exists
from src.lfw_dataset import _extract_samples_paths, train_info_url, test_info_url
import numpy as np
first_input = KL.Input(input_shape)
second_input = KL.Input(input_shape)
def tanh_scaled(x):
A = 1.7159
B = 2 / 3
return A * K.tanh(B * x)
model_params = {}
act = model_params.get('act', tanh_scaled)
dropout = model_params.get('dropout', 0)
batchnorm = model_params.get('batchnorm', False)
#loss = model_params.get('loss', contrastive_loss)
learning_rate = model_params.get('learning_rate', 1e-3)
first_input = KL.Input(input_shape)
second_input = KL.Input(input_shape)
batchnorm = True
dropout = True
act = 'relu'
model = keras.Sequential()
initialize_weights_conv = keras.initializers.glorot_uniform(
seed=84) # filters initialize
initialize_weights_dense = keras.initializers.glorot_uniform(
seed=84) # dense initialize
initialize_bias = keras.initializers.RandomNormal(
mean=0.5, stddev=0.01, seed=84) # bias initialize
model.add(
KL.Conv2D({{choice([5, 10, 14, 30, 60])}}, (6, 6),
strides=(2, 2),
activation=act,
input_shape=input_shape,
kernel_initializer=initialize_weights_conv,
kernel_regularizer=l2({{uniform(0, 0.1)}})))
model.add(KL.BatchNormalization())
model.add(KL.Dropout({{uniform(0, 0.5)}}))
model.add(KL.MaxPool2D())
model.add(
KL.Conv2D({{choice([5, 10, 14, 30, 60])}}, (6, 6),
strides=(2, 2),
activation=act,
kernel_initializer=initialize_weights_conv,
bias_initializer=initialize_bias,
kernel_regularizer=l2({{uniform(0, 0.1)}})))
model.add(KL.BatchNormalization())
model.add(KL.Dropout({{uniform(0, 0.5)}}))
model.add(KL.MaxPool2D())
model.add(
KL.Conv2D({{choice([5, 10, 14, 30, 60])}}, (6, 6),
activation=act,
kernel_initializer=initialize_weights_conv,
bias_initializer=initialize_bias,
kernel_regularizer=l2({{uniform(0, 0.1)}})))
model.add(KL.BatchNormalization())
model.add(KL.Dropout({{uniform(0, 0.5)}}))
model.add(KL.MaxPool2D())
model.add(KL.Flatten())
model.add(
KL.Dense({{choice([40, 64, 128, 256])}},
activation=act,
kernel_regularizer=l2({{uniform(0, 0.1)}}),
kernel_initializer=initialize_weights_dense,
bias_initializer=initialize_bias))
model.add(KL.Dropout({{uniform(0, 0.5)}}))
model.add(
KL.Dense({{choice([40, 64, 128, 256])}},
activation=None,
kernel_regularizer=l2({{uniform(0, 0.1)}}),
kernel_initializer=initialize_weights_dense,
bias_initializer=initialize_bias))
model.add(KL.Dropout({{uniform(0, 0.5)}}))
# Generate the encodings (feature vectors) for the two images
encoded_l = model(first_input)
encoded_r = model(second_input)
# calculate similarity
L1_distance = KL.Lambda(lambda tensors: K.abs(tensors[0] - tensors[1]))(
[encoded_l, encoded_r])
similarity = KL.Dense(1,
activation='sigmoid',
kernel_initializer=initialize_weights_dense,
bias_initializer=initialize_bias)(L1_distance)
final_network = keras.Model(inputs=[first_input, second_input],
outputs=similarity)
optimizer = keras.optimizers.SGD(lr={{uniform(0.0001, 0.1)}},
momentum={{uniform(0, 1)}},
decay={{uniform(0, 0.1)}})
final_network.compile(loss='binary_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
start_time = datetime.now()
history = final_network.fit_generator(generator=training_generator,
validation_data=validation_generator,
use_multiprocessing=False,
verbose=2,
epochs=30)
end_time = datetime.now()
validation_acc = np.amax(history.history['val_acc'])
print('Best validation acc of epoch:', validation_acc)
test_generator = LFWDataLoader(same_test_paths, diff_test_paths)
test_loss, test_accuracy = final_network.evaluate_generator(test_generator)
return {
'loss': -validation_acc,
'status': STATUS_OK,
'history': history.history,
'training_time': end_time - start_time,
'test_loss': test_loss,
'test_accuracy': test_accuracy
}
def run_fte_bte_exp(data_x, data_y, which_task, model, ntrees=30, shift=0):
df_total = []
for slot in range(
1
): # Rotates the batch of training samples that are used from each class in each task
train_x, train_y, test_x, test_y = cross_val_data(
data_x, data_y, shift, slot)
if model == "odif":
# Reshape the data
train_x = train_x.reshape(
train_x.shape[0],
train_x.shape[1] * train_x.shape[2] * train_x.shape[3])
test_x = test_x.reshape(
test_x.shape[0],
test_x.shape[1] * test_x.shape[2] * test_x.shape[3])
if model == "odin":
clear_session(
) # clear GPU memory before each run, to avoid OOM error
default_transformer_class = NeuralClassificationTransformer
network = keras.Sequential()
network.add(
layers.Conv2D(
filters=16,
kernel_size=(3, 3),
activation="relu",
input_shape=np.shape(data_x)[1:],
))
network.add(layers.BatchNormalization())
network.add(
layers.Conv2D(
filters=32,
kernel_size=(3, 3),
strides=2,
padding="same",
activation="relu",
))
network.add(layers.BatchNormalization())
network.add(
layers.Conv2D(
filters=64,
kernel_size=(3, 3),
strides=2,
padding="same",
activation="relu",
))
network.add(layers.BatchNormalization())
network.add(
layers.Conv2D(
filters=128,
kernel_size=(3, 3),
strides=2,
padding="same",
activation="relu",
))
network.add(layers.BatchNormalization())
network.add(
layers.Conv2D(
filters=254,
kernel_size=(3, 3),
strides=2,
padding="same",
activation="relu",
))
network.add(layers.Flatten())
network.add(layers.BatchNormalization())
network.add(layers.Dense(2000, activation="relu"))
network.add(layers.BatchNormalization())
network.add(layers.Dense(2000, activation="relu"))
network.add(layers.BatchNormalization())
network.add(layers.Dense(units=10, activation="softmax"))
default_transformer_kwargs = {
"network": network,
"euclidean_layer_idx": -2,
"loss": "categorical_crossentropy",
"optimizer": Adam(3e-4),
"fit_kwargs": {
"epochs": 100,
"callbacks":
[EarlyStopping(patience=5, monitor="val_loss")],
"verbose": False,
"validation_split": 0.33,
"batch_size": 32,
},
}
default_voter_class = KNNClassificationVoter
default_voter_kwargs = {"k": int(np.log2(300))}
default_decider_class = SimpleArgmaxAverage
p_learner = ProgressiveLearner(
default_transformer_class=default_transformer_class,
default_transformer_kwargs=default_transformer_kwargs,
default_voter_class=default_voter_class,
default_voter_kwargs=default_voter_kwargs,
default_decider_class=default_decider_class,
)
elif model == "odif":
p_learner = LifelongClassificationForest()
df = fte_bte_experiment(
train_x,
train_y,
test_x,
test_y,
ntrees,
shift,
slot,
model,
p_learner,
which_task,
acorn=12345,
)
df_total.append(df)
return df_total
from numpy import float32
import tensorflow as tf
import keras
from keras.datasets import fashion_mnist
from keras.layers import Activation, Flatten, Dense
(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()
x_train = x_train/255.0
x_test = x_test/255.0
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer=tf.train.AdamOptimizer(),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=1)
model.save('train-images-idx3-ubyte.gz')
model.load_weights('train-images-idx3-ubyte.gz')
test_loss, test_acc = model.evaluate(x_test, y_test)
