def train_model(model, X_train, y_train, name, config):
"""train
train a single model.
# Arguments
model: Model, NN model to train.
X_train: ndarray(number, 1, 4), Input data for train.
y_train: ndarray(number, ), result data for train.
(7776, 4, 1)
(7776,)
name: String, name of model.
config: Dict, parameter for train.
"""
opt = keras.optimizers.Adam(learning_rate=0.001)
# early = EarlyStopping(monitor='val_loss', patience=30, verbose=0, mode='auto')
model.compile(loss="mse", optimizer=opt, metrics=['mape'])
hist = model.fit(X_train,
y_train,
batch_size=config["batch"],
epochs=config["epochs"],
validation_split=0.05)
model.save('model/model_out/' + name + '.h5')
df = pd.DataFrame.from_dict(hist.history)
df.to_csv('model/model_loss/' + name + '_loss.csv',
encoding='utf-8',
index=False)
def train_model(model, X_train, y_train, name, config):
"""train
train a single model.
# Arguments
model: Model, NN model to train.
X_train: ndarray(number, lags), Input data for train.
y_train: ndarray(number, ), result data for train.
name: String, name of model.
config: Dict, parameter for train.
"""
mlflow.set_tracking_uri("http://127.0.0.1:5000")
tracking_uri = mlflow.get_tracking_uri()
print("Current tracking uri: {}".format(tracking_uri))
tags = {"usuario": "Anonymous"}
mlflow.set_experiment("traffic_flow-saes")
with mlflow.start_run() as run:
mlflow.set_tags(tags)
mlflow.keras.autolog()
model.compile(loss="mse", optimizer="rmsprop", metrics=['mape'])
#early = EarlyStopping(monitor='val_loss', patience=30, verbose=0, mode='auto')
hist = model.fit(X_train,
y_train,
batch_size=config["batch"],
epochs=config["epochs"],
validation_split=0.05)
model.save('model/' + name + '.h5')
df = pd.DataFrame.from_dict(hist.history)
df.to_csv('model/' + name + ' loss.csv', encoding='utf-8', index=False)
mlflow.log_param("Run_id", run.info.run_id)
def train_model(model, X_train, y_train, name, config):
"""train
train a single model.
# Arguments
model: Model, NN model to train.
X_train: ndarray(number, lags), Input data for train.
y_train: ndarray(number, ), result data for train.
name: String, name of model.
config: Dict, parameter for train.
"""
# Define the Keras TensorBoard callback.
logdir = os.path.join(
"logs",
"fit",
name,
'lstm_4_4',
datetime.now().strftime("%Y%m%d-%H%M"),
)
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)
model.compile(loss="mse", optimizer="adam", metrics=['mape'])
early = EarlyStopping(monitor='val_loss', patience=5, verbose=0, mode='auto')
hist = model.fit(
X_train, y_train,
batch_size=config["batch"],
epochs=config["epochs"],
validation_split=0.05,
callbacks=[tensorboard_callback, early])
print(name);
model.save('model/' + name + '4_layers_4' + '.h5')
df = pd.DataFrame.from_dict(hist.history)
df.to_csv('model/' + name +' loss.csv', encoding='utf-8', index=False)
def train_model(model,X_train,y_trian,name,config):
model.compile(loss='mse',optimizer='rmsprop',metrics=['mape'])
hist=model.fit(X_train,y_trian,
batch_size=config['batch'],
epochs=config['epochs'],
validation_split=0.05)
model.save('model/'+name+'.h5')
df=pd.DataFrame.from_dict(hist.history)
df.to_csv('model/'+name+'_loss.csv',encoding='utf-8',index=False)
def _train_test():
tag_folder = '../data/2015/training/event_tags/'
data_folder = '../data/2015/training/stanford_parse/'
data = get_data(tag_folder, data_folder)
if not combined:
train_data_context_x, train_data_context_pos_deprel, train_data_lemma_x, train_data_pos_deprel, train_data_children_pos_deprel, train_data_y = _get_data(
data)
else:
train_x1, train_y1 = _get_joint(data)
tag_folder = '../data/2015/eval/event_tags/'
data_folder = '../data/2015/eval/stanford_parse/'
data = get_data(tag_folder, data_folder)
if not combined:
test_data_context_x, test_data_context_pos_deprel, test_data_lemma_x, test_data_pos_deprel, test_data_children_pos_deprel, test_data_y = _get_data(
data)
else:
train_x2, train_y2 = _get_joint(data)
tag_folder = '../data/2016/event_tags/'
data_folder = '../data/2016/stanford_parse/'
data = get_data(tag_folder, data_folder)
train_x3, train_y3 = _get_joint(data)
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
if not combined:
model.fit([
np.array(train_data_context_x + test_data_context_x),
np.array(train_data_context_pos_deprel +
test_data_context_pos_deprel),
np.array(train_data_lemma_x + test_data_lemma_x),
np.array(train_data_pos_deprel + test_data_pos_deprel),
np.array(train_data_children_pos_deprel +
test_data_children_pos_deprel),
],
np.array(train_data_y + test_data_y),
batch_size=1500,
nb_epoch=15,
verbose=1,
shuffle=True)
else:
model.fit(np.array(train_x1 + train_x2 + train_x3),
np.array(train_y1 + train_y2 + train_y3),
batch_size=1000,
nb_epoch=15,
verbose=1,
shuffle=True)
model.save('realis_models/model_6.h5')
"""
def train_model(model, X_train, y_train, name, config):
model.compile(loss="mse", optimizer="rmsprop", metrics=['mape'])
hist = model.fit(X_train,
y_train,
batch_size=config["batch"],
epochs=config["epochs"],
validation_split=0.05)
temp = 'scaler'
model.save('model/' + name + temp + '.h5')
df = pd.DataFrame.from_dict(hist.history)
df.to_csv('model/' + name + temp + ' loss.csv',
encoding='utf-8',
index=False)
def train_model(model, X_train, y_train, name, config):
model.compile(loss="mse", optimizer="rmsprop", metrics=['mape'])
# early = EarlyStopping(monitor='val_loss', patience=30, verbose=0, mode='auto')
hist = model.fit(X_train,
y_train,
batch_size=config["batch"],
epochs=config["epochs"],
validation_split=0.05)
model.save('model/' + name + '.h5')
df = pd.DataFrame.from_dict(hist.history)
df.to_csv('model/' + name + ' loss.csv', encoding='utf-8', index=False)
def train_allDense_model(model, X_train, y_train, name, config, lag):
"""train
train a single model.
# Arguments
model: Model, NN model to train.
X_train: ndarray(number, lags), Input data for train.
y_train: ndarray(number, ), result data for train.
name: String, name of model.
config: Dict, parameter for train.
"""
model.compile(loss="mse", optimizer="rmsprop", metrics=['mape'])
hist = model.fit(X_train,
y_train,
batch_size=config["batch"],
epochs=config["epochs"])
model.save('model/' + name + '-' + str(lag) + '.h5')
def run(savefile, lr):
model = None
try:
model = load_model(savefile)
print('Loaded model from', savefile)
except OSError:
print('Saved model not found. Making new model...')
from model import model
optimizer = SGD(lr=lr,
clipnorm=1.,
decay=1e-6,
momentum=0.9,
nesterov=True)
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
train(model)
save(model)
def train_model(model, X_train, y_train, name, config, lag):
"""train
train a single model.
# Arguments
model: Model, NN model to train.
X_train: ndarray(number, lags), Input data for train.
y_train: ndarray(number, ), result data for train.
name: String, name of model.
config: Dict, parameter for train.
"""
model.compile(loss="mse", optimizer="rmsprop", metrics=['mape'])
# early = EarlyStopping(monitor='val_loss', patience=30, verbose=0, mode='auto')
hist = model.fit(X_train,
y_train,
batch_size=config["batch"],
epochs=config["epochs"],
validation_split=0.05)
model.save('model/' + name + '-' + str(lag) + '.h5')
def train_model(model, X_train, y_train, name, config):
"""train
train a single model.
# Arguments
model: Model, NN model to train.
X_train: ndarray(number, lags), Input data for train.
y_train: ndarray(number, ), result data for train.
name: String, name of model.
config: Dict, parameter for train.
"""
model.compile(loss="mse", optimizer="rmsprop", metrics=['rmse'])
# early = EarlyStopping(monitor='val_loss', patience=30, verbose=0, mode='auto')
hist = model.fit(X_train,
y_train,
batch_size=config["batch"],
epochs=config["epochs"],
validation_split=0.05)
model.save('model/' + name + '.h5')
df = pd.DataFrame.from_dict(hist.history)
df.to_csv('model/' + name + ' loss.csv', encoding='utf-8', index=False)
def train():
# compile the model with all of the training parameters (should be done *after* setting layers to non-trainable)
model.compile(optimizer=training_config['optimizer'], loss=training_config['loss_function'],
metrics=training_config['metrics'])
# create csv logger to store to CSV
csv_logging = callbacks.CSVLogger(training_filepath, separator=',', append=False)
model_checkpoint = callbacks.ModelCheckpoint(snapshots_dir + 'weights.{epoch:02d}-{val_loss:.2f}.hdf5',
monitor='val_loss', verbose=0,
save_best_only=False, save_weights_only=False,
mode='auto', period=1)
# train the model on the new data for a few epochs
print "training model with full model"
model.fit_generator(
train_generator,
samples_per_epoch=nb_train_samples,
nb_epoch=training_config['nb_epoch'],
validation_data=val_generator,
nb_val_samples=nb_val_samples,
callbacks=[csv_logging, model_checkpoint]
)
import keras
from keras.callbacks import CSVLogger
import path
from model import model
import batch
import logger
path.run.make()
run = path.run.loadCurrent()
model.compile(loss='categorical_crossentropy',
optimizer=keras.optimizers.Adam(),
metrics=['accuracy'])
model.fit_generator(batch.trainIterator,
validation_data=batch.validationIterator,
steps_per_epoch=batch.trainIterator.n / batch.size,
epochs=8,
callbacks=[
keras.callbacks.CSVLogger(run.log,
separator=',',
append=False)
])
model.save(run.model)
logger.addModelDiagram(run)
logger.addModelSummary(run)
logger.addAccuracyPlot(run)
'labels':
np.array([int(label) for label in labels])
})
train_dataset_info = np.array(train_dataset_info)
# images, labels = next(train_datagen)
# fig, ax = plt.subplots(1,5,figsize=(25,5))
# for i in range(5):
# ax[i].imshow(images[i])
# print('min: {0}, max: {1}'.format(images.min(), images.max()))
# fig.show()
model = model((299, 299, 3), output_shape=28)
model.compile(loss="categorical_crossentropy",
optimizer=Adam(1e-3),
metrics=["acc"])
checkpointer = ModelCheckpoint('./res/model/inceptionv4.model',
verbose=2,
save_best_only=True)
tensorboard = TensorBoard(log_dir='./res/logs',
histogram_freq=0,
batch_size=BATCH_SIZE,
write_graph=True,
write_grads=False,
write_images=False,
embeddings_freq=0,
embeddings_layer_names=None,
embeddings_metadata=None,
embeddings_data=None)
y_train = np.asarray(y_train) / 100
y_test = np.asarray(y_test) / 100
FR = FR_model()
# normalizing the dataset
train_set = normalize(train_set)
test_set = normalize(test_set)
# getting corresponding embeddings
train_set = FR(train_set)
test_set = FR(test_set)
model = model()
model.compile(tf.keras.optimizers.Adam(),
tf.keras.losses.MeanAbsoluteError(),
metrics=['accuracy'])
model.fit(train_set,
y_train,
batch_size=opt.b_size,
epochs=opt.epochs,
validation_data=(test_set, y_test))
optimizer = tf.keras.optimizers.Adam()
batch_size = opt.b_size
"""for i in range(opt.epochs):
n_batches=int(len(train_set)/opt.b_size)
loss_t=0
loss_vt=0
it=0
eval_fp = os.path.join(args.data_dir, "eval.tfrecord")
assert os.path.isfile(eval_fp), f"No validation file found at {eval_fp}"
params = params.Params(json_path)
model = model.StylometerModel(params)
log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
os.makedirs(log_dir)
train = dataset.training_dataset(train_fp, params)
validation = dataset.training_dataset(eval_fp, params)
model.compile(
optimizer="adam",
loss=
"categorical_crossentropy", # tf.contrib.losses.metric_learning.triplet_semihard_loss,
metrics=["accuracy"], # keras_metrics.precision(), keras_metrics.recall()
)
# Creating Keras callbacks
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir,
histogram_freq=1)
model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(
"training_checkpoints/weights.{epoch:02d}.hdf5", # -{val_loss:.2f}
save_freq=5,
monitor="val_loss",
)
os.makedirs("training_checkpoints/", exist_ok=True)
early_stopping_checkpoint = tf.keras.callbacks.EarlyStopping(patience=5)
history = model.fit(
from model import model
from preprocess.generator import train_generator, valid_generator
# Custom loss function
def huber_loss(y_true, y_pred):
return tf.losses.huber_loss(y_true, y_pred)
# Creating the model
model = model()
model.summary()
# Compile
adam = Adam(lr=1e-5, beta_1=0.9, beta_2=0.999, epsilon=1e-10, decay=0.0)
model.compile(optimizer=adam, loss=huber_loss)
# Train
epochs = 10
train_gen = train_generator(sample_per_batch=2, batch_number=1690)
val_gen = valid_generator(sample_per_batch=50, batch_number=10)
checkpoints = ModelCheckpoint('weights/weights{epoch:03d}.h5', save_weights_only=True, period=1)
history = model.fit_generator(train_gen, steps_per_epoch=1690, epochs=epochs, verbose=1, shuffle=True,
validation_data=val_gen, validation_steps=10,
callbacks=[checkpoints], max_queue_size=100)
with open('history.txt', 'a+') as f:
print(history.history, file=f)
print('All Done!')
from model import model, preprocess_input, smodel
from keras.optimizers import SGD
from keras.callbacks import ReduceLROnPlateau
from generator import Generator
import json
if __name__ == '__main__':
model = smodel()
opt = SGD(lr=0.01, momentum=0.9)
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['acc'])
print(model.summary())
model.load_weights('weights/classifier.h5')
listsss = json.load(open('list_withbndbx.json', 'r'))
train_gen = Generator(
listsss[:7211],
'/home/palm/PycharmProjects/DATA/Tanisorn/imgCarResize/',
preprocess_function=preprocess_input)
test_gen = Generator(
listsss[7211:],
'/home/palm/PycharmProjects/DATA/Tanisorn/imgCarResize/',
preprocess_function=preprocess_input)
reduce_lr_01 = ReduceLROnPlateau(monitor='val_1st_acc',
factor=0.2,
patience=5,
min_lr=0,
mode='max')
reduce_lr_02 = ReduceLROnPlateau(monitor='val_2nd_acc',
factor=0.2,
""" Normalization """
x_train = x_train / 255.
x_test = x_test / 255.
""" From numerical label to categorical label """
y_train = to_categorical(y_train, classes)
y_test = to_categorical(y_test, classes)
""" Building the Model """
model = model()
model.summary()
""" End of the Model """
""" Compilation """
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
""" Training """
history = model.fit(x_train, y_train, batch_size=256, epochs=120, verbose=2, shuffle=True,
validation_data=(x_test, y_test))
""" Evaluation of the model """
score = model.evaluate(x_test, y_test, verbose=1)
print('Test set loss: {0:.2f} and Accuracy: {1:.2f}%'.format(score[0], score[1] * 100))
""" Saving the weight file """
model.save('MODEL DATA/cifar-10.h5')
""" Saving the history in a text file """
with open('history.txt', 'a+') as f:
print(history.history, file=f)
for training_filename in tqdm.tqdm(randomized_files):
try:
audio, _ = librosa.load(training_filename, sr=p.sr, mono=True)
print(audio)
audio = audio.reshape(-1, 1)
training_data = training_data + audio.tolist()
except:
pass
training_data = np.array(training_data)
print(training_data)
training_audio_length = len(training_data)
np.save('training_data', training_data)
logger.info('preprocessing..')
training_data = preprocess.preprocess(training_data, p.bs, p.fsz, p.fs)
logger.info('**training started**')
model = model.WaveNet(p.isz, p.nl, p.ks, p.dr, p.nf).model()
model.compile(loss='categorical_crossentropy', optimizer='adam')
if p.s == True:
model.summary()
model.fit(training_data,
epochs=p.epochs,
steps_per_epoch=training_audio_length // 128,
verbose=1,
callbacks=[earlystopping_callback, tensorboard_callback])
model.save('src/trained_model/modelWN.h5')
logger.info("model saved in model/n Training finished successfully")
#Load data collected from the simulator
csv_data_path = "../data/driving_log.csv"
output_model_file_path = '../results/models/model.h5'
simulator_data = DataLoadHelper(csv_data_path)
train_generator = simulator_data.load_train_data_from_generator()
validation_generator = simulator_data.load_validation_data_from_generator()
#Clear any previous keras sessions
K.clear_session()
#Create an object to the model, compile, fit and save it to .h5 file
model = model(input_size=(160, 320, 3))
model.compile(loss='mse', optimizer='adam')
history_object = model.fit_generator(train_generator, samples_per_epoch=simulator_data.sample_training_size(), \
validation_data=validation_generator, nb_val_samples=simulator_data.sample_validation_size(),
nb_epoch=3, verbose=1)
model.save(output_model_file_path)
### print the keys contained in the history object
print(history_object.history.keys())
### plot the training and validation loss for each epoch
plt.plot(history_object.history['loss'])
plt.plot(history_object.history['val_loss'])
plt.title('model mean squared error loss')
plt.ylabel('mean squared error loss')
plt.xlabel('epoch')
# construct the image generator for data augmentation
aug = ImageDataGenerator(rotation_range=10,
zoom_range=0.05,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.15,
horizontal_flip=False,
fill_mode="nearest")
# initialize and compile our deep neural network
print("[INFO] Compiling model...")
opt = SGD(lr=INIT_LR, decay=INIT_LR / EPOCHS)
model = model.get_model()
model.compile(loss="categorical_crossentropy",
optimizer="adam",
metrics=["accuracy"])
# train the network
print("[INFO] Training network...")
H = model.fit(aug.flow(trainX, trainY, batch_size=BS),
validation_data=(testX, testY),
steps_per_epoch=len(trainX) // BS,
epochs=EPOCHS,
verbose=1)
# define the list of label names
labelNames = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
labelNames = [l for l in labelNames]
# evaluate the network
from keras.optimizers import Adam
from nmt_utils import *
from model import model
m = 10000
Tx = 30
Ty = 10
n_a = 32
n_s = 64
learning_rate = 0.005
batch_size = 100
dataset, human_vocab, machine_vocab, inv_vocab = load_dataset(m)
X, Y, Xoh, Yoh = preprocess_data(dataset, human_vocab, machine_vocab, Tx, Ty)
model = model(Tx, Ty, n_a, n_s, len(human_vocab), len(machine_vocab))
# model.summary()
opt = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, decay=0.001)
model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
s0 = np.zeros((m, n_s))
c0 = np.zeros((m, n_s))
outputs = list(Yoh.swapaxes(0, 1))
model.fit([Xoh, s0, c0], outputs, epochs=50, batch_size=batch_size)
model.save_weights('models/model_50.h5')
X = np.array(X)
Y = np.array(Y)
X = X.reshape(-2, 2)
Y = Y.reshape(-1, 1)
#read the file for testing
filename = 'func_vals_test.csv'
raw_data = open(filename, 'r')
reader = csv.reader(raw_data)
#load dataset
dataset = np.loadtxt(raw_data, delimiter=",")
#split into input and output variables
X_test = dataset[:, 0:2]
Y_test = dataset[:, 2]
X_test = np.array(X_test)
Y_test = np.array(Y_test)
X_test = X_test.reshape(-2, 2)
Y_test = Y_test.reshape(-1, 1)
#use ReLU
model.compile(optimizer=Adam(0.001), loss='mean_squared_error')
model.fit(X, Y, shuffle=True, batch_size=20, validation_split=0.4, epochs=20)
predictions = model.predict(X_test)
score = r2_score(Y_test, predictions)
print(predictions)
print(Y_test)
print("Score: ", score)
index = np.where(similarity == maximum)
top_k.append(index[0][0])
similarity[index] = -2
np.save('{}_similarity.probs'.format(img_path), np.array(top_k))
# Emoji scoring using emoji sense definitions
similarity_defns = []
for i in range(len(sense_embeddings)):
prod = cosine_product(Final_image_embedding, definition_embeddings[i])
similarity_defns.append(prod)
similarity_defns = np.array(similarity_defns)
top_k = []
while len(top_k) <= 24:
maximum = max(similarity_defns)
index = np.where(similarity_defns == maximum)
top_k.append(index[0][0])
similarity_defns[index] = -2
np.save('{}_similarity_defns.probs'.format(img_path), np.array(top_k))
if __name__ == '__main__':
args = parser()
# Test pretrained model
model = model()
model.compile()
model.set_weights(args.weights_path)
for img in os.listdir(args.img_dir):
predict(model, img)
ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
patience=7,
min_lr=lr / 100),
EarlyStopping(
patience=
9, # Patience should be larger than the one in ReduceLROnPlateau
min_delta=0.00001)
]
# Set session and compile model
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
set_session(tf.Session(config=config))
# If you are continuing an interrupted section, uncomment line bellow:
# model = keras.models.load_model(PATH_TO_PREV_MODEL, compile=False)
model.compile(loss=loss, optimizer=opt)
# Get annotations
y = pd.read_csv(args.path_to_csv).values
# Get tracings
f = h5py.File(args.path_to_hdf5, "r")
x = f[args.dataset_name]
# Create log
callbacks += [
TensorBoard(log_dir='./logs', batch_size=batch_size,
write_graph=False),
CSVLogger('training.log', append=False)
] # Change append to true if continuing training
# Save the BEST and LAST model
callbacks += [
ModelCheckpoint('./backup_model_last.hdf5'),
from utils import load_train_test_data
train_inputs, test_inputs, train_output, test_output = load_train_test_data()
print('Will train with {} and test with {} samples'.format(
len(train_inputs[0]), len(test_inputs[0])))
avg_winners = np.mean(train_output, axis=0)
def custom_loss(y_true, y_pred):
normalized_error = (y_pred - y_true) / avg_winners
return tf.reduce_mean(tf.math.square(normalized_error), axis=1)
model.compile(optimizer='adam', loss=[None, custom_loss])
model.fit(train_inputs,
train_output,
validation_data=(test_inputs, test_output),
epochs=1000,
callbacks=[
tf.keras.callbacks.EarlyStopping('loss', patience=5),
tf.keras.callbacks.TensorBoard(log_dir='logs/' +
time.strftime('%Y%m%d%H%M%S'),
histogram_freq=1)
])
model.save('results/model.h5', include_optimizer=False)
normal_probs, lucky_probs = model.get_layer('gather_probs_layer').get_probs()
normal_probs = pd.Series(normal_probs, index=np.arange(1, 50))
lucky_probs = pd.Series(lucky_probs, index=np.arange(1, 11))
le.fit(y)
y = le.transform(y)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
with open("X_test.npy", "wb+") as f:
np.save(f, X_test)
with open("y_test.npy", "wb+") as f:
np.save(f, y_test)
logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)
early_callback = keras.callbacks.EarlyStopping(monitor='val_loss',
min_delta=1e-5,
patience=5)
checkpoint_callback = keras.callbacks.ModelCheckpoint(
filepath="best_so_far.h5", save_best_only=True)
model.compile(optimizer="adam",
loss="sparse_categorical_crossentropy",
metrics=["accuracy", "categorical_accuracy", f1])
model.fit(
X_train,
y_train,
validation_split=0.2,
batch_size=500,
epochs=1000,
callbacks=[tensorboard_callback, early_callback, checkpoint_callback])
model.save("model.h5")
batch_size = 32
epochs = 3
if __name__ == '__main__':
# Get data
(X_1, y_1) = get_data_from_list(glob('images/positive/*'), 1)
(X_2, y_2) = get_data_from_list(glob('images/negative/**/*.*'), 0)
X = np.append(X_1, X_2, axis=0)
y = np.append(y_1, y_2, axis=0)
# important to do this, model.fit won't shuffle randomly
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.3)
# Init model structure
model = model((200, 300, 3), 1)
model.compile(loss="binary_crossentropy",
optimizer="adam",
metrics=["accuracy"])
model.fit(X_train,
y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(X_val, y_val),
callbacks=[WandbCallback(log_batch_frequency=10)])
model.save('models/base_model_v13.h5')
# Note:
# Keras aggregates the train acc/loss of all batches per epoch.
# val acc/loss is therefore better than reported train acc/loss
import numpy as np
import random
from dataloader import CaptchaSequence
import string
characters = string.digits + string.ascii_uppercase
data = CaptchaSequence(characters, batch_size=2, steps=1000)
from tensorflow.keras.models import *
from tensorflow.keras.layers import *
from tensorflow.keras.callbacks import EarlyStopping, CSVLogger, ModelCheckpoint
from tensorflow.keras.optimizers import *
train_data = CaptchaSequence(characters, batch_size=128, steps=1000)
valid_data = CaptchaSequence(characters, batch_size=128, steps=100)
callbacks = [
EarlyStopping(patience=3),
CSVLogger('cnn.csv'),
ModelCheckpoint('cnn_best.h5', save_best_only=True)
]
from model import model
model.compile(loss='categorical_crossentropy',
optimizer=Adam(1e-3, amsgrad=True),
metrics=['accuracy'])
model.fit_generator(train_data,
epochs=100,
validation_data=valid_data,
workers=4,
use_multiprocessing=True,
callbacks=callbacks)
