def compute(self, config, budget, **kwargs):
"""
Evaluates the configuration on the defined budget and returns the validation performance.
Args:
config: dictionary containing the sampled configurations by the optimizer
budget: (float) amount of time/epochs/etc. the model can use to train
Returns:
dictionary with mandatory fields:
'loss' (scalar)
'info' (dict)
"""
lr = config["learning_rate"]
num_filters = config["num_filters"]
batch_size = config["batch_size"]
filter_size = config["filter_size"]
epochs = budget
# TODO: train and validate your convolutional neural networks here
# <JAB>
# Define the model
model = Sequential()
model.add(
Conv2D(num_filters,
kernel_size=filter_size,
activation='relu',
input_shape=(28, 28, 1),
padding='same'))
model.add(MaxPooling2D(pool_size=2))
model.add(
Conv2D(num_filters,
kernel_size=filter_size,
activation='relu',
padding='same'))
model.add(MaxPooling2D(pool_size=2))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(10, activation='softmax'))
optimizer = SGD(lr=lr)
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy'])
model.summary()
# Train the Model
print('\n\n*Starting Training:')
train_his = model.fit(self.x_train,
self.y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(self.x_test, self.y_test),
verbose=2,
use_multiprocessing=True)
#print('\n\n*Training Evaluation:')
#train_score = model.evaluate(self.x_train, self.y_train, verbose=0)
print('\n\n*Validation Evaluation:')
val_score = model.evaluate(self.x_valid, self.y_valid, verbose=0)
print('\n\n*Test Evaluation:')
test_score = model.evaluate(self.x_test, self.y_test, verbose=0)
# </JAB>
# TODO: We minimize so make sure you return the validation error here
from tensorflow.keras.initializers import glorot_uniform # Or your initializer of choice
initial_weights = model.get_weights()
new_weights = [
glorot_uniform()(w.shape).eval() for w in initial_weights
]
model.set_weights(new_weights)
return ({
'loss':
val_score[0], # this is the a mandatory field to run hyperband
'info': {
'fit_lc': train_his.history,
'test_score': test_score
} # can be used for any user-defined information - also mandatory
})
def Model_RNN3(input_shape,
classes,
n_pool='average',
n_l2=0.001,
n_init='he_normal',
**kwargs):
name = kwargs.get("name", 'AtzoriNet2')
base_channel = kwargs.get("base_channel", 64)
if n_init == 'glorot_normal':
kernel_init = initializers.glorot_normal(seed=0)
elif n_init == 'glorot_uniform':
kernel_init = initializers.glorot_uniform(seed=0)
elif n_init == 'he_normal':
kernel_init = initializers.he_normal(seed=0)
elif n_init == 'he_uniform':
kernel_init = initializers.x(seed=0)
elif n_init == 'normal':
kernel_init = initializers.normal(seed=0)
elif n_init == 'uniform':
kernel_init = initializers.uniform(seed=0)
# kernel_init = n_init
kernel_regl = regularizers.l2(n_l2)
## Block 0 [Input]
X_input = Input(input_shape, name='b0_input')
X = X_input
chanel = base_channel
################################################################
# X=AveragePooling2D((3,1),strides=(1,1),padding='same')(X)
X = ZeroPadding2D((0, 1))(X)
X = Conv2D(chanel, (1, 3),
padding='valid',
kernel_regularizer=kernel_regl,
kernel_initializer=kernel_init,
name='b{}_conv2d_1_3x3'.format(1))(X)
X = LayerNormalization()(X)
X = Activation('relu', name='b{}_relu1'.format(1))(X)
chanel = chanel * 2
X = ZeroPadding2D((0, 1))(X) # （8,8)
X = Conv2D(chanel, (1, 3),
strides=(1, 2),
padding='valid',
kernel_regularizer=kernel_regl,
kernel_initializer=kernel_init,
name='b{}_conv2d_2_3x3'.format(1))(X)
X = LayerNormalization()(X)
X = Activation('relu', name='b{}_relu2'.format(1))(X)
################################################################
# CNN to RNN
inner = Reshape(target_shape=((60, chanel * 4)),
name='reshape')(X) # (None, 64, 384)
inner = Dense(512,
activation='relu',
kernel_initializer='he_normal',
name='dense1')(inner) # (None, 60, 384)
################################################################
# RNN layer
gru_1 = LSTM(256,
return_sequences=True,
kernel_initializer='he_normal',
name='gru1')(inner) # (None, 60, 512)
gru_1b = LSTM(256,
return_sequences=True,
go_backwards=True,
kernel_initializer='he_normal',
name='gru1_b')(inner)
# reversed_gru_1b = Lambda(lambda inputTensor: tf.reverse(inputTensor, axes=1))(gru_1b)
reversed_gru_1b = tf.reverse(gru_1b, axis=[1])
gru1_merged = add([gru_1, reversed_gru_1b]) # (None, 60, 512)
gru1_merged = LayerNormalization()(gru1_merged)
gru_2 = LSTM(256,
return_sequences=True,
kernel_initializer='he_normal',
name='gru2')(gru1_merged)
gru_2b = LSTM(256,
return_sequences=True,
go_backwards=True,
kernel_initializer='he_normal',
name='gru2_b')(gru1_merged)
# reversed_gru_2b = Lambda(lambda inputTensor: tf.reverse(inputTensor, axes=1))(gru_2b)
reversed_gru_2b = tf.reverse(gru_2b, axis=[1])
gru2_merged = concatenate([gru_2, reversed_gru_2b]) # (None, 60, 1024)
X = gru2_merged
################################################################
# X = BatchNormalization()(X)
X = GlobalAveragePooling1D()(X)
X = Dropout(0.5)(X)
## Block 5 [Pad -> Conv -> Softmax]
X = Dense(classes, activation="softmax")(X)
model = Model(
inputs=X_input,
outputs=X,
name=name,
)
return model
#scaler = StandardScaler()
#scaler1 = scaler.fit(y1_train)
#y1_train = scaler.transform(y1_train)
#y1_test = scaler.transform(y1_test)
#sc = StandardScaler()
#sc = scaler.fit(y2_train)
#y2_train = sc.transform(y2_train)
#y2_test = sc.transform(y2_test)
my_init=glorot_uniform(seed=42)
def MT_model(perm):
#def funx1(i,maxL):
#if i<maxL:
#return Input(shape=(fpSize,),name=f"MRg_{i}")
#elif i<2*maxL-3 and i!=maxL+2:
# elif maxL<=i< 2*maxL:
#return Input(shape=(FpLen,),name=f"Ml_{i}")
#else:
# return Input(shape=(FpLen1,),name=f"Sq_{i}")
def convolutional_block(X, f, filters, stage, block, s=2):
"""
Implementation of the convolutional block as defined in Figure 4
Arguments:
X -- input tensor of shape (m, n_H_prev, n_W_prev, n_C_prev)
f -- integer, specifying the shape of the middle CONV's window for the main path
filters -- python list of integers, defining the number of filters in the CONV layers of the main path
stage -- integer, used to name the layers, depending on their position in the network
block -- string/character, used to name the layers, depending on their position in the network
s -- Integer, specifying the stride to be used
Returns:
X -- output of the convolutional block, tensor of shape (n_H, n_W, n_C)
"""
# defining name basis
conv_name_base = 'res' + str(stage) + block + '_branch'
bn_name_base = 'bn' + str(stage) + block + '_branch'
# Retrieve Filters
F1, F2, F3 = filters
# Save the input value
X_shortcut = X
##### MAIN PATH #####
# First component of main path
X = Conv2D(F1, (1, 1),
strides=(s, s),
name=conv_name_base + '2a',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3, name=bn_name_base + '2a')(X)
X = Activation('relu')(X)
# Second component of main path (≈3 lines)
X = Conv2D(filters=F2,
kernel_size=(f, f),
strides=(1, 1),
padding='same',
name=conv_name_base + '2b',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3, name=bn_name_base + '2b')(X)
X = Activation('relu')(X)
# Third component of main path (≈2 lines)
X = Conv2D(filters=F3,
kernel_size=(1, 1),
strides=(1, 1),
padding='valid',
name=conv_name_base + '2c',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3, name=bn_name_base + '2c')(X)
##### SHORTCUT PATH #### (≈2 lines)
X_shortcut = Conv2D(filters=F3,
kernel_size=(1, 1),
strides=(s, s),
padding='valid',
name=conv_name_base + '1',
kernel_initializer=glorot_uniform(seed=0))(X_shortcut)
X_shortcut = BatchNormalization(axis=3,
name=bn_name_base + '1')(X_shortcut)
# Final step: Add shortcut value to main path, and pass it through a RELU activation (≈2 lines)
X = Add()([X, X_shortcut])
X = Activation('relu')(X)
return X
#==================================================================
#******************** Learning **********************************
#==================================================================
# Importing the Keras libraries and packages
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras import losses
from tensorflow.keras import optimizers
import tensorflow.keras.initializers as init
# Initialising the ANN
reg = Sequential()
reg.add(
Dense(units=128,
kernel_initializer=init.glorot_uniform(),
activation='relu',
input_dim=5))
reg.add(
Dense(units=256,
kernel_initializer=init.glorot_uniform(),
activation='relu'))
reg.add(
Dense(units=512,
kernel_initializer=init.glorot_uniform(),
activation='relu'))
reg.add(
Dense(units=128,
kernel_initializer=init.glorot_uniform(),
activation='relu'))
reg.add(
def STN(model_params, input_shape=(53, 52, 63, 53), output_shape=1):
'''Build the CNN model
model_params: dict with the architecture parameters
convFilt: list with number of filters in each layer
dropout: dropout before the last dense layer
l2: weights decay regularization parameter (L2)
optlr: learning rate
optType: 0 = Nadam, 1 = Adamax, 2 = SGD, 3 = Adam, 4 = Nadam
optMom: momentum rate
input_shape: tuple, the shape of the input volume
output_shape: integer, # of output neurons
'''
def convolutional_block(X, filters, stage, s=2, weight_decay=0.001):
# defining name basis
conv_name_base = 'conv_' + stage
bn_name_base = 'bn_' + stage
# First component of main path
X = Conv3D(filters, (3, 3, 3),
strides=(1, 1, 1),
name=conv_name_base + '_1',
kernel_initializer=glorot_uniform(seed=0),
kernel_regularizer=regularizers.l2(weight_decay))(X)
X = BatchNormalization(name=bn_name_base + '_1')(X)
X = Activation('relu')(X)
X = Conv3D(filters, (3, 3, 3),
strides=(s, s, s),
name=conv_name_base + '_2',
kernel_initializer=glorot_uniform(seed=0),
kernel_regularizer=regularizers.l2(weight_decay))(X)
X = BatchNormalization(name=bn_name_base + '_2')(X)
X = Activation('relu')(X)
return X
filters = model_params.get('convFilt')
weight_decay = model_params.get('l2')
optType, optlr, optMom = model_params.get('optType'), model_params.get(
'optlr'), model_params.get('optMom')
Optm = OptimTypeFunc(optType, optlr, optMom)
X_input = Input(shape=input_shape)
X = Conv3D(filters[0], (1, 1, 1),
name='conv3D_first_reduce_channels',
kernel_initializer=glorot_uniform(seed=0),
kernel_regularizer=regularizers.l2(weight_decay))(X_input)
X = BatchNormalization(name='bn_f_reduce_channels')(X)
X = Activation('relu')(X)
X = convolutional_block(X,
filters=filters[1],
stage='a',
weight_decay=weight_decay)
X = convolutional_block(X,
filters=filters[2],
stage='b',
weight_decay=weight_decay)
X = Conv3D(filters[4], (1, 1, 1),
name='conv3D_second_reduce_channels',
kernel_initializer=glorot_uniform(seed=0),
kernel_regularizer=regularizers.l2(weight_decay))(X)
X = BatchNormalization(name='bn_s_reduce_channels')(X)
X = Activation('relu')(X)
X = Flatten()(X)
X = Dropout(model_params.get('dropout'))(X)
final_pred = Dense(output_shape)(X)
model = Model(inputs=X_input, outputs=final_pred, name='SFCN')
model.compile(loss=['mse'],
optimizer=Optm,
metrics=['mean_absolute_error', 'mse'])
model.summary()
return model
def res_block(X, filter, stage):
# Convolutional_block
X_copy = X
f1, f2, f3 = filter
# Main Path
X = Conv2D(f1, (1, 1),
strides=(1, 1),
name='res_' + str(stage) + '_conv_a',
kernel_initializer=glorot_uniform(seed=0))(X)
X = MaxPool2D((2, 2))(X)
X = BatchNormalization(axis=3, name='bn_' + str(stage) + '_conv_a')(X)
X = Activation('relu')(X)
X = Conv2D(f2,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
name='res_' + str(stage) + '_conv_b',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3, name='bn_' + str(stage) + '_conv_b')(X)
X = Activation('relu')(X)
X = Conv2D(f3,
kernel_size=(1, 1),
strides=(1, 1),
name='res_' + str(stage) + '_conv_c',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3, name='bn_' + str(stage) + '_conv_c')(X)
# Short path
X_copy = Conv2D(f3,
kernel_size=(1, 1),
strides=(1, 1),
name='res_' + str(stage) + '_conv_copy',
kernel_initializer=glorot_uniform(seed=0))(X_copy)
X_copy = MaxPool2D((2, 2))(X_copy)
X_copy = BatchNormalization(axis=3,
name='bn_' + str(stage) + '_conv_copy')(X_copy)
# ADD
X = Add()([X, X_copy])
X = Activation('relu')(X)
# Identity Block 1
X_copy = X
# Main Path
X = Conv2D(f1, (1, 1),
strides=(1, 1),
name='res_' + str(stage) + '_identity_1_a',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3,
name='bn_' + str(stage) + '_identity_1_a')(X)
X = Activation('relu')(X)
X = Conv2D(f2,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
name='res_' + str(stage) + '_identity_1_b',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3,
name='bn_' + str(stage) + '_identity_1_b')(X)
X = Activation('relu')(X)
X = Conv2D(f3,
kernel_size=(1, 1),
strides=(1, 1),
name='res_' + str(stage) + '_identity_1_c',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3,
name='bn_' + str(stage) + '_identity_1_c')(X)
# ADD
X = Add()([X, X_copy])
X = Activation('relu')(X)
# Identity Block 2
X_copy = X
# Main Path
X = Conv2D(f1, (1, 1),
strides=(1, 1),
name='res_' + str(stage) + '_identity_2_a',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3,
name='bn_' + str(stage) + '_identity_2_a')(X)
X = Activation('relu')(X)
X = Conv2D(f2,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
name='res_' + str(stage) + '_identity_2_b',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3,
name='bn_' + str(stage) + '_identity_2_b')(X)
X = Activation('relu')(X)
X = Conv2D(f3,
kernel_size=(1, 1),
strides=(1, 1),
name='res_' + str(stage) + '_identity_2_c',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3,
name='bn_' + str(stage) + '_identity_2_c')(X)
# ADD
X = Add()([X, X_copy])
X = Activation('relu')(X)
return X
def ResNet(input_shape, classes):
_input = Input(shape=input_shape)
res = ZeroPadding2D([3, 3])(_input)
# stage 1
res = Conv2D(filters=64,
kernel_size=(7, 7),
strides=(2, 2),
name="res_stage_1_conv",
kernel_initializer=glorot_uniform(seed=0))(res)
res = BatchNormalization(axis=3, name="res_stage_1_BN")(res)
res = Activation('relu')(res)
res = MaxPooling2D((3, 3), strides=(2, 2))(res)
# stage 2
res = conv_block(input_tensor=res,
kernel_size=3,
filters=[64, 64, 256],
stride=1,
stage="2a")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[64, 64, 256],
stage="2b")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[64, 64, 256],
stage="2c")
# stage 3
res = conv_block(input_tensor=res,
kernel_size=3,
filters=[128, 128, 512],
stride=2,
stage="3a")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[128, 128, 512],
stage="3b")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[128, 128, 512],
stage="3c")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[128, 128, 512],
stage="3d")
# stage 4
res = conv_block(input_tensor=res,
kernel_size=3,
filters=[256, 256, 1024],
stride=2,
stage="4a")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[256, 256, 1024],
stage="4b")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[256, 256, 1024],
stage="4c")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[256, 256, 1024],
stage="4d")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[256, 256, 1024],
stage="4e")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[256, 256, 1024],
stage="4f")
# stage 5
res = conv_block(input_tensor=res,
kernel_size=3,
filters=[512, 512, 2048],
stride=2,
stage="5a")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[512, 512, 2048],
stage="5b")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[512, 512, 2048],
stage="5c")
res = AveragePooling2D(pool_size=(2, 2), padding='same')(res)
res = Flatten()(res)
res = Dense(classes,
activation='softmax',
name='output_fc_layer',
kernel_initializer=glorot_uniform(seed=0))(res)
model = Model(inputs=_input, outputs=res, name='ResNet')
return model
def create_model(x_train, y_train, x_test, y_test):
"""
Function to create the ML model
"""
# Define input size for first layer
in_size = (64, 64, 1)
# Define number of classes predicted
out_classes = 2
# Define a sequential model so we can quickly make a model by adding layers to the API
model = tf.keras.Sequential()
# Convolve input once
L1 = layers.Conv2D(
filters=32,
kernel_size=(4, 4),
strides=[2, 2],
input_shape=in_size,
activation='relu',
kernel_initializer=initializers.glorot_uniform(seed=None),
padding='same',
kernel_regularizer=regularizers.l2(0.01))
model.add(L1)
# Convolve input again
L2 = layers.Conv2D(
filters=16,
kernel_size=(2, 2),
strides=[2, 2],
input_shape=in_size,
activation='relu',
kernel_initializer=initializers.glorot_uniform(seed=None),
padding='same',
kernel_regularizer=regularizers.l2(0.01))
model.add(L2)
# Pool the convolutions and extract important parts
P1 = layers.MaxPooling2D(pool_size=3,
strides=2,
padding='valid',
name="P1")
model.add(P1)
# Flatten the pooled layer
F = layers.Flatten(name="flatten")
model.add(F)
# Add dropout to the flattened layers to generalize better
dO = layers.Dropout(0.01)
model.add(dO)
# First dense layer
D1 = layers.Dense(
256,
activation='relu',
name='D1',
kernel_initializer=initializers.glorot_uniform(seed=None),
kernel_regularizer=regularizers.l2(0.01))
model.add(D1)
# Output layer
D2 = layers.Dense(out_classes, activation='softmax', name='D2')
model.add(D2)
# Output the structure of the model
model.summary()
model.compile(loss='categorical_crossentropy',
metrics=['accuracy'],
optimizer=optimizers.Adam(lr=0.00001))
# 1000 is a lot but since the initialization might different at all times. 1000 guarantees convergence
result = model.fit(train_x,
train_y,
epochs=1000,
verbose=2,
validation_data=(test_x, test_y))
# Store model after training acoording to time it was made
filepath = "./models/model-" + str(time.time()) + ".h5"
tf.keras.models.save_model(model,
filepath,
overwrite=True,
include_optimizer=True)
ANN_top10 = []
cmap = plt.set_cmap('cividis')
cNorm = mpl.colors.Normalize(vmin=-7, vmax=-1)
for m in modellist:
#read in model files
ANN_list = []
foldername = m.split('/')[-1]
for i in range(fold):
json_file = open(m + '/' + 'model_' + str(i) + '.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
ANN = model_from_json(
loaded_model_json,
custom_objects={'GlorotUniform': glorot_uniform()})
ANN.load_weights(workinghome + '/' + foldername + '/' + 'model_' +
str(i) + '.h5')
ANN_test_predicted = ANN.predict(x_test_scale)
ANN_list.append(ANN)
# setup_curves_compare(site, scaler, workinghome, foldername, siteparams, ANN_list, vref, pre_scatter = np.asarray([0]), obs_scatter = np.asarray([0]), dist_scatter = np.asarray([0]), mag_scatter = np.asarray([0]))
ANN_top10.append(ANN_list) #the 5 fold models
mlist = np.linspace(2.8, 5.0, 200)
Rlist = np.linspace(10., 225., 200)
X, Y = np.meshgrid(Rlist, mlist)
Z = np.zeros((len(X), len(Y)))
for i in range(len(X)):
if site == '5coeff':
d = {'mw': Y[i][0], 'R': X[i]}
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
from keras.metrics import Recall
from keras_preprocessing.image import ImageDataGenerator
from configuration import image_directory, augmented_image_directory, \
training_images_list_filename, training_augmented_sample_list_filename, \
validation_images_list_filename, \
class_map, num_classes, model_filename_first
#%% ---------------------------------------- Set-Up --------------------------------------------------------------------
SEED = 42
os.environ['PYTHONHASHSEED'] = str(SEED)
random.seed(SEED)
np.random.seed(SEED)
tf.random.set_seed(SEED)
weight_init = glorot_uniform(seed=SEED)
#%%
train_df = pd.read_csv(training_images_list_filename)
test_df = pd.read_csv(validation_images_list_filename)
datagen = ImageDataGenerator(rescale=1. / 255., validation_split=0.25)
train_generator = datagen.flow_from_dataframe(dataframe=train_df,
directory=None,
x_col="name",
y_col="class",
subset="training",
batch_size=32,
seed=42,
shuffle=True,
def result():
'''
Load model and vectorizer
'''
print("JUMP TO PREDICT!!!")
getfile = "file.wav"
juice = sr.AudioFile(getfile)
with juice as source:
audio = r.record(source)
text = r.recognize_google(audio)
print("TRANSCRIPTION IS: ", text)
# load VAD text models
model_val = joblib.load('model_text_valence_iemocap.pkl')
model_act = joblib.load('model_text_activation_iemocap.pkl')
model_dom = joblib.load('model_text_dominance_iemocap.pkl')
vect_file = joblib.load('vect_obj_iemocap.pkl')
# munge text
message = clean_lemma(text)
message = vect_file.transform(message).toarray()
# Text predictions
predictions_V = model_val.predict(message)
predictions_A = model_act.predict(message)
predictions_D = model_dom.predict(message)
# trigger functions to read wav, munge it and predict VAD from audio
# List to store lpms matrices
wav_samples = []
# get datapoints and sample rate of file and load it
samples, sar = lib.load(getfile, sr=None)
silence_stripped = strip_silence(samples)
lpms_ified = convert_to_lpms(silence_stripped)
chunk_scale_lpms_matrix(lpms_ified, wav_samples)
# model_audio = keras.models.load_model('model_audio_iemocap_v2.h5')
with CustomObjectScope({'GlorotUniform': glorot_uniform()}):
model_audio = load_model('model_audio_iemocap_v2.h5')
print("Loaded model from disk")
# As wav_samples is a list I can't use array indexing on it
# convert to ndarray
wav_samples = np.array(wav_samples)
print("wav_samples length: ", len(wav_samples))
print("wav_samples type: ", type(wav_samples))
nRows, nCols, nDims = 20, 25, 1
wav_samples = wav_samples.reshape(wav_samples.shape[0], nRows, nCols, nDims)
print("RESHAPED wav_samples: ", wav_samples.shape)
# Step through each 0.4 sec chunk and make a prediction, store it
audio_predictions = model_audio.predict(wav_samples, batch_size=32, verbose=2)
print("Predictions list length: ", len(audio_predictions))
print("Predictions slot[0] length: ", len(audio_predictions[0]))
# Calculate the mean of each prediction
audio_pred_val = audio_predictions[:, 0].mean()
audio_pred_act = audio_predictions[:, 1].mean()
audio_pred_dom = audio_predictions[:, 2].mean()
print("Length of frame data: ", len(audio.frame_data))
print("File sample_rate: ", audio.sample_rate)
print(predictions_V, audio_pred_val)
print(predictions_A, audio_pred_act)
print(predictions_D, audio_pred_dom)
text_ = [str(text)]
# Provide predictions to results page
return render_template('result.html', # was result.html
pred_words=text_,
pred_V=predictions_V,
pred_A=predictions_A,
pred_D=predictions_D,
pred_Vaud=audio_pred_val,
pred_Aaud=audio_pred_act,
pred_Daud=audio_pred_dom)
def train_classifier_nn():
feature_set = pickle.load(open(FSETDIR, "rb"))
label_set = pickle.load(open(LSETDIR, "rb"))
num_of_classes = len(CATEGORIES)
#label_set = to_categorical(label_set)
# Scale (normalize) data
feature_set = feature_set/255.0
# Build CNN model
model = Sequential()
# Conv2D, 64 filters, 3x3 filter size, same input size as images
model.add(Conv2D(4, (3,3), input_shape = feature_set.shape[1:]))
# Activation layer, rectify linear activation
model.add(Activation("relu"))
# Pooling layer, max pooling2D
model.add(MaxPooling2D(pool_size=(3,3), strides=(2,2)))
model.add(Conv2D(4, (3,3), input_shape = feature_set.shape[1:]))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(3,3), strides=(2,2)))
# Dense layer, requires 1D input so flatten the dataset first
model.add(Flatten())
model.add(Dense(64))
model.add(Activation("relu"))
# Output layer, no activation function
model.add(Dense(num_of_classes))
model.compile(loss="sparse_categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
best_accuracy = 0.0
for i in range(0,10):
# First of all, randomize weights (reinitialize the model)
initial_weights = model.get_weights()
backend_name = keras_backend.backend()
if backend_name == 'tensorflow':
k_eval = lambda placeholder: placeholder.eval(session=keras_backend.get_session())
elif backend_name == 'theano':
k_eval = lambda placeholder: placeholder.eval()
else:
raise ValueError("Unsupported backend")
new_weights = [k_eval(glorot_uniform()(w.shape)) for w in initial_weights]
model.set_weights(new_weights)
# Fit the model to the training data
# Note: model will converge nicely after 10 epochs, use that or more in the final program
result = model.fit(feature_set, label_set, batch_size=32, epochs=15, validation_split=0.1)
accuracy = result.history["acc"][-1]
if accuracy > best_accuracy:
# Save model if we beat our best accuracy
model.save("{}classifier-CNN.model".format(MODELDIR))
best_accuracy = accuracy
print("Save classification model with best accuracy: {}".format(best_accuracy))
def Model_beta1(input_shape,
classes,
n_pool='average',
n_l2=0.001,
n_init='glorot_normal',
**kwargs):
"""
Arguments:
input_shape -- tuple, dimensions of the input in the form (height, width, channels)
classes -- integer, number of classes to be classified, defines the dimension of the softmax unit
n_pool -- string, pool method to be used {'max', 'average'}
n_dropout -- float, rate of dropping units
n_l2 -- float, ampunt of weight decay regularization
n_init -- string, type of kernel initializer {'glorot_normal', 'glorot_uniform', 'he_normal', 'he_uniform', 'normal', 'uniform'}
batch_norm -- boolean, whether BatchNormalization is applied to the input
Returns:
model -- keras.models.Model (https://keras.io)
"""
with_NL = kwargs.get("with_NL", False)
name = kwargs.get("name", 'AtzoriNet2')
base_channel = kwargs.get("base_channel", 64)
activation = kwargs.get("activation", "relu")
if n_init == 'glorot_normal':
kernel_init = initializers.glorot_normal(seed=0)
elif n_init == 'glorot_uniform':
kernel_init = initializers.glorot_uniform(seed=0)
elif n_init == 'he_normal':
kernel_init = initializers.he_normal(seed=0)
elif n_init == 'he_uniform':
kernel_init = initializers.he_uniform(seed=0)
elif n_init == 'normal':
kernel_init = initializers.normal(seed=0)
elif n_init == 'uniform':
kernel_init = initializers.uniform(seed=0)
# kernel_init = n_init
kernel_regl = regularizers.l2(n_l2)
# kernel_regl = regularizers.l1(n_l2)
## Block 0 [Input]
X_input = Input(input_shape, name='b0_input')
X = X_input
chanel = base_channel
################################################################
X = ZeroPadding2D((1, 1))(X)
X = Conv2D(chanel, (1, 5),
padding='valid',
kernel_regularizer=kernel_regl,
kernel_initializer=kernel_init,
name='b{}_conv2d_1_3x3'.format(1))(X)
X = BatchNormalization()(X)
X = Activation(activation, name='b{}_relu1'.format(1))(X)
chanel = chanel * 2
X = ZeroPadding2D((1, 1))(X) # （8,8)
X = Conv2D(chanel, (1, 5),
strides=(1, 2),
padding='valid',
kernel_regularizer=kernel_regl,
kernel_initializer=kernel_init,
name='b{}_conv2d_2_3x3'.format(1))(X)
X = BatchNormalization()(X)
X = Activation(activation, name='b{}_relu2'.format(1))(X)
chanel = chanel * 2
################################################################
X = ZeroPadding2D((1, 1))(X)
X = Conv2D(chanel, (5, 3),
padding='valid',
kernel_regularizer=kernel_regl,
kernel_initializer=kernel_init,
name='b{}_conv2d_1_3x3'.format(2))(X)
X = BatchNormalization()(X)
X = Activation(activation, name='b{}_relu1'.format(2))(X)
chanel = chanel * 2
X = ZeroPadding2D((1, 1))(X) # （8,8)
X = Conv2D(chanel, (5, 3),
strides=(2, 2),
padding='valid',
kernel_regularizer=kernel_regl,
kernel_initializer=kernel_init,
name='b{}_conv2d_2_3x3'.format(2))(X)
X = BatchNormalization()(X)
X = Activation(activation, name='b{}_relu2'.format(2))(X)
X = GlobalAveragePooling2D()(X)
X = Dropout(0.5)(X)
## Block 5 [Pad -> Conv -> Softmax]
X = Dense(classes, activation="softmax")(X)
model = Model(
inputs=X_input,
outputs=X,
name=name,
)
return model
def model(datagen, X_train, y_train, X_val, y_val):
inputs = Input(shape=(128,128,3))
x = Convolution2D(48, (3, 3), padding='same', activation='relu')(inputs)
x = MaxPooling2D(pool_size=(2,2))(x)
x = Dropout({{uniform(0, 0.3)}})(x)
x = Convolution2D({{choice([64,128])}}, {{choice([3, 5])}}, padding='same', activation='relu')(x)
x = MaxPooling2D(pool_size=(2,2))(x)
x = Dropout({{uniform(0, 0.5)}})(x)
x = Convolution2D({{choice([128, 256])}}, {{choice([3, 5])}}, padding='same', activation='relu')(x)
x = MaxPooling2D(pool_size=(2,2))(x)
x = Dropout({{uniform(0, 0.7)}})(x)
model_choice = {{choice(['three', 'four'])}}
if model_choice == 'four':
x = Convolution2D({{choice([128, 256])}}, {{choice([3, 5])}}, padding='same', activation='relu')(x)
x = MaxPooling2D(pool_size=(2,2))(x)
x = Dropout({{uniform(0, 0.8)}})(x)
x = Flatten()(x)
x = Dense(128, activation='relu',kernel_initializer=({{choice([he_normal(seed = 33),glorot_uniform(seed = 33)])}}))(x)
x = Dense({{choice([256, 512, 1024])}}, activation='relu',kernel_initializer=({{choice([he_normal(seed = 33),glorot_uniform(seed = 33)])}}))(x)
x = Dense(5, activation='softmax')(x)
opt =optimizers.Adam(lr=0.001)
model = Model(inputs=inputs,outputs=x)
model.compile(loss='categorical_crossentropy', optimizer=opt,metrics=['accuracy'])
# fit the model on the batches generated by datagen.flow()
model.fit_generator(datagen.flow(X_train, y_train,
batch_size=128), epochs=100,
validation_data=(X_val, y_val))
score, acc = model.evaluate(X_val, y_val, verbose=0)
return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def build(input_shape, classes):
model = Sequential()
filter_num = ['None',32,64,128,256]
kernel_size = ['None',8,8,8,8]
conv_stride_size = ['None',1,1,1,1]
pool_stride_size = ['None',4,4,4,4]
pool_size = ['None',8,8,8,8]
model.add(Conv1D(filters=filter_num[1], kernel_size=kernel_size[1],input_shape=input_shape,
strides=conv_stride_size[1],padding='same',
name='block1_conv1'))
model.add(BatchNormalization(axis=-1))
model.add(ELU(alpha=1.0, name='block1_adv_act1'))
model.add(Conv1D(filters=filter_num[1], kernel_size=kernel_size[1],
strides=conv_stride_size[1], padding='same',
name='block1_conv2'))
model.add(BatchNormalization(axis=-1))
model.add(ELU(alpha=1.0, name='block1_adv_act2'))
model.add(MaxPooling1D(pool_size=pool_size[1], strides=pool_stride_size[1],
padding= 'same', name='block1_pool'))
model.add(Dropout(0.2, name='block1_dropout'))
model.add(Conv1D(filters=filter_num[2], kernel_size=kernel_size[2],
strides=conv_stride_size[2], padding='same',
name='block2_conv1'))
model.add(BatchNormalization())
model.add(Activation('relu', name='block2_act1'))
model.add(Conv1D(filters=filter_num[2], kernel_size=kernel_size[2],
strides=conv_stride_size[2], padding='same',
name='block2_conv2'))
model.add(BatchNormalization())
model.add(Activation('relu', name='block2_act2'))
model.add(MaxPooling1D(pool_size=pool_size[2], strides=pool_stride_size[3],
padding='same', name='block2_pool'))
model.add(Dropout(0.2, name='block2_dropout'))
model.add(Conv1D(filters=filter_num[3], kernel_size=kernel_size[3],
strides=conv_stride_size[3], padding='same',
name='block3_conv1'))
model.add(BatchNormalization())
model.add(Activation('relu', name='block3_act1'))
model.add(Conv1D(filters=filter_num[3], kernel_size=kernel_size[3],
strides=conv_stride_size[3], padding='same',
name='block3_conv2'))
model.add(BatchNormalization())
model.add(Activation('relu', name='block3_act2'))
model.add(MaxPooling1D(pool_size=pool_size[3], strides=pool_stride_size[3],
padding='same', name='block3_pool'))
model.add(Dropout(0.2, name='block3_dropout'))
model.add(Conv1D(filters=filter_num[4], kernel_size=kernel_size[4],
strides=conv_stride_size[4], padding='same',
name='block4_conv1'))
model.add(BatchNormalization())
model.add(Activation('relu', name='block4_act1'))
model.add(Conv1D(filters=filter_num[4], kernel_size=kernel_size[4],
strides=conv_stride_size[4], padding='same',
name='block4_conv2'))
model.add(BatchNormalization())
model.add(Activation('relu', name='block4_act2'))
model.add(MaxPooling1D(pool_size=pool_size[4], strides=pool_stride_size[4],
padding='same', name='block4_pool'))
model.add(Dropout(0.2, name='block4_dropout'))
model.add(Flatten(name='flatten'))
model.add(Dense(512, kernel_initializer = glorot_uniform(seed=0), name='fc1'))
model.add(BatchNormalization())
model.add(Activation('relu', name='fc1_act'))
model.add(Dropout(0.7, name='fc1_dropout'))
model.add(Dense(512, kernel_initializer = glorot_uniform(seed=0), name='fc2'))
model.add(BatchNormalization())
model.add(Activation('relu', name='fc2_act'))
model.add(Dropout(0.5, name='fc2_dropout'))
model.add(Dense(classes, kernel_initializer = glorot_uniform(seed=0),name='fc3'))
model.add(Activation('softmax', name="softmax"))
return model
def custom_mlp_with_mse(input_shape,
depth,
af='relu',
num_classes=1,
init_type='None'):
""" mlp model with mse loss
# Returns
model (Model): Keras model instance
"""
model = None
x = None
outputs = None
inputs = None
inputs = tf.keras.Input(shape=input_shape)
if af == 'LeakyReLU':
if init_type == 'xia':
initializer = glorot_uniform()
else:
initializer = TruncatedNormal(mean=0.0, stddev=0.5, seed=1)
# x = Dense(10, kernel_initializer='glorot_uniform', bias_initializer='zeros')(inputs)
x = Dense(10, kernel_initializer=initializer,
bias_initializer='zeros')(inputs)
x = Activation(LeakyReLU(alpha=0.1))(x)
elif af == 'PReLU':
if init_type == 'xia':
initializer = glorot_uniform()
else:
initializer = TruncatedNormal(mean=0.0, stddev=0.5, seed=1)
# x = Dense(10, kernel_initializer='glorot_uniform', bias_initializer='zeros')(inputs)
x = Dense(10, kernel_initializer=initializer,
bias_initializer='zeros')(inputs)
x = Activation(PReLU())(x)
elif af == 'ELU':
if init_type == 'xia':
initializer = glorot_uniform()
else:
initializer = TruncatedNormal(mean=0.0, stddev=0.5, seed=1)
# initializer = TruncatedNormal(mean=0.0, stddev=0.5, seed=1)
# x = Dense(10, kernel_initializer='glorot_uniform', bias_initializer='zeros')(inputs)
x = Dense(10, kernel_initializer=initializer,
bias_initializer='zeros')(inputs)
x = Activation(ELU(alpha=0.1))(x)
else:
if init_type == 'xia':
initializer = glorot_uniform()
else:
initializer = TruncatedNormal(mean=0.0, stddev=0.5, seed=1)
# x = Dense(10, kernel_initializer='glorot_uniform', bias_initializer='zeros', activation=af)(inputs)
x = Dense(10,
kernel_initializer=initializer,
bias_initializer='zeros',
activation=af)(inputs)
for _ in range(depth):
if af == 'LeakyReLU':
if init_type == 'xia':
initializer = glorot_uniform()
else:
initializer = TruncatedNormal(mean=0.0, stddev=0.5, seed=1)
# x = Dense(10, kernel_initializer='glorot_uniform', bias_initializer='zeros')(x)
x = Dense(10,
kernel_initializer=initializer,
bias_initializer='zeros')(x)
x = Activation(LeakyReLU(alpha=0.1))(x)
elif af == 'PReLU':
if init_type == 'xia':
initializer = glorot_uniform()
else:
initializer = TruncatedNormal(mean=0.0, stddev=0.5, seed=1)
# x = Dense(10, kernel_initializer='glorot_uniform', bias_initializer='zeros')(x)
x = Dense(10,
kernel_initializer=initializer,
bias_initializer='zeros')(x)
x = Activation(PReLU())(x)
elif af == 'ELU':
if init_type == 'xia':
initializer = glorot_uniform()
else:
initializer = TruncatedNormal(mean=0.0, stddev=0.5, seed=1)
# x = Dense(10, kernel_initializer='glorot_uniform', bias_initializer='zeros')(x)
x = Dense(10,
kernel_initializer=initializer,
bias_initializer='zeros')(x)
x = Activation(ELU(alpha=0.1))(x)
else:
if init_type == 'xia':
initializer = glorot_uniform()
else:
initializer = TruncatedNormal(mean=0.0, stddev=0.5, seed=1)
# x = Dense(10, kernel_initializer='glorot_uniform', bias_initializer='zeros', activation=af)(x)
x = Dense(10,
kernel_initializer=initializer,
bias_initializer='zeros',
activation=af)(x)
outputs = Dense(num_classes,
activation='sigmoid',
kernel_initializer='he_normal')(x)
# Instantiate model.
model = Model(inputs=inputs, outputs=outputs)
return model
def identity_block(X, f, filters, stage, block):
# defining name basis
conv_name_base = 'res' + str(stage) + block + '_branch'
bn_name_base = 'bn' + str(stage) + block + '_branch'
# Retrieve Filters
F1, F2, F3 = filters
# Save the input value. You'll need this later to add back to the main path.
X_shortcut = X
# First component of main path
X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)
X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)
X = Activation('relu')(X)
# Second component of main path (≈3 lines)
X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)
X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)
X = Activation('relu')(X)
# Third component of main path (≈2 lines)
X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c', kernel_initializer = glorot_uniform(seed=0))(X)
X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)
# Final step: Add shortcut value to main path, and pass it through a RELU activation (≈2 lines)
X = Add()([X, X_shortcut])
X = Activation('relu')(X)
return X
def runANN_k(workinghome, foldername, hlayers,hunits_list, site, plot, epochs, fold, train_model):
# AIClist = []
# sigmalist = []
# for i in range(len(foldername_list)):
foldername = foldername
site = site
act = 'tanh'
hlayers = hlayers
hunits = hunits_list
if site == 'vs30':
vref = 760.
# vref = 519.
elif site == 'kappa':
vref = 0.06
else:
vref = 760.
lr = 0.01
epochs = epochs
if not os.path.exists(workinghome):
os.mkdir(workinghome)
if not os.path.exists(workinghome + '/' + foldername):
os.mkdir(workinghome + '/' + foldername)
os.mkdir(workinghome + '/' + foldername + '/testing')
os.mkdir(workinghome + '/' + foldername + '/training')
os.mkdir(workinghome + '/' + foldername + '/validation')
os.mkdir(workinghome + '/' + foldername + '/curves')
if not os.path.exists(workinghome + '/' + foldername+ '/curves'):
os.mkdir(workinghome + '/' + foldername + '/curves')
if site == 'vs30' or site == 'none':
db = pickle.load(open('/Users/aklimase/Documents/GMM_ML/database_vs30.pckl', 'r'))
else:
db = pickle.load(open('/Users/aklimase/Documents/GMM_ML/database_kappa.pckl', 'r'))
if site == '5coeff':
d = {'mw': db.mw,'R': db.r,'sta': db.sta, 'pga': np.log(db.pga/9.81), 'elat': db.elat, 'elon': db.elon,'stlat': db.stlat,'stlon': db.stlon}
# d = {'mw': db.mw,'R': db.r,'mw2': db.mw**2.,'logR': np.log(db.r),'sta': db.sta, 'pga': np.log(db.pga/9.81)}
else:
d = {'mw': db.mw,'R': db.r,'sta': db.sta,'vs30': db.vs30.flatten(), 'pga': np.log(db.pga/9.81), 'elat': db.elat, 'elon': db.elon,'stlat': db.stlat,'stlon': db.stlon}
df = pd.DataFrame(data=d)
train, test_valid = train_test_split(df, test_size=0.4, random_state = seed)
valid, test = train_test_split(test_valid, test_size=1/2., random_state = seed)
y_train = train['pga']
x_train_sta = train['sta']
x_train_coor = train[['elat', 'elon', 'stlat', 'stlon']]
x_train = train.drop(['pga','sta','elat', 'elon', 'stlat', 'stlon'], axis = 1)
y_test = test['pga']
x_test_sta = test['sta']
x_test_coor = test[['elat', 'elon', 'stlat', 'stlon']]
x_test = test.drop(['pga','sta','elat', 'elon', 'stlat', 'stlon'], axis = 1)
y_valid = valid['pga']
x_valid_sta = valid['sta']
x_valid_coor = valid[['elat', 'elon', 'stlat', 'stlon']]
x_valid = valid.drop(['pga','sta','elat', 'elon', 'stlat', 'stlon'], axis = 1)
scaler = StandardScaler()
scaler.fit(x_train)
x_train_scale = scaler.transform(x_train)
x_test_scale = scaler.transform(x_test)
x_valid_scale = scaler.transform(x_valid)
kfold = KFold(n_splits=fold, shuffle=True)
split = 0
ann_predicted_total_test = []
ann_predicted_total_valid = []
ann_predicted_total_train = []
test_std_kfold = []
ANN_list = []
for train_index, test_index in kfold.split(x_train_scale):
n = split
X_traink, X_validk = x_train_scale[train_index], x_train_scale[test_index]
y_traink, y_validk = np.asarray(y_train)[train_index], np.asarray(y_train)[test_index]
if train_model == True:
ANN = fitANN(act, hlayers, hunits, lr, epochs, X_traink, y_traink, X_validk, y_validk, foldername, workinghome)
model_json = ANN.to_json()
with open(workinghome + '/' + foldername + '/'+ 'model_' + str(n) + '.json', "w") as json_file:
json_file.write(model_json)
# serialize weights to HDF5
ANN.save_weights(workinghome + '/' + foldername + '/'+ 'model_' + str(n) + '.h5')
#else the model is trained and saved already
else:
json_file = open(workinghome + '/' + foldername + '/' + 'model_' + str(n) + '.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
ANN = model_from_json(loaded_model_json, custom_objects={'GlorotUniform': glorot_uniform()})
ANN.load_weights(workinghome + '/' + foldername + '/' + 'model_' + str(n) + '.h5')
ANN_list.append(ANN)
ANN_test_predicted = ANN.predict(x_test_scale)
ANN_test_predicted = ANN_test_predicted.flatten()
test_std = np.std(y_test - ANN_test_predicted)
print 'ANN ' + str(split) + ' test_std: ' + str(test_std)
test_std_kfold.append(test_std)
ann_predicted_total_test.append(ANN_test_predicted)
ANN_valid_predicted = ANN.predict(x_valid_scale)
ANN_valid_predicted = ANN_valid_predicted.flatten()
valid_std = np.std(y_valid - ANN_valid_predicted)
print 'ANN ' + str(split) + ' valid_std: ' + str(valid_std)
ann_predicted_total_valid.append(ANN_valid_predicted)
# ANN_train_predictedk = ANN.predict(X_traink)
# ANN_train_predictedk = ANN_train_predictedk.flatten()
# train_std = np.std(y_traink - ANN_train_predictedk)
ANN_train_predicted = ANN.predict(x_train_scale)
ANN_train_predicted = ANN_train_predicted.flatten()
train_std = np.std(y_train - ANN_train_predicted)
print 'ANN ' + str(split) + ' train_std: ' + str(train_std)
ann_predicted_total_train.append(ANN_train_predicted)
# setup_test_curves(site, scaler, workinghome, foldername, siteparams, [ANN], ndir = n)
# residual_histo(y_traink, y_valid, y_test, ANN_train_predictedk, ANN_valid_predicted, ANN_test_predicted, workinghome, foldername, n=n)
split+=1
plt.close('all')
#overall prediction is average of k folds
average_pre_test = np.average(ann_predicted_total_test, axis = 0)
total_std = np.std(y_test - average_pre_test)
average_pre_valid = np.average(ann_predicted_total_valid, axis = 0)
valid_std = np.std(y_valid - average_pre_valid)
average_pre_train = np.average(ann_predicted_total_train, axis = 0)
train_std = np.std(y_train - average_pre_train)
residual_histo(y_train, y_valid, y_test, average_pre_train, average_pre_valid, average_pre_test, workinghome, foldername, n='')
def ResNet50_manual(input_shape=(228, 304, 3), dropoutRate=0.3):
"""
Implementation of the popular ResNet50 the following architecture:
CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> CONVBLOCK -> IDBLOCK*2 -> CONVBLOCK -> IDBLOCK*3
-> CONVBLOCK -> IDBLOCK*5 -> CONVBLOCK -> IDBLOCK*2 -> AVGPOOL -> TOPLAYER
Arguments:
input_shape -- shape of the images of the dataset
classes -- integer, number of classes
Returns:
model -- a Model() instance in Keras
"""
# Define the input as a tensor with shape input_shape
X_input = Input(input_shape)
# Zero-Padding
X = ZeroPadding2D((3, 3))(X_input)
# Stage 1
X = Conv2D(64, (7, 7),
strides=(2, 2),
name='conv1',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3, name='bn_conv1')(X)
X = Activation('relu')(X)
#X = Dropout(rate=dropoutRate)(X)
X = MaxPooling2D((3, 3), strides=(2, 2))(X)
# Stage 2
X = convolutional_block(X,
f=3,
filters=[64, 64, 256],
stage=2,
block='a',
s=1)
X = identity_block(X, 3, [64, 64, 256], stage=2, block='b')
X = identity_block(X, 3, [64, 64, 256], stage=2, block='c')
X = Dropout(rate=dropoutRate)(X)
# Stage 3 (≈4 lines)
X = convolutional_block(X,
f=3,
filters=[128, 128, 512],
stage=3,
block='a',
s=2)
X = identity_block(X, 3, [128, 128, 512], stage=3, block='b')
X = identity_block(X, 3, [128, 128, 512], stage=3, block='c')
X = identity_block(X, 3, [128, 128, 512], stage=3, block='d')
X = Dropout(rate=dropoutRate)(X)
# Stage 4 (≈6 lines)
X = convolutional_block(X,
f=3,
filters=[256, 256, 1024],
stage=4,
block='a',
s=2)
X = identity_block(X, 3, [256, 256, 1024], stage=4, block='b')
X = identity_block(X, 3, [256, 256, 1024], stage=4, block='c')
X = identity_block(X, 3, [256, 256, 1024], stage=4, block='d')
X = identity_block(X, 3, [256, 256, 1024], stage=4, block='e')
X = identity_block(X, 3, [256, 256, 1024], stage=4, block='f')
X = Dropout(rate=dropoutRate)(X)
# Stage 5 (≈3 lines)
X = convolutional_block(X,
f=3,
filters=[512, 512, 2048],
stage=5,
block='a',
s=2)
X = identity_block(X, 3, [512, 512, 2048], stage=5, block='b')
X = identity_block(X, 3, [512, 512, 2048], stage=5, block='c')
X = Dropout(rate=dropoutRate)(X)
# =============================================================================
# # AVGPOOL (≈1 line). Use "X = AveragePooling2D(...)(X)"
# X = AveragePooling2D(pool_size=(2, 2))(X)
#
#
# # output layer
# X = Flatten()(X)
# X = Dense(classes, activation='softmax', name='fc' + str(classes), kernel_initializer = glorot_uniform(seed=0))(X)
# =============================================================================
#stage 6
X = Conv2D(1024, (1, 1),
name='conv6',
kernel_initializer=glorot_uniform(seed=0))(X)
X = upConv_block(X, 512, stage=6, block=1)
X = upConv_block(X, 256, stage=6, block=2)
X = upConv_block(X, 128, stage=6, block=3)
X = upConv_block(X, 64, stage=6, block=4)
X = upConv_block(X, 32, stage=6, block=5)
#stage 7
X = Conv2D(1, (3, 3),
name='conv7',
kernel_initializer=glorot_uniform(seed=0))(X)
X = Activation('relu')(X)
# Create model
model = Model(inputs=X_input, outputs=X, name='ResNet50')
return model
def ResNet50(input_shape=(150, 150, 3), classes=2):
"""
Implementation of the popular ResNet50 the following architecture:
CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> CONVBLOCK -> IDBLOCK*2 -> CONVBLOCK -> IDBLOCK*3
-> CONVBLOCK -> IDBLOCK*5 -> CONVBLOCK -> IDBLOCK*2 -> AVGPOOL -> TOPLAYER
Arguments:
input_shape -- shape of the images of the dataset
classes -- integer, number of classes
Returns:
modelResNet -- a modelResNet() instance in Keras
"""
# Define the input as a tensor with shape input_shape
X_input = Input(input_shape)
# Zero-Padding
X = ZeroPadding2D((3, 3))(X_input)
# Stage 1
X = Conv2D(64, (7, 7),
strides=(2, 2),
name='conv1',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3, name='bn_conv1')(X)
X = Activation('relu')(X)
X = MaxPooling2D((3, 3), strides=(2, 2))(X)
# Stage 2
X = convolutional_block(X,
f=3,
filters=[64, 64, 256],
stage=2,
block='a',
s=1)
X = identity_block(X, 3, [64, 64, 256], stage=2, block='b')
X = identity_block(X, 3, [64, 64, 256], stage=2, block='c')
### START CODE HERE ###
# Stage 3 (≈4 lines)
X = convolutional_block(X,
f=3,
filters=[128, 128, 512],
stage=3,
block='a',
s=2)
X = identity_block(X, 3, [128, 128, 512], stage=3, block='b')
X = identity_block(X, 3, [128, 128, 512], stage=3, block='c')
X = identity_block(X, 3, [128, 128, 512], stage=3, block='d')
# Stage 4 (≈6 lines)
X = convolutional_block(X,
f=3,
filters=[256, 256, 1024],
stage=4,
block='a',
s=2)
X = identity_block(X, 3, [256, 256, 1024], stage=4, block='b')
X = identity_block(X, 3, [256, 256, 1024], stage=4, block='c')
X = identity_block(X, 3, [256, 256, 1024], stage=4, block='d')
X = identity_block(X, 3, [256, 256, 1024], stage=4, block='e')
X = identity_block(X, 3, [256, 256, 1024], stage=4, block='f')
# Stage 5 (≈3 lines)
X = convolutional_block(X,
f=3,
filters=[512, 512, 2048],
stage=5,
block='a',
s=2)
X = identity_block(X, 3, [512, 512, 2048], stage=5, block='b')
X = identity_block(X, 3, [512, 512, 2048], stage=5, block='c')
# AVGPOOL (≈1 line). Use "X = AveragePooling2D(...)(X)"
X = AveragePooling2D((2, 2), name="avg_pool")(X)
### END CODE HERE ###
# output layer
X = Flatten()(X)
X = Dense(classes,
activation='softmax',
name='fc' + str(classes),
kernel_initializer=glorot_uniform(seed=0))(X)
# Create modelResNet
modelResNet = Model(inputs=X_input, outputs=X, name='ResNet50')
return modelResNet
from tensorflow.keras.models import load_model
from tensorflow.keras.utils import CustomObjectScope
from tensorflow.keras.initializers import glorot_uniform
app = Flask(__name__)
bootstrap = Bootstrap(app)
SECRET_KEY = os.urandom(32)
app.config['SECRET_KEY'] = "HARD_TO_GUESS"
app.config['WTF_CSRF_CHECK_DEFAULT'] = False
CsrfProtect(app)
modelConfiguration = r'darknet-yolo/obj.cfg'
modelWeights = r'darknet-yolo/obj_60000.weights'
with CustomObjectScope({'GlorotUniform': glorot_uniform()}):
charModel = load_model( r'charRecognition/model.h5')
UPLOAD_FOLDER = r'static/images'
net = cv2.dnn.readNetFromDarknet(modelConfiguration, modelWeights)
net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
net.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)
for file in os.listdir(UPLOAD_FOLDER):
os.remove(os.path.join(UPLOAD_FOLDER,file) )
@app.route('/',methods=['GET','POST'])
def home():
output = ''
form = uploadImage()
def build(self, input_shape):
super(ScoreLayer, self).build(input_shape)
if self.use_global:
self.global_bias=self.add_weight(shape=(1,),initializer=glorot_uniform(self.seed))
def RNN_model(self, train, test, train_size, data, look_back = 1):
"""
Recurrent Neural Network model.
Args :
------
train :array_like
test : array_lik
train_size : int
data: ndarray, DataFrame
look_back : float
window size
Returns:
--------
Plot of timeseies predection.
Test Score RMSE and Normalized RMS
"""
plt.style.use('default')
# %%
l2 = regularizers.l2
dataset = data.values # .as_matrix() will be decrepit in the future, switched to .values
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset) #fit scaler
# reshape into X=t and Y=t+1
# lookback is the window size
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
print(data)
# %%
# reshape input to be [samples, time steps, features]
trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
# %%
##Train Model
# %%
# numEpoch: number of passes through the data
numEpoch = 100
vl_splt = 730.0 / 5475.0
initBias = initializers.glorot_uniform(seed=0)
initKernel = initializers.Orthogonal(gain=1.0, seed=0)
# %%
# create and fit the dense ann
# first we need to flatten the extra dimension within the dataset
flat_TrainX = np.reshape(trainX, (len(trainX), look_back))
#print(testX.shape)
flat_TestX = np.reshape(testX, (len(testX), 20))
#print(flat_TestX.shape)
# %%
# create and fit the simpleRNN
simpleRNN = Sequential()
simpleRNN.add(SimpleRNN(8,
input_shape=(1, look_back),
kernel_initializer = initKernel,
bias_initializer = initBias,
# kernel_regularizer=l2(0.00001),
# recurrent_regularizer=l2(0.0001),
bias_regularizer=l2(0.00001),
dropout=0.01,
#recurrent_dropout=0.01
))
simpleRNN.add(Dense(1,
kernel_initializer = initKernel,
bias_initializer = initBias
# kernel_regularizer=l2(0.001),
# bias_regularizer=l2(0.001)
))
simpleRNN.compile(loss='mean_squared_error', optimizer='adam')
simpleRNN.fit(trainX, trainY, epochs=numEpoch,
batch_size=1, verbose=2, validation_split = vl_splt) #look into setting validation set
# %%
##Test Model
# %%
trainY = scaler.inverse_transform([trainY])
testY = scaler.inverse_transform([testY])
# %%
# make predictions
RNN_trainPredict = simpleRNN.predict(trainX)
RNN_testPredict = simpleRNN.predict(testX)
# invert predictions
RNN_trainPredict = scaler.inverse_transform(RNN_trainPredict)
RNN_testPredict = scaler.inverse_transform(RNN_testPredict)
# calculate root mean squared error
RNN_trainScore = math.sqrt(mean_squared_error(trainY[0], RNN_trainPredict[:,0]))
#print('Train Score: %.2f RMSE' % (RNN_trainScore))
RNN_testScore = math.sqrt(mean_squared_error(testY[0], RNN_testPredict[:,0]))
print('Test Score: %.2f RMSE' % (RNN_testScore))
# normalized RMSE
y_min, y_max = min(trainY[0]), max(trainY[0])
yhat = y_max - y_min
print("Normalized RMSE: %s" % (RNN_testScore/yhat))
# %%
# shift train predictions for plotting
RNN_trainPredictPlot = np.empty_like(dataset)
RNN_trainPredictPlot[:, :] = np.nan
RNN_trainPredictPlot[look_back:len(RNN_trainPredict)+look_back, :] = RNN_trainPredict
# shift test predictions for plotting
RNN_testPredictPlot = np.empty_like(dataset)
RNN_testPredictPlot[:, :] = np.nan
RNN_testPredictPlot[len(RNN_trainPredict)+
(look_back*2)+1:len(dataset)-1, :] = RNN_testPredict
# plot baseline and predictions
plt.figure(figsize=(18,8))
#plt.plot(scaler.inverse_transform(dataset))
#plt.plot(RNN_trainPredictPlot)
dates = data.index[train_size:-1].values
RNN_testPredictPlot = [RNN_testPredictPlot[i][0] for i in range(train_size+1, len(RNN_testPredictPlot))]
pred = pd.DataFrame({"Date": dates, "Volume": RNN_testPredictPlot})
pred.Date = pd.to_datetime(pred.Date)
pred.set_index("Date", inplace=True)
plt.title("Water Volume (seasoned predictions)")
plt.plot(data)
plt.plot(pred)
plt.show()
#------------------------------------------------------------------------------
# load data
labels_rand_train = np.load(dir_anfiles + "/labels_train_sounds.npy")
labels_rand_test = np.load(dir_anfiles + "/labels_test_sounds.npy")
an_l_rand_train = np.load(dir_anfiles + "/an_l_train_sounds.npy")
an_l_rand_test = np.load(dir_anfiles + "/an_l_test_sounds.npy")
an_r_rand_train = np.load(dir_anfiles + "/an_r_train_sounds.npy")
an_r_rand_test = np.load(dir_anfiles + "/an_r_test_sounds.npy")
print("Loading arrays completed")
# load model
#t.tic()
mymodel = load_model(dir_mofiles + "/A_" + modelname + ".h5",
custom_objects={
'GlorotUniform': glorot_uniform(),
"cust_mean_squared_error": cust_mean_squared_error,
"cos_distmet_2D_angular": cos_distmet_2D_angular
})
mymodel.summary()
#t.toc("loading the model took ")
print("Loading model completed")
#------------------------------------------------------------------------------
# Training
#------------------------------------------------------------------------------
# train the model
#t.tic()
history = mymodel.fit([an_l_rand_train, an_r_rand_train],
labels_rand_train,
def identity_block(X, f, filters, stage, block):
"""
From Coursera shamelessly coppied...
Implementation of the identity block as defined in Figure 4
Arguments:
X -- input tensor of shape (m, n_H_prev, n_W_prev, n_C_prev)
f -- integer, specifying the shape of the middle CONV's window for the main
path
filters -- python list of integers, defining the number of filters in the
CONV layers of the main path
stage -- integer, used to name the layers, depending on their position in
the network
block -- string/character, used to name the layers, depending on their
position in the network
Returns:
X -- output of the identity block, tensor of shape (n_H, n_W, n_C)
"""
# defining name basis
conv_name_base = 'res' + str(stage) + block + '_branch'
bn_name_base = 'bn' + str(stage) + block + '_branch'
# Retrieve Filters
F1, F2, F3 = filters
X_shortcut = X
# First component of main path
X = Conv3D(filters=F1,
kernel_size=(1, 1, 1),
strides=(1, 1, 1),
padding='valid',
name=conv_name_base + '2a',
kernel_initializer=glorot_uniform(seed=0))(X)
# axis3 could be an issue
X = BatchNormalization(axis=3, name=bn_name_base + '2a')(X)
X = Activation('relu')(X)
# Second component of main path
X = Conv3D(filters=F2,
kernel_size=(f, f, f),
strides=(1, 1, 1),
padding='same',
name=conv_name_base + '2b',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3, name=bn_name_base + '2b')(X)
X = X = Activation('relu')(X)
X = Conv3D(filters=F3,
kernel_size=(1, 1, 1),
strides=(1, 1, 1),
padding='same',
name=conv_name_base + '2c',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3, name=bn_name_base + '2c')(X)
# Final step: Add shortcut value to main path, and pass it through a RELU
# activation
X = Add()([X_shortcut, X])
X = Activation('relu')(X)
return X
def conv_block(X, f, filters, activation, s=2):
X_shortcut = X
X = Conv2D(filters=filters, kernel_size=(1, 1), strides=(s, s), padding='valid', kernel_initializer=glorot_uniform(seed=0))(X)
if epsilon != 0:
X = BatchNormalization(epsilon = epsilon, axis=axis)(X)
X = Activation(activation)(X)
X = Conv2D(filters=filters, kernel_size=(f, f), strides=(1, 1), padding='same', kernel_initializer=glorot_uniform(seed=0))(X)
if epsilon != 0:
X = BatchNormalization(epsilon = epsilon, axis=axis)(X)
X_shortcut = Conv2D(filters=filters, kernel_size=(1, 1), strides=(s, s), padding='valid', kernel_initializer=glorot_uniform(seed=0))(X_shortcut)
if epsilon != 0:
X_shortcut = BatchNormalization(epsilon = epsilon, axis=axis)(X_shortcut)
X = Add()([X, X_shortcut])
X = Activation(activation)(X)
return X
def HOT_RES_BACILLUS_03(input_shape, n_class):
n_filters = 128
# Input layer
x = Input(shape=input_shape)
conv_x = Conv2D(
filters=100,
kernel_size=(4, 15),
padding='same'
)(x)
conv_x = BatchNormalization()(conv_x)
conv_x = Activation('relu')(conv_x)
conv_y = Conv2D(filters=n_filters, kernel_size=(1, 5), padding='same')(conv_x)
conv_y = BatchNormalization()(conv_y)
conv_y = Activation('relu')(conv_y)
conv_z = Conv2D(filters=n_filters, kernel_size=(1, 3), padding='same')(conv_y)
conv_z = BatchNormalization()(conv_z)
# expand channels for the sum
shortcut_y = Conv2D(filters=n_filters, kernel_size=(4, 1), padding='same')(x)
shortcut_y = BatchNormalization()(shortcut_y)
output_block_1 = Add()([shortcut_y, conv_z])
output_block_1 = Activation('relu')(output_block_1)
# BLOCK 2
conv_x = Conv2D(filters=n_filters * 2, kernel_size=(1, 8), padding='same')(output_block_1)
conv_x = BatchNormalization()(conv_x)
conv_x = Activation('relu')(conv_x)
conv_y = Conv2D(filters=n_filters * 2, kernel_size=(1, 5), padding='same')(conv_x)
conv_y = BatchNormalization()(conv_y)
conv_y = Activation('relu')(conv_y)
conv_z = Conv2D(filters=n_filters * 2, kernel_size=(1, 3), padding='same')(conv_y)
conv_z = BatchNormalization()(conv_z)
# expand channels for the sum
shortcut_y = Conv2D(filters=n_filters * 2, kernel_size=(1, 1), padding='same')(output_block_1)
shortcut_y = BatchNormalization()(shortcut_y)
output_block_2 = Add()([shortcut_y, conv_z])
output_block_2 = Activation('relu')(output_block_2)
# BLOCK 3
conv_x = Conv2D(filters=n_filters * 2, kernel_size=(1, 8), padding='same')(output_block_2)
conv_x = BatchNormalization()(conv_x)
conv_x = Activation('relu')(conv_x)
conv_y = Conv2D(filters=n_filters * 2, kernel_size=(1, 5), padding='same')(conv_x)
conv_y = BatchNormalization()(conv_y)
conv_y = Activation('relu')(conv_y)
conv_z = Conv2D(filters=n_filters * 2, kernel_size=(1, 3), padding='same')(conv_y)
conv_z = BatchNormalization()(conv_z)
# no need to expand channels because they are equal
shortcut_y = BatchNormalization()(output_block_2)
output_block_3 = Add()([shortcut_y, conv_z])
output_block_3 = Activation('relu')(output_block_3)
gap_layer = GlobalAveragePooling2D()(output_block_3)
# X = AveragePooling2D((1, 2), name="avg_pool")(X)
# Fully connected layers
# X = Flatten()(X)
X = Dropout(.2)(gap_layer)
outputs = Dense(n_class, activation='sigmoid', name='fc' + str(n_class), kernel_initializer=glorot_uniform(seed=0))(
X)
# Create model object
model = models.Model(inputs=[x], outputs=[outputs])
return model
X = Activation('relu')(X)
return X
input_shape = (96, 96, 1)
# Input tensor shape
X_input = Input(input_shape)
# Zero-padding
X = ZeroPadding2D((3, 3))(X_input)
# 1 - stage
X = Conv2D(64, (7, 7), strides=(2, 2), name='conv1',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3, name='bn_conv1')(X)
X = Activation('relu')(X)
X = MaxPooling2D((3, 3), strides=(2, 2))(X)
# 2 - stage
X = res_block(X, filter=[64, 64, 256], stage=2)
# 3 - stage
X = res_block(X, filter=[128, 128, 512], stage=3)
# Average Pooling
X = AveragePooling2D((2, 2), name='Averagea_Pooling')(X)
# Final layer
def create_model(input_size, hyper_param):
""" Creates a model using the provided hyperparamaters
Arguments:
input_size - number of inputs provided to network
hyper_param - instance of cHyperParameters defining hyperparamters to be used
"""
#TODO: add paramater for kernel and activity regularized
#TODO: add paramater for activation function
#TODO: Try KL-Divergence Sparse Autoencoder
act_func = 'elu'
# Input layer:
model=Sequential()
#ENCODER
# First hidden layer, connected to input vector X
model.add(Dropout(hyper_param.drop_out[0], input_shape=(input_size,)))
model.add(Dense(hyper_param.layers[0],
activation=act_func,
kernel_initializer=initializers.glorot_uniform(seed=hyper_param.random_seed),
activity_regularizer=regularizers.l1(hyper_param.kernel_reg[0]),
#kernel_regularizer=regularizers.l2(kernel_reg[i]),
))
model.add(Dropout(hyper_param.drop_out[1]))
#print("Encoder: Added layer -> " + str(input_size) + ":" + str(hyper_param.layers[0]) + " k_reg: " + str(hyper_param.kernel_reg[0]) + " drop_out: " + str(hyper_param.drop_out[0]))
for i in range(1,len(hyper_param.layers)-1):
model.add(Dense(hyper_param.layers[i],
activation=act_func,
#kernel_regularizer=regularizers.l2(kernel_reg[i]),
activity_regularizer=regularizers.l1(hyper_param.kernel_reg[i]),
kernel_initializer=initializers.glorot_uniform(seed=hyper_param.random_seed)))
model.add(Dropout(hyper_param.drop_out[i+1]))
#print("Encoder: Added layer -> " + str(hyper_param.layers[i]) + " k_reg: " + str(hyper_param.kernel_reg[i]) + " i is " + str(i))
#BOTTLENECK
model.add(Dense(hyper_param.layers[-1],
activation=act_func,
#kernel_regularizer=regularizers.l2(kernel_reg[-1]),
kernel_initializer=initializers.glorot_uniform(seed=hyper_param.random_seed)))
#print("Bottleneck: Added layer - nodes: " + str(hyper_param.layers[-1]) + " k_reg: " + str(hyper_param.kernel_reg[-1]))
#DECODER
for i in range(len(hyper_param.layers)-2,-1,-1):
model.add(Dense(hyper_param.layers[i],
activation=act_func,
#kernel_regularizer=regularizers.l2(kernel_reg[i]),
activity_regularizer=regularizers.l1(hyper_param.kernel_reg[i]),
kernel_initializer=initializers.glorot_uniform(seed=hyper_param.random_seed)))
#print("Decoder: Added layer -> " + str(hyper_param.layers[i]) + " k_reg: " + str(hyper_param.kernel_reg[i]) + " i is " + str(i))
model.add(Dense(input_size,
#kernel_regularizer=regularizers.l2(0.001),
kernel_initializer=initializers.glorot_uniform(seed=hyper_param.random_seed)))
#print("Decoder: Added layer -> " + str(input_size) + " k_reg: " + str(hyper_param.kernel_reg[-1]))
#TODO: Check for other loss functions
#https://medium.com/@syoya/what-happens-in-sparse-autencoder-b9a5a69da5c6
model.compile(loss='mse',optimizer='adam')
print("\nModel Summary...")
print(model.summary())
return model
