model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=["accuracy"])
# Viewing model configuration
model.summary()
model.get_config()
model.layers[0].get_config()
model.layers[0].input_shape
model.layers[0].output_shape
model.layers[0].get_weights()
np.shape(model.layers[0].get_weights()[0])
model.layers[0].trainable
# Training the model
print("Training the model")
hist = model.fit(X_train,
y_train,
batch_size=64,
nb_epoch=num_epoch,
verbose=1,
validation_data=(X_test, y_test))
def train(x_train, y_train, x_test, y_test, epochs):
# calculate classes
if np.unique(y_train).shape[0] == np.unique(y_test).shape[0]:
#
num_classes = np.unique(y_train).shape[0]
else:
print('Error in class data...')
return -2
# set validation data
'''val_size = int(0.1 * x_train.shape[0])
r = np.random.randint(0, x_train.shape[0], size=val_size)
x_val = x_train[r, :, :]
y_val = y_train[r]
x_train = np.delete(x_train, r, axis=0)
y_train = np.delete(y_train, r, axis=0)'''
step = int(x_train.shape[0] * 0.005)
length = int(x_train.shape[0] * 0.1 * 0.005)
r = []
for i in range(0, x_train.shape[0] - length, step):
r.extend(range(i, i + length))
x_val = x_train[r, :, :]
y_val = y_train[r]
x_train = np.delete(x_train, r, axis=0)
y_train = np.delete(y_train, r, axis=0)
print('\nInitializing CNN2D...')
print('\nclasses:', num_classes)
print('x train shape:',
x_train.shape), print('x val shape:',
x_val.shape), print('x test shape:',
x_test.shape)
print('y train shape:',
y_train.shape), print('y val shape:',
y_val.shape), print('y test shape:',
y_test.shape)
print("\nTrain split with mean|std {:.2f}|{:.2f}".format(
np.mean(x_train), np.std(x_train)))
print("Test split with mean|std {:.2f}|{:.2f}".format(
np.mean(x_test), np.std(x_test)))
# shape data
x_train = x_train.reshape(x_train.shape[0], x_train.shape[1],
x_train.shape[2], 1)
x_val = x_val.reshape(x_val.shape[0], x_val.shape[1], x_val.shape[2], 1)
x_test = x_test.reshape(x_test.shape[0], x_test.shape[1], x_test.shape[2],
1)
y_train = tf.keras.utils.to_categorical(y_train, num_classes)
y_val = tf.keras.utils.to_categorical(y_val, num_classes)
y_test = tf.keras.utils.to_categorical(y_test, num_classes)
# define the model
activation = 'elu'
regularizer = 0.0000
dropout = 0.25
# preprocessing
'''
offset = 1.0 * np.std(x_train)
dc0 = (x)
dc1 = GaussianNoise(offset*0.1)(x)
dc2 = GaussianDropout(dropout)(x)
dc3 = Lambda(lambda r: r + __import__('keras').backend.random_uniform((1,), -offset, offset))(x)
dc4 = Lambda(lambda r: r + __import__('keras').backend.random_uniform((1,), -offset, offset))(x)
m = Concatenate()([dc0, dc1, dc2, dc3, dc4])
m = Lambda(lambda r: r - __import__('keras').backend.mean(r))(x)
'''
# sequential
model = Sequential()
model.add(
Conv2D(16,
kernel_size=(3, 3),
strides=(2, 1),
activation='elu',
kernel_regularizer=regularizers.l2(regularizer),
input_shape=(x_train.shape[1], x_train.shape[2], 1)))
model.add(EntropyPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
model.add(
Conv2D(32,
kernel_size=(3, 3),
strides=(1, 1),
activation='elu',
kernel_regularizer=regularizers.l2(regularizer)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
model.add(
Conv2D(64,
kernel_size=(3, 3),
strides=(1, 1),
activation='elu',
kernel_regularizer=regularizers.l2(regularizer)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
# model.add(Conv2D(128, kernel_size=(3, 3), strides=(1, 1), activation='elu', kernel_regularizer=regularizers.l2(regularizer)))
# model.add(MaxPooling2D(pool_size=(1, 2)))
# model.add(Dropout(dropout))
model.add(Flatten())
model.add(
Dense(64,
activation='elu',
kernel_regularizer=regularizers.l2(regularizer)))
model.add(Dropout(dropout))
model.add(Dense(num_classes, activation='softmax'))
# functional
'''
x = Input((x_train.shape[1], x_train.shape[2], x_train.shape[3]))
m = Conv2D(16, 3, activation=activation , kernel_regularizer=regularizers.l2(regularizer))(x)
m = EntropyPooling2D((2, 2))(m)
m = Dropout(dropout)(m)
m = Conv2D(32, 3, activation=activation, kernel_regularizer=regularizers.l2(regularizer))(m)
m = EntropyPooling2D((2, 2))(m)
m = Dropout(dropout)(m)
m = Conv2D(64, 3, activation=activation, kernel_regularizer=regularizers.l2(regularizer))(m)
m = EntropyPooling2D((2, 2))(m)
m = Dropout(dropout)(m)
if x_train.shape[1] < 50:
#
m = Flatten()(m)
else:
m = Conv2D(128, 3, activation=activation, kernel_regularizer=regularizers.l2(regularizer))(m)
m = GlobalAveragePooling2D()(m)
m = Dropout(dropout)(m)
m = (Dense(64, activation=activation, kernel_regularizer=regularizers.l2(regularizer)))(m)
m = Dropout(dropout)(m)
y = Dense(num_classes, activation='softmax')(m)
model = Model(inputs=[x], outputs=[y])
'''
# summarize model
for i in range(0, len(model.layers)):
if i == 0:
plot_model(model, to_file='Models\\model_cnn2d.png')
# f = open('Models\\model_cnn2d.txt', 'w')
# print(' ')
# print('{}. Layer {} with input / output shapes: {} / {}'.format(i, model.layers[i].name, model.layers[i].input_shape, model.layers[i].output_shape))
# f.write('{}. Layer {} with input / output shapes: {} / {} \n'.format(i, model.layers[i].name, model.layers[i].input_shape, model.layers[i].output_shape))
if i == len(model.layers) - 1:
# f.close()
print(' ')
model.summary()
# compile, fit evaluate
callback = [
callbacks.EarlyStopping(monitor='val_acc',
min_delta=0.01,
patience=10,
restore_best_weights=True)
]
model.compile(loss=tf.keras.losses.categorical_crossentropy,
optimizer=tf.keras.optimizers.Adam(),
metrics=['accuracy'])
model.fit(x_train,
y_train,
batch_size=256,
epochs=epochs,
verbose=2,
validation_data=(x_val, y_val),
callbacks=callback)
score = model.evaluate(x_test, y_test, verbose=2)
# evaluate on larger frames
aggr_size = 5
for i in range(0, y_test.shape[0] - aggr_size, aggr_size):
if i == 0:
y_pred = model.predict(x_test)
y_pred = np.argmax(y_pred, axis=1)
y_test = np.argmax(y_test, axis=1)
y_aggr_test = []
y_aggr_pred = []
if np.unique(y_test[i:i + aggr_size]).shape[0] == 1:
y_aggr_test.append(stats.mode(y_test[i:i + aggr_size])[0][0])
y_aggr_pred.append(stats.mode(y_pred[i:i + aggr_size])[0][0])
# print(confusion_matrix(np.argmax(y_test, axis=1), np.argmax(y_pred, axis=1)))
scipy_score = classification_report(y_aggr_test,
y_aggr_pred,
output_dict=True)['accuracy']
print('short {:.2f} and aggr {:.2f}'.format(score[1], scipy_score))
# save model
open("Models\\model_cnn2d.json", "w").write(model.to_json())
pickle.dump(model.get_config(), open("Models\\model_cnn2d.pickle", "wb"))
model.save_weights("Models\\model_cnn2d.h5")
# results
return score[1]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3) neural_network = Sequential() neural_network.add(Dense(activation = 'relu', input_dim = num_col - 1, units=6)) neural_network.add(Dense(activation = 'relu', units=6)) neural_network.add(Dense(activation = 'relu', units=6)) neural_network.add(Dense(activation = 'relu', units=6)) neural_network.add(Dense(activation = 'relu', units=6)) neural_network.add(Dense(activation = 'relu', units=6)) neural_network.add(Dense(activation = 'sigmoid', units=1)) neural_network.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy']) neural_network.fit(X_train, y_train, batch_size = 5, epochs = 5) y_pred = neural_network.predict(X_test) y_pred = (y_pred > 0.5) print(neural_network.get_config()) cm = confusion_matrix(y_test, y_pred) #Random Forest df3 = "/Users/Vartika_Bisht/Desktop/df_CNN.csv" RF_dataframe = pd.read_csv(df3) print(RF_dataframe) print(RF_dataframe.columns) num_col = len(RF_dataframe.columns) X = RF_dataframe.drop(labels=['c', 't2'], axis=1) y = RF_dataframe[['c', 't2']] X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)
