def build_classifier():
classifier = Sequential()
classifier.add(Dense(units=6, kernel_initializer='uniform', activation='relu', input_dim=11))
classifier.add(Dense(units=6, kernel_initializer='uniform', activation='relu'))
classifier.add(Dense(units=1, kernel_initializer='uniform', activation='sigmoid'))
classifier.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
return classifier
def target_last_layer():
model = Sequential()
model.add(
Dense(mc._TARGET_DIM_NUM,
name='target_nn_output',
input_shape=(mc._OUT_DIM, )))
return model
def source_last_layer():
model = Sequential()
model.add(
Dense(mc._SOURCE_DIM_NUM,
name='source_nn_output',
input_shape=(mc._OUT_DIM, )))
return model
def build_regressor():
regressor = Sequential()
regressor.add(Dense(units=6, kernel_initializer='uniform', activation='relu', input_dim=11))
regressor.add(Dense(units=6, kernel_initializer='uniform', activation='relu'))
regressor.add(Dense(units=1, kernel_initializer='uniform', activation='linear'))
regressor.compile(optimizer='adam', loss='mean_squared_error')
return regressor
def build(self):
"""
Builds the tiny yolo v2 network.
:param input: input image batch to the network
:return: logits output from network
"""
self.model = Sequential()
self.model.add(Convolution2D(16, (3, 3), input_shape=(416, 416, 3), padding='same'))
self.model.add(LeakyReLU())
self.model.add(BatchNormalization())
self.model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))
self.model.add(Convolution2D(32, (3, 3), padding='same'))
self.model.add(LeakyReLU())
self.model.add(BatchNormalization())
self.model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))
self.model.add(Convolution2D(64, (3, 3), padding='same'))
self.model.add(LeakyReLU())
self.model.add(BatchNormalization())
self.model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))
self.model.add(Convolution2D(128, (3, 3), padding='same'))
self.model.add(LeakyReLU())
self.model.add(BatchNormalization())
self.model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))
self.model.add(Convolution2D(256, (3, 3), padding='same'))
self.model.add(LeakyReLU())
self.model.add(BatchNormalization())
self.model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))
self.model.add(Convolution2D(512, (3, 3), padding='same'))
self.model.add(LeakyReLU())
self.model.add(BatchNormalization())
self.model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 1), padding='valid'))
self.model.add(Convolution2D(1024, (3, 3), padding='same'))
self.model.add(LeakyReLU())
self.model.add(BatchNormalization())
self.model.add(Convolution2D(1024, (3, 3), padding='same'))
self.model.add(LeakyReLU())
self.model.add(BatchNormalization())
self.model.add(Convolution2D(125, (1, 1), activation=None))
if self.config.optimizer == 'adam':
opt = Adam()
elif self.config.optimizer == 'sgd':
opt = SGD()
if self.config.loss == 'categorical_crossentropy':
loss = 'categorical_crossentropy'
elif self.config.loss == 'yolov2_loss':
raise NotImplemented
self.model.compile(loss=loss, optimizer=opt, metrics=['accuracy'])
self.model.summary()
return self.model
def _build_model(self):
# Neural Net for Deep-Q learning Model
model = Sequential()
model.add(Dense(24, input_dim=self.state_size, activation='relu'))
model.add(Dense(24, activation='relu'))
model.add(Dense(self.action_size, activation='linear'))
model.compile(loss='mse', optimizer=Adam(lr=self.learning_rate))
return model
def __init__(self):
self.losses = []
self.classifier = Sequential()
self.x_vail = []
self.y_vail = []
self.train_filepath = ''
self.train_img_filepath = ''
self.valid_filepath = ''
self.valid_img_filepath = ''
self.test_img_filepath = ''
self.test_addition_img_filepath = ''
self.test_img_name_list = ''
self.y_map = {}
def network(num_classes):
model = Sequential()
model.add(Dense(10, activation='relu', input_shape=(4, )))
model.add(Dense(20, activation='relu'))
model.add(Dense(10, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
return model
def load_codec(self, weights_prefix):
encoder_weight_filename = weights_prefix + "_encoder.h5"
decoder_weight_filename = weights_prefix + "_decoder.h5"
if not os.path.isfile(encoder_weight_filename):
raise Exception("The file for encoder weights does not exist:{}".format(encoder_weight_filename))
self.encoder.load_weights(encoder_weight_filename)
if not os.path.isfile(decoder_weight_filename):
raise Exception("The file for decoder weights does not exist:{}".format(decoder_weight_filename))
self.decoder.load_weights(decoder_weight_filename)
print("Encoder summaries")
self.encoder.summary()
_, encode_H, encode_W, numChannels = self.encoder.output_shape
config = self.decoder.get_config()
config2 = config[1::]
config2[0]['config']['batch_input_shape'] = (None, encode_H, encode_W, numChannels)
decoder_temp = Sequential.from_config(config2, custom_objects={"tf": tf})
# set weights
cnt = -1
for l in self.decoder.layers:
cnt += 1
if cnt == 0:
continue
weights = l.get_weights()
decoder_temp.layers[cnt - 1].set_weights(weights)
self.decoder = decoder_temp
print("Decoder summaries")
self.decoder.summary()
def generator(data_shape):
model = Sequential()
model.add(Dense(macro._LAYER_DIM, activation='relu', input_shape=(macro._NOISE_DIM+macro._PROP_DIM,)))
#model.add(Dropout(0.2))
model.add(Dense(2*macro._LAYER_DIM, activation='relu'))
#model.add(Dropout(0.2))
#model.add(Dense(3*macro._LAYER_DIM, activation='relu'))
#model.add(Dropout(0.2))
# use sigmoid function to constrain output from 0 to 1.
model.add(Dense(data_shape, activation='sigmoid'))
return model
def layer3_last(input_dim1,input_dim2,input_dim3,filt_num):
''' last layer : Conv - Relu - Conv '''
seq = Sequential()
for i in range(1):
seq.add(Conv2D(filt_num,(2,2), padding='valid',input_shape=(input_dim1, input_dim2, input_dim3), name='S3_c1%d' %(i) )) # pow(25/23,2)*12*(maybe7?) 43 3
seq.add(Activation('relu', name='S3_relu1%d' %(i)))
seq.add(Conv2D(1,(2,2), padding='valid', name='S3_last'))
return seq
def __init__(self):
self.model = Sequential()
self.model.add(
Conv2D(32, (3, 3), input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(pool_size=(2, 2)))
self.model.add(Conv2D(32, (3, 3)))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(pool_size=(2, 2)))
self.model.add(Conv2D(64, (3, 3)))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(pool_size=(2, 2)))
self.model.add(Flatten())
self.model.add(Dense(64))
self.model.add(Activation('relu'))
self.model.add(Dropout(0.5))
self.model.add(Dense(1))
self.model.add(Activation('sigmoid'))
def latent(data_shape):
model = Sequential()
model.add(Dense(mc._OUT_DIM, activation='relu', input_shape=(data_shape,),\
kernel_regularizer=regularizers.l2(mc._L2_REGULARIZE_RATE)))
model.add(Dense(mc._OUT_DIM, activation='relu', input_shape=(data_shape,),\
kernel_regularizer=regularizers.l2(mc._L2_REGULARIZE_RATE)))
return model
def __init__(self, img_size, img_channels=3, output_size=17):
self.losses = []
self.model = Sequential()
self.model.add(
BatchNormalization(input_shape=(img_size[0], img_size[1],
img_channels)))
self.model.add(Conv2D(32, (3, 3), padding='same', activation='relu'))
self.model.add(Conv2D(32, (3, 3), activation='relu'))
self.model.add(MaxPooling2D(pool_size=2))
self.model.add(Dropout(0.3))
self.model.add(Conv2D(64, (3, 3), padding='same', activation='relu'))
self.model.add(Conv2D(64, (3, 3), activation='relu'))
self.model.add(MaxPooling2D(pool_size=2))
self.model.add(Dropout(0.3))
self.model.add(Conv2D(128, (3, 3), padding='same', activation='relu'))
self.model.add(Conv2D(128, (3, 3), activation='relu'))
self.model.add(MaxPooling2D(pool_size=2))
self.model.add(Dropout(0.3))
self.model.add(Conv2D(256, (3, 3), padding='same', activation='relu'))
self.model.add(Conv2D(256, (3, 3), activation='relu'))
self.model.add(MaxPooling2D(pool_size=2))
self.model.add(Dropout(0.3))
self.model.add(Conv2D(512, (3, 3), padding='same', activation='relu'))
self.model.add(Conv2D(512, (3, 3), activation='relu'))
self.model.add(MaxPooling2D(pool_size=2))
self.model.add(Dropout(0.3))
self.model.add(Flatten())
self.model.add(Dense(512, activation='relu'))
self.model.add(BatchNormalization())
self.model.add(Dropout(0.5))
self.model.add(Dense(output_size, activation='sigmoid'))
def build_model(layers, pct_dropout=0.2):
"""Build computational graph model
Parameters
----------
layers: list | [input, hidden_1, hidden_2, output]
Dimensions of each layer
pct_dropout: float | 0.0 to 1.0
Percentage of dropout for hidden LSTM layers
Returns
-------
model: keras.Model
Compiled keras sequential model
"""
if not isinstance(layers, list):
raise TypeError('layers was expected to be of type %s, received %s' %
(type([]), type(layers)))
if len(layers) != 4:
raise ValueError('4 layer dimentions required, received only %d' %
len(layers))
model = Sequential()
model.add(
LSTM(layers[1],
input_shape=(layers[1], layers[0]),
return_sequences=True,
dropout=pct_dropout))
model.add(LSTM(layers[2], return_sequences=False, dropout=pct_dropout))
model.add(Dense(layers[3], activation='linear'))
start = time.time()
model.compile(loss="mse", optimizer="rmsprop")
print("> Compilation Time : ", time.time() - start)
return model
def layersP3_output(input_shape, filters_count):
seq = Sequential()
seq.add(Conv2D(filters_count, (2, 2),
padding='same',
input_shape=input_shape,
activation='relu',
name='seq3_conv1_0'))
seq.add(Conv2D(1, (2, 2), padding='same', name='seq3_last'))
return seq
def get_model(joint,
verts,
layers=3,
activation='tanh',
units=512,
input_dim=100):
"""
Build a training model based on the joint and vertices
:param joint: RotateTransform values of the joint
:param verts: Deltas of the vertices
:param layers: The number of layers to create. A minimum of 2 is required.
:param activation: The type of activation. Defaults to tanh
:param units: The units per layer if not the input/output
:param input_dim: The input dimensions of each layer that is not input/output
:return: The model, name of the input node, the name of the output_node
"""
model = Sequential()
if layers < 2:
logger.warning('A minimum of 2 layers is required')
layers = 2
input_name = 'input_node'
output_name = 'output_node'
for layer in range(layers):
if not layer:
model.add(
Dense(units,
input_dim=joint.shape[1],
activation=activation,
name=input_name))
continue
if layer == (layers - 1):
model.add(
Dense(verts.shape[1], activation='linear', name=output_name))
continue
model.add(
Dense(units,
input_dim=input_dim,
activation=activation,
name="dense_layer_%s" % layer))
output_node = model.output.name
input_node = '%s_input:0' % input_name
return model, input_node, output_node
def discriminator(data_shape):
model = Sequential()
model.add(Dense(2*macro._LAYER_DIM, activation='relu', input_shape=(data_shape,)))
#model.add(Dropout(0.2))
#model.add(Dense(3*macro._LAYER_DIM, activation='relu', input_shape=(data_shape,)))
#model.add(Dropout(0.2))
#model.add(Dense(2*macro._LAYER_DIM, activation='relu'))
#model.add(Dropout(0.2))
model.add(Dense(macro._LAYER_DIM, activation='relu'))
#model.add(Dropout(0.2))
return model
def layer2_merged(self, input_dim1, input_dim2, input_dim3, filt_num,
conv_depth):
''' Merged layer : Conv - Relu - Conv - BN - Relu '''
seq = Sequential()
for i in range(conv_depth):
(Conv2D(filt_num, (2, 2),
padding='valid',
input_shape=(input_dim1, input_dim2, input_dim3),
name='S2_c1%d' % (i)))
(Activation('relu', name='S2_relu1%d' % (i)))
(Conv2D(filt_num, (2, 2), padding='valid', name='S2_c2%d' % (i)))
(BatchNormalization(axis=-1, name='S2_BN%d' % (i)))
(Activation('relu', name='S2_relu2%d' % (i)))
return seq
def layer1_multistream(self, input_dim1, input_dim2, input_dim3, filt_num):
seq = Sequential()
''' Multi-Stream layer : Conv - Relu - Conv - BN - Relu '''
# (Reshape((input_dim1,input_dim12,input_dim3),input_shape=(input_dim1, input_dim2, input_dim3,1)))
for i in range(3):
(Conv2D(int(filt_num), (2, 2),
input_shape=(input_dim1, input_dim2, input_dim3),
padding='valid',
name='S1_c1%d' % (i)))
(Activation('relu', name='S1_relu1%d' % (i)))
(Conv2D(int(filt_num), (2, 2),
padding='valid',
name='S1_c2%d' % (i)))
(BatchNormalization(axis=-1, name='S1_BN%d' % (i)))
(Activation('relu', name='S1_relu2%d' % (i)))
(Reshape((input_dim1 - 6, input_dim2 - 6, int(filt_num))))
return seq
def layer1_multistream(input_dim1,
input_dim2,
input_dim3,
filt_num,
do_vis=False,
name=None):
seq = Sequential()
''' Multi-Stream layer : Conv - Relu - Conv - BN - Relu '''
if do_vis:
global feats
global feat_names
# seq.add(Reshape((input_dim1,input_dim12,input_dim3),input_shape=(input_dim1, input_dim2, input_dim3,1)))
for i in range(3):
seq.add(
Conv2D(int(filt_num), (2, 2),
input_shape=(input_dim1, input_dim2, input_dim3),
padding='valid',
name='S1_c1%d' % (i)))
seq.add(Activation('relu', name='S1_relu1%d' % (i)))
seq.add(
Conv2D(int(filt_num), (2, 2),
padding='valid',
name='S1_c2%d' % (i)))
seq.add(BatchNormalization(axis=-1, name='S1_BN%d' % (i)))
seq.add(Activation('relu', name='S1_relu2%d' % (i)))
if do_vis:
feats.append(seq)
feat_names.append(name + '_S1_c22')
seq.add(Reshape((input_dim1 - 6, input_dim2 - 6, int(filt_num))))
return seq
def __init__(self, restore = None, session=None, use_softmax=False, use_brelu = False, activation = "relu"):
def bounded_relu(x):
return K.relu(x, max_value=1)
if use_brelu:
activation = bounded_relu
print("inside MNISTModel: activation = {}".format(activation))
self.num_channels = 1
self.image_size = 28
self.num_labels = 10
model = Sequential()
model.add(Conv2D(32, (3, 3),
input_shape=(28, 28, 1)))
model.add(Activation(activation))
model.add(Conv2D(32, (3, 3)))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3, 3)))
model.add(Activation(activation))
model.add(Conv2D(64, (3, 3)))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(200))
model.add(Activation(activation))
model.add(Dense(200))
model.add(Activation(activation))
model.add(Dense(10))
# output log probability, used for black-box attack
if use_softmax:
model.add(Activation('softmax'))
if restore:
model.load_weights(restore)
layer_outputs = []
for layer in model.layers:
if isinstance(layer, Conv2D) or isinstance(layer, Dense):
layer_outputs.append(K.function([model.layers[0].input], [layer.output]))
self.model = model
self.layer_outputs = layer_outputs
def __init__(self, restore = None, session=None, use_softmax=False):
self.num_channels = 1
self.image_size = 28
self.num_labels = 10
self.shape = [None, 28, 28, self.num_channels]
model = Sequential()
kernel_size = (5, 5)
drop_rate = 0.3
model.add(Conv2D(32, kernel_size, activation='relu',
padding='same', name='block1_conv1', input_shape=(28,28,1))) # 1
model.add(MaxPooling2D(pool_size=(2, 2), name='block1_pool1')) # 2
model.add(Dropout(drop_rate))
# block2
model.add(Conv2D(64, kernel_size, activation='relu', padding='same', name='block2_conv1')) # 4
model.add(MaxPooling2D(pool_size=(2, 2), name='block2_pool1')) # 5
model.add(Dropout(drop_rate))
model.add(Flatten(name='flatten'))
model.add(Dense(120, activation='relu', name='fc1')) # -5
model.add(Dropout(drop_rate))
model.add(Dense(84, activation='relu', name='fc2')) # -3
model.add(Dense(10, name='before_softmax')) # -2
model.add(Activation('softmax', name='predictions')) #
if restore:
model.load_weights(restore)
layer_outputs = []
for layer in model.layers:
if isinstance(layer, Conv2D) or isinstance(layer, Dense):
layer_outputs.append(K.function([model.layers[0].input], [layer.output]))
self.layer_outputs = layer_outputs
self.model = model
def convert(file_name, new_name, cifar=False):
if not cifar:
eq_weights, new_params = get_weights(file_name)
data = MNIST()
else:
eq_weights, new_params = get_weights(file_name, inp_shape=(32, 32, 3))
data = CIFAR()
model = Sequential()
model.add(Flatten(input_shape=data.train_data.shape[1:]))
for param in new_params:
model.add(Dense(param))
model.add(Lambda(lambda x: tf.nn.relu(x)))
model.add(Dense(10))
for i in range(len(eq_weights)):
try:
print(eq_weights[i][0].shape)
except:
pass
model.layers[i].set_weights(eq_weights[i])
sgd = SGD(lr=0.01, decay=1e-5, momentum=0.9, nesterov=True)
model.compile(loss=fn, optimizer=sgd, metrics=['accuracy'])
model.save(new_name)
acc = model.evaluate(data.validation_data, data.validation_labels)[1]
printlog("Converting CNN to MLP")
nlayer = file_name.split('_')[-3][0]
filters = file_name.split('_')[-2]
kernel_size = file_name.split('_')[-1]
printlog(
"model name = {0}, numlayer = {1}, filters = {2}, kernel size = {3}".
format(file_name, nlayer, filters, kernel_size))
printlog("Model accuracy: {:.3f}".format(acc))
printlog("-----------------------------------")
return acc
def layer1_multistream(input_dim1, input_dim2, input_dim3, filt_num,
channelImage):
seq = Sequential()
''' Multi-Stream layer : Conv - Relu - Conv - BN - Relu '''
#seq.add(Reshape((input_dim1,input_dim2,input_dim3),input_shape=(input_dim1, input_dim2, input_dim3,1)))
for i in range(3):
#seq.add(Conv2D(int(filt_num),(2,2),input_shape=(input_dim1, input_dim2, input_dim3), padding='valid', name='S1_c1%d' %(i),data_format='channels_last' ))
seq.add(
Conv3D(int(filt_num), (2, 2, 2),
input_shape=(input_dim1, input_dim2, input_dim3,
channelImage),
padding='valid',
name='S1_c1%d' % (i),
data_format='channels_last'))
seq.add(Activation('relu', name='S1_relu1%d' % (i)))
seq.add(
Conv3D(int(filt_num), (2, 2, 2),
padding='valid',
name='S1_c2%d' % (i),
data_format='channels_last'))
seq.add(BatchNormalization(axis=-1, name='S1_BN%d' % (i)))
seq.add(Activation('relu', name='S1_relu2%d' % (i)))
#seq.add(Reshape((input_dim1-6,input_dim2-6,int(filt_num))))
return seq
def __init__(self, restore=None, session=None, use_log=False):
self.num_channels = 1
self.image_size = 28
self.num_labels = 10
model = Sequential()
model.add(Flatten(input_shape=(28, 28, 1)))
model.add(Dense(1024))
model.add(Lambda(lambda x: x * 10))
model.add(Activation('softplus'))
model.add(Lambda(lambda x: x * 0.1))
model.add(Dense(10))
# output log probability, used for black-box attack
if use_log:
model.add(Activation('softmax'))
if restore:
model.load_weights(restore)
layer_outputs = []
for layer in model.layers:
if isinstance(layer, Conv2D) or isinstance(layer, Dense):
layer_outputs.append(
K.function([model.layers[0].input], [layer.output]))
self.layer_outputs = layer_outputs
self.model = model
def __init__(self, restore=None, session=None, use_softmax=False):
self.num_channels = 1
self.image_size = 28
self.num_labels = 10
self.shape = [None, 28, 28, self.num_channels]
model = Sequential()
model.add(
Conv2D(6, (5, 5),
padding='valid',
activation='relu',
kernel_initializer='he_normal',
input_shape=(28, 28, 1),
name='l1'))
model.add(MaxPooling2D((2, 2), strides=(2, 2), name='l2'))
model.add(
Conv2D(16, (5, 5),
padding='valid',
activation='relu',
kernel_initializer='he_normal',
name='l3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2), name='l4'))
model.add(Flatten())
model.add(
Dense(120,
activation='relu',
kernel_initializer='he_normal',
name='l5'))
model.add(
Dense(84,
activation='relu',
kernel_initializer='he_normal',
name='l6'))
model.add(
Dense(10,
activation='softmax',
kernel_initializer='he_normal',
name='l7'))
if restore:
model.load_weights(restore)
layer_outputs = []
for layer in model.layers:
if isinstance(layer, Conv2D) or isinstance(layer, Dense):
layer_outputs.append(
K.function([model.layers[0].input], [layer.output]))
self.layer_outputs = layer_outputs
self.model = model
def onBeginTraining(self):
ue.log("starting mnist keras cnn training")
model_file_name = "mnistKerasCNN"
model_directory = ue.get_content_dir() + "/Scripts/"
model_sess_path = model_directory + model_file_name + ".tfsess"
model_json_path = model_directory + model_file_name + ".json"
my_file = Path(model_json_path)
#reset the session each time we get training calls
K.clear_session()
#let's train
batch_size = 128
num_classes = 10
epochs = 8
# input image dimensions
img_rows, img_cols = 28, 28
# the data, shuffled and split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
ue.log('x_train shape:' + str(x_train.shape))
ue.log(str(x_train.shape[0]) + 'train samples')
ue.log(str(x_test.shape[0]) + 'test samples')
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
model = Sequential()
model.add(Conv2D(64, kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
# model.add(Dropout(0.2))
# model.add(Flatten())
# model.add(Dense(512, activation='relu'))
# model.add(Dropout(0.2))
# model.add(Dense(num_classes, activation='softmax'))
#model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adadelta(),
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test),
callbacks=[self.stopcallback])
score = model.evaluate(x_test, y_test, verbose=0)
ue.log("mnist keras cnn training complete.")
ue.log('Test loss:' + str(score[0]))
ue.log('Test accuracy:' + str(score[1]))
self.session = K.get_session()
self.model = model
stored = {'model':model, 'session': self.session}
#run a test evaluation
ue.log(x_test.shape)
result_test = model.predict(np.reshape(x_test[500],(1,28,28,1)))
ue.log(result_test)
#flush the architecture model data to disk
#with open(model_json_path, "w") as json_file:
# json_file.write(model.to_json())
#flush the whole model and weights to disk
#saver = tf.train.Saver()
#save_path = saver.save(K.get_session(), model_sess_path)
#model.save(model_path)
return stored
def __init__(self):
self.losses = []
self.classifier = Sequential()
from tensorflow.contrib.keras.api.keras.layers import Activation
import tushare as ts
import numpy as np
import time
import matplotlib.pyplot as plt
def plot_results(predicted_data, true_data):
fig = plt.figure(facecolor='white')
ax = fig.add_subplot(111)
ax.plot(true_data, label='True Data')
plt.plot(predicted_data, label='Prediction')
plt.legend()
plt.show()
model = Sequential()
#if tf.gfile.Exists('./logs'):
# tf.gfile.Remove('./logs')
tbCallBack = keras.callbacks.TensorBoard(log_dir='./logs', histogram_freq=0,write_graph=True, write_images=True)
basetick = 30
pretick = 5
sh001 = ts.get_k_data("000001",index=True)
#print(sh001.head())
#train_x = sh001.iloc[:sh001.index.size-pretick-basetick,1:6]
#print(train_x.head())
train_x = []
train_y = []
for index in range(sh001.index.size-pretick-basetick):
#ty = sh001.iloc[index+basetick+pretick,3]-sh001.iloc[index+basetick,1]
ty = sh001.iloc[index+basetick+pretick,3]
#tx = sh001.iloc[index:index+basetick,1:6]
import numpy as np
np.random.seed(1337)
from jellyfish_eye_k.data_set import load_data
from tensorflow.contrib.keras.api.keras.layers import Conv2D, Dense, Dropout, Flatten, MaxPooling2D
from tensorflow.contrib.keras.api.keras.models import Sequential, save_model
(x_train, y_train), (x_validation, y_validation), (x_test, y_test) = load_data()
model = Sequential((
Conv2D(32, 5, activation='relu', input_shape=x_train[0].shape),
Conv2D(64, 5, activation='relu'),
MaxPooling2D(),
Dropout(0.5),
Flatten(),
Dense(512, activation='relu'),
Dense(256, activation='relu'),
Dropout(0.5),
Dense(3, activation='softmax')))
model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(x_train, y_train, batch_size=20, epochs=5, verbose=1, validation_data=(x_validation, y_validation))
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss: {0}'.format(score[0]))
print('Test accuracy: {0}'.format(score[1]))
save_model(model, './jellyfish_eye.h5')
del model
class AmazonKerasClassifier:
def __init__(self):
self.losses = []
self.classifier = Sequential()
def add_conv_layer(self, img_size=(32, 32), img_channels=3):
self.classifier.add(BatchNormalization(input_shape=(img_size, img_channels)))
self.classifier.add(Conv2D(32, (3, 3), padding='same', activation='relu'))
self.classifier.add(Conv2D(32, (3, 3), activation='relu'))
self.classifier.add(MaxPooling2D(pool_size=2))
self.classifier.add(Dropout(0.25))
self.classifier.add(Conv2D(64, (3, 3), padding='same', activation='relu'))
self.classifier.add(Conv2D(64, (3, 3), activation='relu'))
self.classifier.add(MaxPooling2D(pool_size=2))
self.classifier.add(Dropout(0.25))
self.classifier.add(Conv2D(128, (3, 3), padding='same', activation='relu'))
self.classifier.add(Conv2D(128, (3, 3), activation='relu'))
self.classifier.add(MaxPooling2D(pool_size=2))
self.classifier.add(Dropout(0.25))
self.classifier.add(Conv2D(256, (3, 3), padding='same', activation='relu'))
self.classifier.add(Conv2D(256, (3, 3), activation='relu'))
self.classifier.add(MaxPooling2D(pool_size=2))
self.classifier.add(Dropout(0.25))
def add_flatten_layer(self):
self.classifier.add(Flatten())
def add_ann_layer(self, output_size):
self.classifier.add(Dense(512, activation='relu'))
self.classifier.add(BatchNormalization())
self.classifier.add(Dropout(0.5))
self.classifier.add(Dense(output_size, activation='sigmoid'))
def _get_fbeta_score(self, classifier, X_valid, y_valid):
p_valid = classifier.predict(X_valid)
return fbeta_score(y_valid, np.array(p_valid) > 0.2, beta=2, average='samples')
def train_model(self, x_train, y_train, learn_rate=0.001, epoch=5, batch_size=128, validation_split_size=0.2, train_callbacks=()):
history = LossHistory()
X_train, X_valid, y_train, y_valid = train_test_split(x_train, y_train,
test_size=validation_split_size)
opt = Adam(lr=learn_rate)
self.classifier.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])
# early stopping will auto-stop training process if model stops learning after 3 epochs
earlyStopping = EarlyStopping(monitor='val_loss', patience=3, verbose=0, mode='auto')
self.classifier.fit(X_train, y_train,
batch_size=batch_size,
epochs=epoch,
verbose=1,
validation_data=(X_valid, y_valid),
callbacks=[history, *train_callbacks, earlyStopping])
fbeta_score = self._get_fbeta_score(self.classifier, X_valid, y_valid)
return [history.train_losses, history.val_losses, fbeta_score]
def save_weights(self, weight_file_path):
self.classifier.save_weights(weight_file_path)
def load_weights(self, weight_file_path):
self.classifier.load_weights(weight_file_path)
def predict(self, x_test):
predictions = self.classifier.predict(x_test)
return predictions
def map_predictions(self, predictions, labels_map, thresholds):
"""
Return the predictions mapped to their labels
:param predictions: the predictions from the predict() method
:param labels_map: the map
:param thresholds: The threshold of each class to be considered as existing or not existing
:return: the predictions list mapped to their labels
"""
predictions_labels = []
for prediction in predictions:
labels = [labels_map[i] for i, value in enumerate(prediction) if value > thresholds[i]]
predictions_labels.append(labels)
return predictions_labels
def close(self):
backend.clear_session()
X_train.append(training_set_scaled[i - 60:i, 0])
y_train.append(training_set_scaled[i, 0])
X_train, y_train = np.array(X_train), np.array(y_train)
# Reshaping
X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))
# Part 2 - Building the RNN
# Importing the Keras libraries and packages
from tensorflow.contrib.keras.api.keras.models import Sequential
from tensorflow.contrib.keras.api.keras.layers import Dense
from tensorflow.contrib.keras.api.keras.layers import LSTM
# Initialising the RNN
regressor = Sequential()
# Adding the input layer and the LSTM layer
regressor.add(LSTM(units=3, return_sequences=True, input_shape=(None, 1)))
# Adding a second LSTM layer
regressor.add(LSTM(units=3, return_sequences=True))
# Adding a third LSTM layer
regressor.add(LSTM(units=3, return_sequences=True))
# Adding a fourth LSTM layer
regressor.add(LSTM(units=3))
# Adding the output layer
regressor.add(Dense(units=1))
# Load the data, shuffled and split between train and test sets
data = mnist.load_data({'dataset': {}})
x_train = data['x_train']
y_train = data['y_train']
x_test = data['x_test']
y_test = data['y_test']
# Bring data into necessary format
x_train = mnist.preprocess(x_train, subtact_mean=False)
x_test = mnist.preprocess(x_test, subtact_mean=False)
y_train = mnist.to_categorical(y_train, mnist.n_classes)
y_test = mnist.to_categorical(y_test, mnist.n_classes)
# Define model
input_shape = (mnist.img_rows, mnist.img_cols, 1)
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), activation='relu',
input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(mnist.n_classes, activation='softmax'))
# Fit model
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adam(),
metrics=['accuracy'])
model.fit(x_train, y_train,
