def train_model(train_data, train_labels, test_data, test_labels, epochs):
input_shape = (28, 28, 1)
my_model = Sequential()
my_model.add(
Conv2D(filters=32,
kernel_size=(3, 3),
activation="relu",
input_shape=input_shape))
my_model.add(Conv2D(filters=64, kernel_size=(3, 3), activation="relu"))
my_model.add(MaxPooling2D())
my_model.add(Dropout(0.25))
my_model.add(Flatten())
my_model.add(Dropout(0.5))
my_model.add(Dense(128, activation='relu'))
my_model.add(Dense(10, activation='softmax'))
my_model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adadelta(),
metrics=['accuracy'])
my_model.fit(train_data.reshape((60000, 28, 28, 1)),
train_labels,
batch_size=128,
epochs=epochs,
verbose=1,
validation_data=(test_data.reshape(
(10000, 28, 28, 1)), test_labels))
return my_model
def learn_model(x_train, y_train, x_test, y_test, take_components, save_path=None, do_pca=False):
# pca select main features
if do_pca:
pca = PCA(n_components=take_components)
print("Compute pca relevant features with " + str(take_components) + " percent of variance")
previous_dims = len(x_train[0])
x_train = pca.fit_transform(x_train)
x_test = pca.transform(x_test)
print(str(len(x_train[0])) + " dims are used from initially " + str(previous_dims))
# expand dims
x_train = np.expand_dims(x_train, axis=2)
x_test = np.expand_dims(x_test, axis=2)
# change label to categorical
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
# build model
model = Sequential()
model.add(Conv1D(256, 8, padding='same', input_shape=(x_train.shape[1], 1)))
model.add(Activation('relu'))
model.add(Conv1D(256, 8, padding='same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.6))
model.add(Conv1D(128, 8, padding='same'))
model.add(Activation('relu'))
model.add(Conv1D(128, 8, padding='same'))
model.add(Activation('relu'))
model.add(Conv1D(128, 8, padding='same'))
model.add(Activation('relu'))
model.add(Conv1D(128, 8, padding='same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.6))
model.add(Conv1D(64, 8, padding='same'))
model.add(Activation('relu'))
model.add(Conv1D(64, 8, padding='same'))
model.add(Activation('relu'))
model.add(Flatten())
model.add(Dense(4096, activation='relu'))
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.6))
model.add(Dense(2))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.SGD(lr=0.001, momentum=0.9, decay=0.0),
metrics=['acc'])
# fit network
model.fit(x_train, y_train, batch_size=16, epochs=33)
# evaluate model
_, accuracy = model.evaluate(x_test, y_test)
# save model
if save_path is not None:
model.save(save_path)
return accuracy
def prueba_2():
cantidad_twits=10
# define class twits
test = load_test()
twits = preprocesing(test[:cantidad_twits, 0])
print(f"\ntwiters:\n{twits}")
# define class labels
labels = test[:cantidad_twits, 1].astype('float32')
print(f"\nlabels:\n{labels}")
# prepare tokenizer
t = Tokenizer()
t.fit_on_texts(twits)
vocab_size = len(t.word_index) + 1
# integer encode the documents
encoded_twits = t.texts_to_sequences(twits)
print(f"\nencoded_twits:\n{encoded_twits}")
# pad documents to a max length of 4 words
# Calculo largo maximo
mylen = np.vectorize(len)
lens=mylen(encoded_twits)
max_len=max(lens)
#TODO: Contar el twtit mas largo
max_length = max_len
padded_twits = pad_sequences(encoded_twits, maxlen=max_length, padding='post')
print(f"\npadded_twits:\n{padded_twits}")
# load the whole embedding into memory
embeddings_index = dict()
f = open('fasttext.es.300.txt')
for line in f:
values = line.split()
word = values[0]
coefs = np.asarray(values[1:], dtype='float32')
embeddings_index[word] = coefs
f.close()
print('Loaded %s word vectors.' % len(embeddings_index))
# create a weight matrix for words in training docs
embedding_matrix = np.zeros((vocab_size, 300))
for word, i in t.word_index.items():
embedding_vector = embeddings_index.get(word)
if embedding_vector is not None:
embedding_matrix[i] = embedding_vector
# define model
model = Sequential()
e = Embedding(vocab_size, 300, weights=[embedding_matrix], input_length=max_length, trainable=False)
model.add(e)
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
# compile the model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# summarize the model
print(model.summary())
# fit the model
model.fit(padded_twits, labels, epochs=50, verbose=0)
# evaluate the model
loss, accuracy = model.evaluate(padded_twits, labels, verbose=0)
print('Accuracy: %f' % (accuracy * 100))
def LSTM_model(n_steps, n_features, X, y): model = Sequential() model.add(LSTM(30, activation='sigmoid', input_shape=(n_steps, n_features))) model.add(Dropout(0.3)) model.add(Dense(30)) model.compile(optimizer='adam', loss='mse') model.fit(X, y, epochs=50, verbose=0) return model
def train_model_2BLSTM_variableSequenceLength(path, subjectID, modelType, MLtechnique, features, labels, dw, batch_size, patience, LSTMunits=30): """ FUNCTION NAME: train_model_2BLSTM_variableSequenceLength This function trains a bidirectional LSTM model with 2 hidden layers when input sequences have difference length from one sample to the other. In the first step, input sequences are arranged into a tensor of the same length using zero padding. When data is ready, the bidirectional LSTM is trained. INPUT: ------ -> path: full path where to store the trained model -> subjectID: integer indicating the ID of the subject being analyzed -> modelType: type of model to train -> MLtechnique: technique to use to train the model -> features: matrix of features to train the model -> labels: matrix of labels to train the model -> dw: factor used when downsampling the available data -> batch_size: value for batch_size parameter -> patience: value for patience parameter -> LSTMunits: number of units of the LSTM OUTPUT: ------- """ epochs = 200 verbose = 1 if (dw == 1): modelName = path + 'Model_Subject' + str(subjectID) + '_' + MLtechnique + '_LSTMunits' + str(LSTMunits) + '_BatchSize' + str(batch_size) + '_Patience' + str(patience) + '_' + modelType else: modelName = path + 'Model_Subject' + str(subjectID) + '_DW' + str(dw) + '_' + MLtechnique + '_LSTMunits' + str(LSTMunits) + '_BatchSize' + str(batch_size) + '_Patience' + str(patience) + '_' + modelType # Convert data matrices to tensors T_features, T_labels = DE.dataMatrices2tensors(features, labels, modelType) # Define the Bidirectional LSTM model = Sequential([ Masking(mask_value = 0., input_shape=(None,DE.get_3DtensorDimensions(T_features)[2])), Bidirectional(LSTM(LSTMunits, activation='tanh', return_sequences=True)), Bidirectional(LSTM(int(LSTMunits/2), activation='tanh', return_sequences=True)), TimeDistributed(Dense(1, activation='linear')) ]) model.compile(optimizer=Adam(),loss=loss_CCC) earlyStop = EarlyStopping(monitor='loss', patience=patience) callbacks_list = [earlyStop] # Train the model model.fit(T_features, T_labels, batch_size=batch_size, epochs=epochs, verbose=verbose, callbacks = callbacks_list, validation_split = 0) print '-> Saving model ..' # Save model model.save(modelName + '.h5') print '<- Model saved'
class DNN(BaseTrainer):
@Decorator.log(True)
def load_data(self, **dict):
print(dict)
self.traindata = pd.read_csv(dict['train'], header=None)
self.testdata = pd.read_csv(dict['test'], header=None)
X = self.traindata.iloc[:, 1:42]
Y = self.traindata.iloc[:, 0]
C = self.testdata.iloc[:, 0]
T = self.testdata.iloc[:, 1:42]
trainX = np.array(X)
testT = np.array(T)
trainX.astype(float)
testT.astype(float)
scaler = Normalizer().fit(trainX)
trainX = scaler.transform(trainX)
scaler = Normalizer().fit(testT)
testT = scaler.transform(testT)
self.y_train = np.array(Y)
self.y_test = np.array(C)
self.X_train = np.array(trainX)
self.X_test = np.array(testT)
def train(self):
batch_size = 64
nb_epoch = 100
if self.has_train:
nb_epoch = nb_epoch - self.epoch
print('new epoch', nb_epoch)
self.model.fit(self.X_train,
self.y_train,
batch_size=batch_size,
epochs=nb_epoch,
callbacks=[self.checkpointer, self.csv_logger])
else:
# 1. define the network
self.model = Sequential()
self.model.add(Dense(1024, input_dim=41, activation='relu'))
self.model.add(Dropout(0.01))
self.model.add(Dense(1))
self.model.add(Activation('sigmoid'))
self.model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
self.model.fit(self.X_train,
self.y_train,
batch_size=batch_size,
epochs=nb_epoch,
callbacks=[self.checkpointer, self.csv_logger])
self.model.save("./dnn1layer_model.hdf5")
score, acc = self.model.evaluate(self.X_test, self.y_test)
print('Test score:', score)
print('Test accuracy', acc)
class PointwiseNN(Ranker):
def __init__(self):
self.model = Sequential()
self.model.add(Dense(128))
self.model.add(Dense(1))
self.model.compile(optimizer='adam', loss='mse')
super().__init__()
def fit(self, X_train, y_train):
self.model.fit(x=X_train, y=y_train)
def predict(self, X) -> ndarray:
return self.model.predict(x=X)
def sequential():
model = Sequential()
model.add(Dense(28, input_dim=784, activation=relu))
model.add(Dense(28, activation=relu))
model.add(Dense(10, activation=tf.nn.softmax))
model.compile(optimizer=Adam(0.001),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(X, y, epochs=10, batch_size=10)
y_pred = model.predict(test_X)
print(y_pred)
def model(x_test, x_train, y_test, y_train):
model = Sequential()
model_choice = {{choice(['one', 'two'])}}
if model_choice == 'one':
model.add(Conv2D(64, kernel_size=3, activation='relu',padding='same', input_shape=(img_rows, img_cols, color_type)))
model.add(Conv2D(128, kernel_size=3, activation='relu',padding='same'))
model.add(MaxPooling2D(pool_size=2,strides=2))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Conv2D(256, kernel_size=3, activation='relu'))
model.add(Conv2D(512, kernel_size=3, activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=2,strides=2))
model.add(Dropout({{uniform(0, 1)}}))
elif model_choice == 'two':
model.add(Conv2D(64, kernel_size=3, activation='relu',padding='same', input_shape=(img_rows, img_cols, color_type)))
model.add(Conv2D(128, kernel_size=3, activation='relu',padding='same'))
model.add(MaxPooling2D(pool_size=2,strides=2))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Conv2D(256, kernel_size=3, activation='relu'))
model.add(Conv2D(512, kernel_size=3, activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=2,strides=2))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Flatten())
model.add(Dense({{choice([256, 512,1024])}}, activation='relu'))
model.add(BatchNormalization())
model.add(Dropout({{uniform(0, 1)}}))
choiceval = {{choice(['one', 'two'])}}
if choiceval == 'two':
model.add(Dense({{choice([256, 512,1024])}}, activation='relu'))
model.add(BatchNormalization())
model.add(Dropout({{uniform(0, 1)}}))
model.add(Dense(10, activation='softmax'))
adam = keras.optimizers.Adam(lr=0.001)
model.compile(loss='categorical_crossentropy', metrics=['accuracy'],
optimizer=adam)
model.fit(x_train, y_train,
batch_size=256,
nb_epoch=15,
verbose=2,
validation_data=(x_test, y_test))
score, acc = model.evaluate(x_test, y_test, verbose=0)
print('Val accuracy:', acc)
return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def mlp_model(x_train, y_train, x_val, y_val, params):
model = Sequential()
model.add(
Dense(params['layer_size'],
activation=params['activation'],
input_dim=x_train.shape[1],
kernel_regularizer=l2(params['regularization'])))
model.add(Dropout(params['dropout']))
for i in range(params['layers'] - 1):
model.add(
Dense(params['layer_size'],
activation=params['activation'],
kernel_regularizer=l2(params['regularization'])))
model.add(Dropout(params['dropout']))
model.add(Dense(2, activation='softmax'))
model.compile(
optimizer=params['optimizer'](params['lr']),
loss=params['loss_functions'],
# loss=params['loss_functions']([params['weights1'], params['weights2']]),
metrics=['accuracy', Recall(), Precision(), f1])
history = model.fit(x_train,
y_train,
batch_size=params['batch_size'],
validation_data=(x_val, y_val),
epochs=100,
callbacks=[
EarlyStopping(monitor='val_acc',
patience=5,
min_delta=0.01)
],
verbose=0)
return history, model
class BiLSTM(NNBaseModel):
def train(self):
batch_size = 64
units = 100
embedding_matrix = np.zeros((self.vocab_size, 100))
for word, index in self.tk.word_index.items():
embedding_vector = self.word2vec.get(word)
if embedding_vector is not None:
embedding_matrix[index] = embedding_vector
self.model = Sequential()
self.model.add(
Embedding(self.vocab_size,
units,
weights=[embedding_matrix],
trainable=False))
self.model.add(
Bidirectional(LSTM(units, return_sequences=True, dropout=0.2)))
self.model.add(Bidirectional(LSTM(units, dropout=0.2)))
self.model.add(Dense(self.output_size, activation='sigmoid'))
print(self.model.summary())
self.model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['acc'])
history = self.model.fit(self.X_train,
self.y_train,
epochs=100,
batch_size=batch_size,
verbose=1)
def train_model(lowdata, labels, results, p):
# Print parameters
print('\n' + ' '.join(map(str, p)))
# Split data
#X_train, X_test, y_train, y_test = train_test_split(lowdata, labels, test_size=0.2, random_state=29, shuffle=True)
# Cross validation
n_split = 5
scores = []
for train_index, test_index in KFold(n_split).split(lowdata):
X_train, X_test = lowdata[train_index], lowdata[test_index]
y_train, y_test = labels[train_index], labels[test_index]
# Define model (complexity is a function of input dimensionality)
if p[5] > 8:
k = 32
elif p[5] >= 3:
k = 8
else:
k = 3
model = Sequential()
model.add(
Dense(2 * k, activation='relu',
input_dim=X_train.shape[1]))
model.add(Dropout(0.5))
model.add(Dense(k, activation='relu'))
model.add(Dense(n_classes, activation='softmax'))
loss = categorical_crossentropy
#optimizer = Adadelta(lr=0.0005)
optimizer = Adam(lr=0.0005)
model.compile(loss=loss,
optimizer=optimizer,
metrics=['categorical_accuracy'])
#print(model.summary())
# Train model
n_epochs = 30
history = model.fit(X_train,
y_train,
batch_size=32,
epochs=n_epochs,
verbose=0,
validation_data=(X_test, y_test))
#plot(history)
scores.append(eval_metrics(model, X_test, y_test, class_names))
# Evaluate model
results = {
'params': p,
'history': history.history,
'score': scores
}
return results
def train_model(X, Y, X_test, Y_test, nr_steps):
n_batch = 14000
n_epoch = 1000
n_neurons = 30
# design network
model = Sequential()
model.add(
LSTM(units=n_neurons,
return_sequences=True,
batch_input_shape=(n_batch, X.shape[1], X.shape[2]),
stateful=True))
model.add(Dropout(0.2))
# Adding a second LSTM layer and Dropout layer
model.add(LSTM(units=n_neurons, return_sequences=True))
model.add(Dropout(0.2))
model.add(Dense(1))
optimizer = optimizers.Adam(clipvalue=0.5)
model.compile(loss='mean_squared_error',
optimizer=optimizer,
metrics=['acc'])
for z in range(0, len(X) // 4, n_batch):
xChunk = X[z:z + n_batch]
yChunk = Y[z:z + n_batch]
model.fit(xChunk,
yChunk,
epochs=n_epoch,
batch_size=n_batch,
verbose=1,
shuffle=False)
model.reset_states()
yhat = model.predict(X_test[0:n_batch, :, :],
batch_size=n_batch,
steps=nr_steps)
for i in range(len(Y_test[0:n_batch])):
print("Extected : " + str(Y[i]) + " but actually: " + str(yhat[i][0]))
error = 1
for j in range(len(Y_test[0:n_batch])):
error = error * (abs(Y_test[j] - yhat[j][0]) / yhat[j][0]) * 100
print("error: " + str(error) + "%")
class Agent:
def __init__(self):
#Here we'll create the brain of our agent, a deep neural network with Keras
self.model = Sequential()
self.q_targets = []
self.model.add(kl.Dense(10, input_dim=27))
self.model.add(kl.Activation('relu'))
self.model.add(kl.Dense(4, input_dim=10))
self.model.add(kl.Activation('tanh'))
self.model.compile(optimizer="adam", loss='MSE', metrics=['accuracy'])
def pick_action(
self, state,
eps): #Epsilon is the probability that wa take a random action
#we chose if we take a random action
if np.random.rand() < eps:
return np.random.randint(4)
#Else we take the best action acording to our Neural network(NN)
else:
return int(
np.argmax(self.model.predict(np.reshape(state, (-1, 27)))))
def train_model(self, states0, states1, actions, rewards):
length = np.min((len(actions), 1000))
self.q_targets = []
prediction = self.model.predict(np.reshape(states0, (-1, 27)))
for n in range(length):
action_mask = np.array([1, 1, 1, 1])
action_mask = np.logical_xor(action_mask, actions[n])
pred = self.model.predict(np.reshape(states1[n], (-1, 27)))
#print(pred.shape)
q_target = prediction[n] * action_mask + actions[n] * (
rewards[n]) # + 0.99*pred[0][np.argmax(pred)] )
self.q_targets.append(q_target)
print(states0[n], actions[n], rewards[n], q_target)
self.model.fit(
np.reshape(states0, (length, 27)),
np.array(self.q_targets),
batch_size=1,
)
def build_model(train_dataset, train_labels, local_testing):
"""
Function for building the LSTM model and setting hyperparameters
:param train_dataset: numpy array with all necessary variables, does not contain canteen values
:param train_labels: the canteen values that is the solution/real values.
:param local_testing: bool value, will print training data if set to True.
:return: The model that is built and the training history
"""
model = Sequential()
model.add(
LSTM(5, input_shape=(train_dataset.shape[1], train_dataset.shape[2])))
model.add(Dense(1))
optimizer = optimizers.Adam(lr=0.01)
model.compile(
loss="mean_squared_error",
optimizer=optimizer,
metrics=["mean_absolute_error", "mean_squared_error"],
)
if local_testing:
history = model.fit(
train_dataset,
train_labels,
epochs=200,
batch_size=20,
validation_split=0.2,
verbose=2,
shuffle=False,
)
else:
history = model.fit(
train_dataset,
train_labels,
epochs=200,
batch_size=20,
validation_split=0.2,
verbose=0,
shuffle=False,
)
return model, history
def ApplyCnn(X32_train, X32_test, Y32_train):
model_CNN = Sequential()
model_CNN.add(
Conv2D(64,
kernel_size=3,
activation='relu',
input_shape=(X3_train.shape[1], X3_train.shape[2], 1)))
model_CNN.add(MaxPooling2D(pool_size=(2, 2)))
model_CNN.add(Conv2D(32, kernel_size=3, activation='relu'))
model_CNN.add(MaxPooling2D(pool_size=(2, 2)))
model_CNN.add(Conv2D(16, kernel_size=3, activation='relu'))
model_CNN.add(MaxPooling2D(pool_size=(2, 2)))
model_CNN.add(Flatten())
model_CNN.add(Dense(10, activation='softmax'))
model_CNN.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
model_CNN.fit(X32_train, Y32_train, epochs=10, verbose=0)
return predict(X32_test, model_CNN)
def fit_mlp(x_train,
y_train,
conf,
seed=3,
epochs=1500,
batch_size=300,
lr=0.05):
"""
:param x_train: training data
:param y_train: training target
:param conf: model structure
:param seed: seed
:param epochs: number of epochs (using early stopping)
:param batch_size: batch size
:param lr: learning rate
:return: model and history
"""
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss',
mode='min',
verbose=0,
patience=3,
restore_best_weights=True)
model = Sequential()
for n, a in conf:
model.add(
Dense(
n,
activation=a,
kernel_initializer=keras.initializers.glorot_normal(seed=seed),
bias_initializer='zeros'))
opt = keras.optimizers.Adam(lr=lr)
if conf[-1][1] == 'linear':
model.compile(loss=keras.losses.mse, optimizer=opt)
elif conf[-1][1] == 'sigmoid':
model.compile(loss=keras.losses.binary_crossentropy,
optimizer=opt,
metrics=['accuracy'])
else:
model.compile(loss=keras.losses.sparse_categorical_crossentropy,
optimizer=opt,
metrics=['accuracy'])
history = model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
validation_split=0.2,
verbose=0,
shuffle=False,
callbacks=[early_stop])
return model, history
def main():
dataset = Tracking(dataset_dir, num_validation_y=0.2, seed=123)
train_x, train_y, _ = dataset.read_train()
print("Train set size: %d images, %d identities" %
(len(train_x), len(np.unique(train_y))))
valid_x, valid_y, camera_indices = dataset.read_validation()
print("Validation set size: %d images, %d identities" %
(len(valid_x), len(np.unique(valid_y))))
train = extract_features(train_x)
# print(list(zip(train,train_y[:20])))
# data = zip(train,train_y[:20])
# data = list(data)
# # save to file
# dump(train, open('train_x.pkl', 'wb'))
# lookback = 3
# pre = 1
# inputs = np.zeros((len(data) - lookback, lookback, 3))
# labels = np.zeros(len(data) - lookback)
# for i in range(lookback, len(data) - (pre)):
# inputs[i - lookback] = data[0][i - lookback:i]
# labels[i - lookback] = data[1][i + pre]
# inputs = inputs.reshape(-1, lookback, 1)
# labels = labels.reshape(-1, 1)
# print("input" ,inputs,"lavel",labels)
train = np.asarray((train))
train_y = np.asarray((train_y))
print(train_y.shape)
print(train.shape)
model = Sequential()
model.add(LSTM(units=64, activation='elu', input_shape=(None, 1)))
model.add(Dense(64, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
opt = keras.optimizers.Adam(learning_rate=0.001)
model.compile(loss="categorical_crossentropy",
optimizer=opt,
metrics=["accuracy"])
print(model.summary())
train_data = tf.data.Dataset.from_tensor_slices((train, train_y[:20]))
model.fit(train_data, epochs=10, batch_size=64)
def prueba_1():
docs = ['Well done!',
'Good work',
'Great effort',
'nice work',
'Excellent!',
'Weak',
'Poor effort!',
'not good',
'poor work',
'Could have done better.']
# define class labels
labels = np.array([1,1,1,1,1,0,0,0,0,0])
# integer encode the documents
vocab_size = 50
encoded_docs = [one_hot(d, vocab_size) for d in docs]
print(encoded_docs)
# pad documents to a max length of 4 words
max_length = 4
padded_docs = pad_sequences(encoded_docs, maxlen=max_length, padding='post')
print(padded_docs)
# define the model
model = Sequential()
model.add(Embedding(vocab_size, 8, input_length=max_length))
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
# compile the model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# summarize the model
print(model.summary())
# fit the model
model.fit(padded_docs, labels, epochs=50, verbose=0)
# evaluate the model
loss, accuracy = model.evaluate(padded_docs, labels, verbose=0)
print('Accuracy: %f' % (accuracy*100))
def variant_default(cls, x_train, y_train, x_val, y_val, params):
model = Sequential()
model.add(
TimeDistributed(
Flatten(input_shape=(x_train.shape[1],
x_train.shape[2] * x_train.shape[3]))))
model.add(
TimeDistributed(
Flatten(input_shape=(x_train.shape[1],
x_train.shape[2] * x_train.shape[3]))))
for i in range(params["lstm_layers"] - 1):
model.add(
LSTM(
params["hidden_size"],
return_sequences=True,
activation=params["activation"],
))
model.add(LSTM(params["hidden_size"], activation=params["activation"]))
if params["dropout"] > 0:
model.add(Dropout(params["dropout"]))
model.add(Dense(10, activation=params["output_activation"]))
model.compile(
optimizer=tf.keras.optimizers.SGD(lr=params["lr"],
momentum=params["momentum"]),
loss="sparse_categorical_crossentropy",
metrics=["accuracy"],
)
history = model.fit(
x_train,
y_train,
validation_data=(x_val, y_val),
epochs=params["epochs"],
batch_size=params["batch_size"],
verbose=1,
callbacks=[
tf.keras.callbacks.TensorBoard(
"./logs/" + "lstm_default/" +
"-".join("=".join((str(k), str(v)))
for k, v in params.items()) +
"-ts={}".format(str(time.time())))
],
)
return history, model
def trainnet(self):
classifier = Sequential([
layers.Dense(4,
activation='relu',
kernel_initializer='random_normal',
input_dim=8),
layers.Dense(4,
activation='relu',
kernel_initializer='random_normal'),
layers.Dense(1,
activation='sigmoid',
kernel_initializer='random_normal')
])
# Compiling the neural network
classifier.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
# Fitting the data to the training dataset
classifier.fit(self.X_train, self.y_train, batch_size=10, epochs=100)
eval_model = classifier.evaluate(self.X_train, self.y_train)
print(eval_model)
nethandler().savenet(model=classifier)
def train_classifier():
data = get_data()
classifier = Sequential()
classifier.add(
Dense(100,
activation=tf.nn.relu,
input_shape=(FLAGS.sentence_embedding_size, )))
for i in range(1 - 1):
classifier.add(
Dense(100,
activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(0.3)))
classifier.add(Dropout(0.5))
classifier.add(Dense(2, activation='softmax'))
classifier.compile(optimizer=Adagrad(0.01),
loss='categorical_crossentropy',
metrics=['accuracy',
Recall(),
Precision(), f1])
classifier.summary()
helper._print_header('Training classifier')
classifier.fit(data['train'][0],
data['train'][1],
batch_size=FLAGS.classifier_batch_size,
validation_data=(data['val'][0], data['val'][1]),
epochs=200,
callbacks=[
EarlyStopping(monitor='val_accuracy',
patience=25,
min_delta=0.01),
SaveBestModelCallback()
],
verbose=2)
def test_crf_viterbi_accuracy(get_random_data):
nb_samples = 2
timesteps = 10
embedding_dim = 4
output_dim = 5
embedding_num = 12
crf_loss_instance = ConditionalRandomFieldLoss()
x, y = get_random_data(nb_samples,
timesteps,
x_high=embedding_num,
y_high=output_dim)
# right padding; left padding is not supported due to the tf.contrib.crf
x[0, -4:] = 0
# test with masking, fix length
model = Sequential()
model.add(
Embedding(embedding_num,
embedding_dim,
input_length=timesteps,
mask_zero=True))
model.add(CRF(output_dim, name="crf_layer"))
model.compile(optimizer='rmsprop',
loss={"crf_layer": crf_loss_instance},
metrics=[crf_viterbi_accuracy])
model.fit(x, y, epochs=1, batch_size=10)
# test viterbi_acc
y_pred = model.predict(x)
_, v_acc = model.evaluate(x, y)
np_acc = (y_pred[x > 0] == y[x > 0]).astype('float32').mean()
print(v_acc, np_acc)
assert np.abs(v_acc - np_acc) < 1e-4
class SimpleDense(NNBaseModel):
def train(self):
self.model = Sequential()
self.model.add(Embedding(self.vocab_size, 16))
self.model.add(GlobalAveragePooling1D())
self.model.add(Dense(16, activation=tf.nn.relu))
self.model.add(Dense(self.output_size, activation=tf.nn.sigmoid))
print(self.model.summary())
self.model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['acc'])
history = self.model.fit(self.X_train,
self.y_train,
epochs=100,
batch_size=64,
verbose=1)
def test_with_keras(self):
# Comentar para usar GPU
tf.config.experimental.set_visible_devices([], 'GPU')
dataset = DatasetUtils(path='./resources/train_data.csv')
train, test = dataset.split(80)
y_train = train[:, -1]
x_train = train[:, :-1]
y_test = test[:, -1][:, None]
x_test = test[:, :-1]
model = Sequential()
model.add(Dense(128, input_dim=x_train.shape[1]))
model.add(Dense(128, activation='relu'))
model.add(Dense(16, activation='relu'))
model.add(Dense(1, activation="sigmoid"))
metrics = [
keras.metrics.Precision(name="precision"),
keras.metrics.Recall(name="recall"),
keras.metrics.BinaryAccuracy(name="Binary Accuracy")
]
model.compile(optimizer=keras.optimizers.Adam(1e-4),
loss="binary_crossentropy",
metrics=metrics)
history = model.fit(x_train,
y_train,
batch_size=16,
epochs=200,
verbose=1,
validation_data=(x_test, y_test))
PlotUtils().plotHistory(history=history, metrics=metrics, plt=plt)
plt.figure()
index_1 = (y_test == 1).reshape(len(y_test))
index_0 = (y_test == 0).reshape(len(y_test))
plt.scatter(x_test[index_1, 0], x_test[index_1, 1], c='red')
plt.scatter(x_test[index_0, 0], x_test[index_0, 1], c='blue')
PlotUtils().plotDecisionBoundry(x_test, model, plt)
plt.show()
def train(self):
model = Sequential()
model.add(
DenseNet201(weights="imagenet",
include_top=False,
input_shape=self.input_shape))
model.add(Flatten())
model.add(Dense(1024, activation="relu"))
model.add(Dense(1, activation="sigmoid"))
plot_model(model)
model.summary()
model.compile(optimizer=Adam(learning_rate=1e-3),
loss="binary_crossentropy",
metrics=['accuracy'])
history = model.fit(self.train_data,
epochs=100,
verbose=1,
validation_data=self.valid_data)
return model, history
def test_masking_fixed_length(get_random_data):
nb_samples = 2
timesteps = 10
embedding_dim = 4
output_dim = 5
embedding_num = 12
crf_loss_instance = ConditionalRandomFieldLoss()
x, y = get_random_data(nb_samples,
timesteps,
x_high=embedding_num,
y_high=output_dim)
# right padding; left padding is not supported due to the tf.contrib.crf
x[0, -4:] = 0
# test with masking, fix length
model = Sequential()
model.add(
Embedding(embedding_num,
embedding_dim,
input_length=timesteps,
mask_zero=True))
model.add(CRF(output_dim, name="crf_layer"))
model.compile(optimizer='adam', loss={"crf_layer": crf_loss_instance})
model.fit(x, y, epochs=1, batch_size=1)
model.fit(x, y, epochs=1, batch_size=2)
model.fit(x, y, epochs=1, batch_size=3)
model.fit(x, y, epochs=1)
# check mask
y_pred = model.predict(x)
assert (y_pred[0, -4:] == 0).all() # right padding
# left padding not working currently due to the tf.contrib.crf.*
# assert (y_pred[1, :5] == 0).all()
# test saving and loading model
MODEL_PERSISTENCE_PATH = './test_saving_crf_model.h5'
model.save(MODEL_PERSISTENCE_PATH)
load_model(MODEL_PERSISTENCE_PATH, custom_objects={'CRF': CRF})
try:
os.remove(MODEL_PERSISTENCE_PATH)
except OSError:
pass
class AudioFeaturesModel:
def __init__(self, model_name, le, layers):
self.le = le
self.model = Sequential(name=model_name)
# Builds layers based on the structure in model_structures
for layer in layers:
self.model.add(layer)
def compile(self):
"""Compile the model and print the structure"""
self.model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer='adam')
self.model.summary()
def test_model(self, x_data, y_data):
"""Calculate the model's accuracy on the input dataset"""
score = self.model.evaluate(x_data, y_data, verbose=0)
accuracy = 100 * score[1]
return accuracy
def train_model(self, x_train, y_train, x_val, y_val):
"""Train and save the model"""
early_stopping = EarlyStopping(monitor='val_loss', patience=sounds_config.patience, mode='min')
checkpointer = ModelCheckpoint(filepath=f'{sounds_config.sounds_model_dir}/{self.model.name}.hdf5', verbose=1,
save_best_only=True)
history = self.model.fit(x_train, y_train, batch_size=sounds_config.num_batch_size,
epochs=sounds_config.num_epochs, validation_data=(x_val, y_val),
callbacks=[checkpointer, early_stopping], verbose=1)
self.le.save(self.model.name)
return history
def calculate_confusion_matrix(self, x_test, y_test):
"""Calculate the probabilities required for the confusion matrix and create a dataframe"""
y_pred = self.model.predict_classes(x_test)
y_test = argmax(y_test, axis=1)
con_mat = confusion_matrix(labels=y_test, predictions=y_pred).numpy()
con_mat_norm = np.around(con_mat.astype('float') / con_mat.sum(axis=1)[:, np.newaxis], decimals=2)
classes = self.le.inverse_transform(list(range(0, self.le.encoded_labels.shape[1])))
return pd.DataFrame(con_mat_norm, index=classes, columns=classes)
class ImageFeaturesModel:
def __init__(self, model_name, le, layers):
self.le = le
self.model = Sequential(name=model_name)
for layer in layers:
self.model.add(layer)
def compile(self):
self.model.compile(loss='categorical_crossentropy',
metrics=['accuracy'],
optimizer='adam')
self.model.summary()
def test_model(self, x_data, y_data):
score = self.model.evaluate(x_data, y_data, verbose=0)
accuracy = 100 * score[1]
return accuracy
def train_model(self, x_train, y_train, x_val, y_val):
early_stop = EarlyStopping(monitor='val_loss',
mode='min',
verbose=1,
patience=5)
checkpointer = ModelCheckpoint(filepath=f'{self.model.name}.hdf5',
verbose=1,
save_best_only=True)
history = self.model.fit(x_train,
y_train,
batch_size=config.num_batch_size,
epochs=config.num_epochs,
validation_data=(x_val, y_val),
callbacks=[early_stop, checkpointer],
verbose=1)
self.le.save(self.model.name)
return history
def test_masking_fixed_length(get_random_data):
nb_samples = 2
timesteps = 10
embedding_dim = 4
output_dim = 5
embedding_num = 12
crf_loss_instance = ConditionalRandomFieldLoss()
x, y = get_random_data(nb_samples,
timesteps,
x_high=embedding_num,
y_high=output_dim)
# test with no masking, fix length
model = Sequential()
model.add(Embedding(embedding_num, embedding_dim, input_length=timesteps))
model.add(CRF(output_dim, name="crf_layer"))
model.compile(optimizer='adam', loss={"crf_layer": crf_loss_instance})
model.fit(x, y, epochs=1, batch_size=1)
model.fit(x, y, epochs=1, batch_size=2)
model.fit(x, y, epochs=1, batch_size=3)
model.fit(x, y, epochs=1)
# test saving and loading model
MODEL_PERSISTENCE_PATH = './test_saving_crf_model.h5'
model.save(MODEL_PERSISTENCE_PATH)
load_model(MODEL_PERSISTENCE_PATH,
custom_objects={
'CRF': CRF,
'crf_loss': crf_loss
})
try:
os.remove(MODEL_PERSISTENCE_PATH)
except OSError:
pass
