model.add(Dropout(config.dropout_rate))
# output layer
model.add(Dense(units=1, activation='sigmoid')) # 이진분류 binary
model.summary()
# 6. 모델 설정
opt = tf.keras.optimizers.Adam(learning_rate=config.learning_rate,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-07,
amsgrad=False,
name="Adam")
model.compile(loss='binary_crossentropy', optimizer=opt,
metrics=['acc']) # 이진분류 binary
callback = EarlyStopping(monitor='val_loss',
patience=10,
verbose=0,
mode='auto',
restore_best_weights=False)
callbacks_list = [callback, WandbCallback()]
# 7. 모델 피팅
history = model.fit(x_train,
y_train,
batch_size=config.batch_size,
epochs=100,
validation_data=(x_val, y_val),
callbacks=callbacks_list,
verbose=2)
"model_history_log.csv"),
append=True)
steps_per_epoch = n_files_train * (n_events_per_file // batch_size)
n_batches_per_file = n_events_per_file // batch_size
print(
f"steps_per_epoch {steps_per_epoch}, n_batches_per_file {n_batches_per_file}"
)
dataset_train = tf.data.Dataset.range(n_files_train).prefetch(
n_batches_per_file * 10).interleave(TrainDatasetEven,
cycle_length=2,
num_parallel_calls=2,
deterministic=False).repeat()
dataset_val = tf.data.Dataset.range(n_files_val).prefetch(
n_batches_per_file * 10).interleave(ValDatasetEven,
cycle_length=2,
num_parallel_calls=2,
deterministic=False)
history = model.fit(x=dataset_train,
steps_per_epoch=steps_per_epoch,
epochs=20,
validation_data=dataset_val,
callbacks=[checkpoint, csv_logger,
WandbCallback()])
with open(os.path.join('saved_models', filename, 'history.pkl'),
'wb') as file_pi:
pickle.dump(history.history, file_pi)
def run_experiment(experiment_config: Dict,
save_model: bool = True,
use_wandb: bool = True):
"""
Run a training experiment.
Parameters
----------
experiment_config (dict)
Of the form
{
"dataset": "Dataset",
"dataset_args": {
"batch_size": 128,
"test_ratio": 0.3
},
"model": "RetrievalModel",
"network": "retrieval_basic_factorization",
"network_args": {
"hidden_dim": 64,
},
"train_args": {
"epochs": 10,
"optimizer": SGD
}
}
"""
print(experiment_config)
models_module = importlib.import_module("recommenders.models")
model_class_ = getattr(models_module, experiment_config["model"])
networks_module = importlib.import_module("recommenders.networks")
network_fn_ = getattr(networks_module, experiment_config["network"])
network_args = experiment_config.get("network_args", {})
datasets_module = importlib.import_module("recommenders.datasets")
dataset_class_ = getattr(datasets_module, experiment_config["dataset"])
dataset_args = experiment_config.get("dataset_args", {})
dataset = dataset_class_(**dataset_args)
dataset.load_or_generate_data()
model = model_class_(dataset=dataset,
network_fn=network_fn_,
network_args=network_args)
if use_wandb:
wandb.init(config=experiment_config)
callbacks = list()
callbacks.append(WandbCallback())
optimizer = _get_optimizer(experiment_config["train_args"]["optimizer"])
model.compile(optimizer=optimizer(
learning_rate=experiment_config["train_args"]["learning_rate"]))
model.fit(dataset.train,
epochs=experiment_config["train_args"]["epochs"],
validation_data=dataset.test,
validation_freq=20,
callbacks=callbacks)
model.print_summary()
if save_model:
if use_wandb:
model.save_weights(wandb.run.dir)
else:
model.save_weights()
def train():
model_settings = models.prepare_model_settings(len(data_process.prepare_words_list(FLAGS.wanted_words.split(","))),
FLAGS.sample_rate,
FLAGS.clip_duration_ms,
FLAGS.window_size_ms,
FLAGS.window_strides_ms,
FLAGS.dct_coefficient_count)
# Create model
model = models.create_model(model_settings,
FLAGS.model_architecture,
FLAGS.model_size_info)
# Create checkpoint for convert mlir
#checkpoint = tf.train.Checkpoint(model)
print("test->", FLAGS.wanted_words)
# audio processor
audio_processor = data_process.AudioProcessor(data_dir=FLAGS.data_dir,
silence_percentage=FLAGS.silence_percentage,
unknown_percentage=FLAGS.unknown_percentage,
augment_percentage=FLAGS.augment_percentage,
wanted_words=FLAGS.wanted_words.split(","),
model_settings=model_settings)
# decaay learning rate in a constant piecewise way
training_steps_list = list(map(int, FLAGS.how_many_train_steps.split(",")))
learning_rates_list = list(map(float, FLAGS.learning_rate.split(",")))
lr_boundary_list = training_steps_list[:-1] # only need values at which to change lr
lr_schedule = tf.keras.optimizers.schedules.PiecewiseConstantDecay(boundaries=lr_boundary_list,
values=learning_rates_list)
# specify optimizer
optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)
# Create checkpoint for convert mlir
checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model)
model.compile(optimizer=optimizer,
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=["accuracy"])
# prepare datasets
train_dataset = audio_processor.get_data(audio_processor.Modes.training,
FLAGS.background_frequency,
FLAGS.background_volume,
int((FLAGS.time_shift_ms * FLAGS.sample_rate) / 1000))
buffer_size = audio_processor.get_set_size(audio_processor.Modes.training)
print("train set set:", buffer_size)
train_dataset = train_dataset.shuffle(buffer_size=buffer_size).repeat().batch(FLAGS.batch_size).prefetch(1)
val_dataset = audio_processor.get_data(audio_processor.Modes.validation)
val_dataset = val_dataset.batch(FLAGS.batch_size).prefetch(1)
# calculate how many epochs because we train for a max number of iterations
train_max_steps = np.sum(training_steps_list)
train_max_epochs = int(np.ceil(train_max_steps / FLAGS.eval_step_interval))
# save models
train_dir = Path(FLAGS.train_dir) / "best"
train_dir.mkdir(parents=True, exist_ok=True)
checkpoint_dir = train_dir / (FLAGS.model_architecture + "_{val_acc:.3f}_ckpt")
model_checkpoint_call_back = tf.keras.callbacks.ModelCheckpoint(
filepath=(train_dir / (FLAGS.model_architecture + "_{val_accuracy:.3f}_ckpt")),
save_weights_only=True,
monitor="val_accuracy",
mode="max",
save_best_only=True)
# Model summary
model.summary()
# Train model
model.fit(x=train_dataset,
steps_per_epoch=FLAGS.eval_step_interval,
validation_data=val_dataset,
callbacks=[model_checkpoint_call_back,WandbCallback()],
verbose=1,
epochs=train_max_epochs*3)
print("Training model finshed, start to test...")
# test and save model
test_dataset = audio_processor.get_data(audio_processor.Modes.testing)
test_dataset = test_dataset.batch(FLAGS.batch_size)
test_loss, test_acc = model.evaluate(test_dataset)
print(f"LOG====>Final test accuracy:{test_acc:0.2f} loss:{test_loss:0.3f}")
# ==========saved_model===========================#
model.save("./result/kws")
model.save("./result/kws.h5")
# =================checkpoint to mlir===================#
save_path = checkpoint.save("./result/ck")
print('----- diversity:', diversity)
generated = ''
sentence = text[start_index:start_index + config.maxlen]
generated += sentence
print('----- Generating with seed: "' + sentence + '"')
sys.stdout.write(generated)
for i in range(200):
x_pred = np.zeros((1, config.maxlen, len(chars)))
for t, char in enumerate(sentence):
x_pred[0, t, char_indices[char]] = 1.
preds = model.predict(x_pred, verbose=0)[0]
next_index = sample(preds, diversity)
next_char = indices_char[next_index]
generated += next_char
sentence = sentence[1:] + next_char
sys.stdout.write(next_char)
sys.stdout.flush()
print()
model.fit(x,
y,
batch_size=config.batch_size,
epochs=100,
callbacks=[SampleText(), WandbCallback()])
def main(args):
train_df = data.load_data.load_custom_text_as_pd(args.train_data,sep='\t',header=True, \
text_column=['Text'],target_column=['Label'])
val_df = data.load_data.load_custom_text_as_pd(args.val_data,sep='\t', header=False, \
text_column=['Text'],target_column=['Label'])
train_df = pd.DataFrame(train_df,copy=False)
val_df = pd.DataFrame(val_df,copy=False)
val_df.columns = train_df.columns
model_save_dir = args.model_save_path
try:
os.makedirs(model_save_dir)
except OSError:
pass
train_df.labels, label2idx = data.data_utils.convert_categorical_label_to_int(train_df.labels, \
save_path=os.path.join(model_save_dir,'label2idx.pkl'))
val_df.labels, _ = data.data_utils.convert_categorical_label_to_int(val_df.labels, \
save_path=os.path.join(model_save_dir,'label2idx.pkl'))
print ("Tokenization")
trainX, tokenizer = data.data_utils.compute_lstm_input_arrays(train_df, 'words', args.max_text_len)
valX, _ = data.data_utils.compute_lstm_input_arrays(val_df, 'words', args.max_text_len, tokenizer=tokenizer)
trainX = np.asarray(trainX)
valX = np.asarray(valX)
outputs = data.data_utils.compute_output_arrays(train_df, 'labels')
val_outputs = data.data_utils.compute_output_arrays(val_df, 'labels')
outputs = outputs[:,np.newaxis]
val_outputs = val_outputs[:,np.newaxis]
num_words = len(tokenizer.word_index)
print ("Modelling")
model = models.tf_models.bilstm(args.n_lstm, args.max_text_len, num_words, args.emb_dim, dropout=args.dropout)
print (model.summary())
optimizer = tf.keras.optimizers.Adam(learning_rate=args.lr) #SGD
model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics='accuracy') #binary_crossentropy
early = tf.keras.callbacks.EarlyStopping(monitor='val_accuracy', patience=8, \
verbose=1, mode='auto', restore_best_weights=True)
lr = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_accuracy', factor=0.7, \
patience=5, verbose=1, mode='auto', min_lr=0.000001)
f1callback = models.tf_utils.F1Callback(model, valX, val_outputs, filename=os.path.join(model_save_dir, 'model.h5'), patience=8)
config = {
'text_max_len': args.max_text_len,
'epochs': args.epochs,
"learning_rate": args.lr,
"batch_size": args.train_batch_size,
"n_lstm": args.n_lstm,
"emb_dim": args.emb_dim,
"dropout": args.dropout,
"model_description": "LSTM",
}
with open(os.path.join(model_save_dir, 'config.pkl'), 'wb') as handle:
pickle.dump(config, handle, protocol=pickle.HIGHEST_PROTOCOL)
K.clear_session()
if _has_wandb and args.wandb_logging:
wandb.init(project='wnut-task2',config=config)
model.fit(trainX, outputs, validation_data=(valX, val_outputs), epochs=args.epochs,\
batch_size=args.train_batch_size, callbacks=[early, lr, f1callback, WandbCallback()], verbose=1)
else:
model.fit(trainX, outputs, validation_data=(valX, val_outputs), epochs=args.epochs,\
batch_size=args.train_batch_size, callbacks=[early,lr, f1callback], verbose=1)
model.load_weights(os.path.join(model_save_dir, 'model.h5'))
model_json = model.to_json()
with open(os.path.join(model_save_dir,"model.json"), "w") as json_file:
json_file.write(model_json)
val_pred = np.round(model.predict(valX))[:,0]
print ("Evaluation")
f1 = f1_score(val_df.labels, val_pred)
precision = precision_score(val_df.labels, val_pred)
recall = recall_score(val_df.labels, val_pred)
#f1 = f1_score([idx2label[i] for i in val_df.labels], [idx2label[i] for i in val_pred])
#precision = precision_score([idx2label[i] for i in val_df.labels], [idx2label[i] for i in val_pred])
#recall = recall_score([idx2label[i] for i in val_df.labels], [idx2label[i] for i in val_pred])
results_ = pd.DataFrame()
results_['description'] = ['Bi-LSTM']
results_['f1'] = [f1]
results_['precision'] = [precision]
results_['recall'] = [recall]
print (results_.iloc[0])
if os.path.exists('../results/result.csv'):
results = pd.read_csv('../results/result.csv')
results = pd.concat([results, results_], axis=0)
results.to_csv('../results/result.csv', index=False)
else:
results_.to_csv('../results/result.csv', index=False)
# network is not reachable, so we use random data
x_train = tf.random.normal((n_train, n_features), dtype='float32')
x_test = tf.random.normal((n_test, n_features), dtype='float32')
y_train = tf.random.uniform((n_train,), minval=0, maxval=n_classes, dtype='int32')
y_test = tf.random.uniform((n_test,), minval=0, maxval=n_classes, dtype='int32')
return x_train, x_test, y_train, y_test
# wandb setup
Path(cfg.wandb.dir).mkdir(exist_ok=True, parents=True)
wandb.init(
config=OmegaConf.to_container(cfg, resolve=True),
**cfg.wandb,
)
callbacks = [
WandbCallback(monitor='loss', save_weights_only=True),
]
# model building
tf.keras.backend.clear_session()
model = my_model(**cfg.model)
model_compile(model, **cfg.compile)
x_train, x_test, y_train, y_test = data(**cfg.data)
history = model.fit(x_train, y_train, **cfg.fit, callbacks=callbacks)
test_scores = model.evaluate(x_test, y_test, verbose=2)
print('Test loss:', test_scores[0])
print('Test accuracy:', test_scores[1])
return True
if __name__ == '__main__':
train_dense_model_main()
def train():
"""Use the wandb configuration to create a model and train it"""
# get the configuration settings from wandb
config = wandb.config
tr_gen = DatasetGenerator(myConfig, shuffle=False, multitask=False)
# get the datasets and relevant variables
train_ds, train_steps, val_ds, val_steps, classes = _load_dataset(config)
# TODO: be smarter about this
img_shape = (224,224,3)
# Setup a multi-gpu distributed batch training strategy
strategy = tf.distribute.MirroredStrategy()
with strategy.scope():
# handle if model is not found
try:
model_cl = getattr(tf.keras.applications, config['model'])
except AttributeError:
raise SyntaxError(f'Model "{config["model"]}" was not found, please adjust your sweep configuration.')
# get pretrained model with top removed
model = model_cl(
include_top=False,
weights='imagenet' if config['imagenet'] else None,
input_shape=img_shape
)
# add data augmentation
model = add_preprocessing(model)
# build model to config specifications
model = build_model(
model,
config,
len(classes)
)
# may replace with wandb equivalent
earlystop = tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
mode='min',
verbose=1
)
# setup checkpointing between epochs
final_model_path = os.path.join(wandb.run.dir,'/checkpoints/final.ckpt')
model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(
filepath=final_model_path,
monitor='val_loss',
mode='min',
save_best_only=True,
verbose=1
)
# compile the model
model.compile(
optimizer=opt,
metrics=mets,
loss=loss_fn,
loss_weights=loss_ws
)
# wandb sample logging
tr_batch = next(train_ds)
if config['orientation']:
tr_image_batch, (tr_label_batch, tr_orientation_batch) = tr_batch
log_batch(tr_image_batch.numpy(), tr_label_batch.numpy(), classes, orientation_batch=tr_orientation_batch.numpy())
else:
tr_image_batch, tr_label_batch = tr_batch
log_batch(tr_image_batch.numpy(), tr_label_batch.numpy(), classes)
# perfom training
model.fit(
train_ds,
steps_per_epoch=train_steps,
validation_data=val_ds,
validation_steps=val_steps,
epochs=config['epochs'],
callbacks=[earlystop,
WandbCallback(),
model_checkpoint_callback
]
)
# save the best model checkpoint to wandb
wandb.save(final_model_path)
model.add(Conv2D(32,
(config.first_layer_conv_width, config.first_layer_conv_height),
input_shape=(28, 28, 1),
activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(config.dense_layer_size, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam',
metrics=['accuracy'], weighted_metrics=['accuracy'])
model.fit(X_train, y_train, validation_data=(X_test, y_test),
epochs=config.epochs,
callbacks=[WandbCallback(data_type="image", save_model=False),
TensorBoard(log_dir=wandb.run.dir)])
from keras import backend as K
import tensorflow as tf
from tensorflow.python.tools import freeze_graph
model.save("cnn.h5")
saver = tf.train.Saver()
saver.save(K.get_session(), './keras_model.ckpt')
freeze_graph.freeze_graph('tensorflowModel.pbtxt', "", False,
'./tensorflowModel.ckpt', "output/softmax",
"save/restore_all", "save/Const:0",
'frozentensorflowModel.pb', True, ""
model = Sequential()
model.add(
Conv1D(filters=64,
kernel_size=4,
activation='relu',
input_shape=(n_input, n_features)))
model.add(MaxPooling1D(pool_size=2))
model.add(Dropout(wandb.config.dropout))
model.add(Flatten())
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')
# validation_split=0.33
# #metrics=['accuracy', 'loss', 'val_accuracy', 'val_loss'],)
# %%
model.fit(generator, epochs=wandb.config.epochs, callbacks=[WandbCallback()])
model.save(os.path.join(wandb.run.dir, "cnn-model.h5"))
# %%
pred_list = []
batch = train[-n_input:].reshape((1, n_input, n_features))
for i in range(n_input):
pred_list.append(model.predict(batch)[0])
batch = np.append(batch[:, 1:, :], [[pred_list[i]]], axis=1)
# %%
df_predict = pd.DataFrame(scaler.inverse_transform(pred_list),
index=df[-n_input:].index,
columns=['Prediction'])
bias_regularizer=keras.regularizers.l2(10e-6)),
keras.layers.Dense(NUM_CLASSES) # softmax not needed as loss specifies from_logits
])
model.compile(optimizer=keras.optimizers.SGD(learning_rate=0.01),
loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy', keras.metrics.SparseCategoricalCrossentropy(from_logits=True)])
# train the model
#! FIT TO CV TRAIN SET
history = model.fit(X_train_, y_train_,
epochs=epochs,
verbose = 2,
batch_size=batch_size,
validation_data=(X_val, y_val),
callbacks=[time_callback, WandbCallback(log_weights=True)])
train_accs.append(history.history['accuracy'])
val_accs.append(history.history['val_accuracy'])
times.append(time_callback.times[0])
AVG_TRAIN_ACCS.append(np.mean(np.stack(train_accs, axis=0), axis=0))
AVG_VAL_ACCS.append(np.mean(np.stack(val_accs, axis=0), axis=0))
AVG_TIMES.append(np.mean(times))
#! IDEA: collect the val data from fit -> stack over CV runs -> take mean -> plot
np.save('./data/1a_3/train_accs_350.npy', AVG_TRAIN_ACCS)
np.save('./data/1a_3/val_accs_350.npy', AVG_VAL_ACCS)
np.save('./data/1a_3/avg_time_1_epoch_350.npy', AVG_TIMES)
def train():
dataloaders = list()
if 'big_exam' in wandb.config.datasets:
dataloaders.append(AbnormalBigExamLoader(wandb_config=wandb.config))
if 'audicor_10s' in wandb.config.datasets:
dataloaders.append(AbnormalAudicor10sLoader(wandb_config=wandb.config))
'''
g = BaseDataGenerator(dataloaders=dataloaders,
wandb_config=wandb.config,
preprocessing_fn=preprocessing)
train_set, valid_set, test_set = g.get()
'''
big_data=np.load('big_signal_label_634_5_28.npy')
hht_set_signal=np.load('./abnormal_detection/wavelet_2c/s3s4label_hs1.npy')[:,3:]
#hht_set_signal=np.delete(hht_set_signal,433,axis = 0)
#hht_set_signal=np.delete(hht_set_signal,525,axis = 0)
hht_set_signal_h2=np.load('./abnormal_detection/wavelet_2c/s3s4label_hs2.npy')[:,3:]
hht_set_signal = np.array([np.array(hht_set_signal),np.array(hht_set_signal_h2)])
hht_set_signal=np.transpose(hht_set_signal,(1,2,0))
#hht_set_signal=np.vstack((hht_set_signal,amp))
print('hht_set_signal',hht_set_signal.shape)
a=big_data[:,1:3]
b=np.zeros((big_data.shape[0],1))
for i in range(big_data.shape[0]):
#print('a[i,0]',a[i,0])
if(a[i,0]=='1.0' ):
b[i]=1
if(a[i,1]=='1.0'):
b[i]=1
#print(a[:5,0],a[:5,1])
#print(a[:5],a.shape)
#b=np.delete(b,433,axis = 0)
#b=np.delete(b,525,axis = 0)
print(b[:5],b.shape)
duration = 10.0
fs = 1000.0
samples = int(fs*duration)
t = np.arange(samples) / fs
train_set_size=int(big_data.shape[0]/2)
valid_set_size=int(train_set_size+big_data.shape[0]*0.2)
#print('set_size',train_set_size,valid_set_size)
train_set_signal=np.array((hht_set_signal[:train_set_size]), dtype=np.float)#0.5
valid_set_signal=np.array((hht_set_signal[train_set_size:valid_set_size]), dtype=np.float)#0.2
test_set_signal=np.array((hht_set_signal[valid_set_size:]), dtype=np.float)#0.3
#train_set_label=np.array((big_data[:298,1:2]), dtype=np.float)
#valid_set_label=np.array((big_data[298:418,1:2]), dtype=np.float)
#test_set_label=np.array((big_data[418:,1:2]), dtype=np.float)
train_set_label=np.array((b[:train_set_size]), dtype=np.float)
valid_set_label=np.array((b[train_set_size:valid_set_size]), dtype=np.float)
test_set_label=np.array((b[valid_set_size:]), dtype=np.float)
print('test_set_label',np.sum(test_set_label),test_set_label.shape,test_set_signal.shape)
train_set_label=onehot(train_set_label)
valid_set_label=onehot(valid_set_label)
test_set_label=onehot(test_set_label)
train_set = [np.array(train_set_signal), np.array(train_set_label)]
valid_set = [np.array(valid_set_signal), np.array(valid_set_label)]
test_set = [np.array(test_set_signal), np.array(test_set_label)]
train_set[0], means_and_stds = normalize(train_set[0])
valid_set[0], _ = normalize(valid_set[0], means_and_stds)
test_set[0], _ = normalize(test_set[0], means_and_stds)
train_set[0] = multi_input_format(train_set[0], wandb.config.include_info)
valid_set[0] = multi_input_format(valid_set[0], wandb.config.include_info)
test_set[0] = multi_input_format(test_set[0], wandb.config.include_info)
print('have',train_set[1][:, 0].sum()/ train_set[1][:, 0].shape[0],valid_set[1][:, 0].sum()/ valid_set[1][:, 0].shape[0],test_set[1][:, 0].sum()/ test_set[1][:, 0].shape[0])
print('have',train_set[1][:, 1].sum()/ train_set[1][:, 0].shape[0],valid_set[1][:, 1].sum()/ valid_set[1][:, 0].shape[0],test_set[1][:, 1].sum()/ test_set[1][:, 0].shape[0])
print(train_set[1][:, 0].shape[0],valid_set[1][:, 0].shape[0],test_set[1][:, 0].shape[0])
for X in [train_set[0], valid_set[0], test_set[0]]:
if wandb.config.n_ekg_channels != 0:
X['ekg_input'] = X['ekg_hs_input'][..., :wandb.config.n_ekg_channels]
if wandb.config.n_hs_channels != 0:
print('X',X['ekg_hs_input'].shape)
hs = X['ekg_hs_input'][..., -wandb.config.n_hs_channels:] # (?, n_samples, n_channels)
X['hs_input'] = mp_generate_wavelet(hs,wandb.config.sampling_rate,
wandb.config.wavelet_scale_length,
'Generate Wavelets')
X.pop('ekg_hs_input')
# save means and stds to wandb
#with open(os.path.join(wandb.run.dir, 'means_and_stds.pl'), 'wb') as f:
#pickle.dump(g.means_and_stds, f)
model = backbone(wandb.config, include_top=True, classification=True, classes=2)
model.compile(RAdam(1e-4) if wandb.config.radam else Adam(amsgrad=True),
'binary_crossentropy', metrics=['acc'])
model.summary()
wandb.log({'model_params': model.count_params()}, commit=False)
callbacks = [
EarlyStopping(monitor='val_loss', patience=50),
# ReduceLROnPlateau(patience=10, cooldown=5, verbose=1),
LogBest(),
WandbCallback(log_gradients=False, training_data=train_set),
]
model.fit(train_set[0], train_set[1], batch_size=64, epochs=800, validation_data=(valid_set[0], valid_set[1]), callbacks=callbacks, shuffle=True)
model.save(os.path.join(wandb.run.dir, 'final_model.h5'))
# load best model from wandb and evaluate
print('Evaluate the BEST model!')
from tensorflow.keras.models import load_model
from ekg.layers import LeftCropLike, CenterCropLike
from ekg.layers.sincnet import SincConv1D
custom_objects = {
'SincConv1D': SincConv1D,
'LeftCropLike': LeftCropLike,
'CenterCropLike': CenterCropLike
}
model = load_model(os.path.join(wandb.run.dir, 'model-best.h5'),
custom_objects=custom_objects, compile=False)
evaluation.evaluation(model, test_set)
def curr_learn_experiment(args):
""" Run curriculum learning experiment, pre-training on class labels for
args.class_switch total epochs, then finetuning on species labels for
args.epochs total epochs """
wandb.init(project=args.project_name)
# NOTE: these absolute paths to the general and specific train and validation
# data depend on your setup
general_train = "curr_learn_25_s_620_100_BY_CLASS/train"
general_val = "curr_learn_25_s_620_100_BY_CLASS/val"
specific_train = "curr_learn_25_s_620_100/train"
specific_val = "curr_learn_25_s_620_100/val"
train_datagen = ImageDataGenerator(
rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1. / 255)
# initially, the more general model pre-trains on 5 classes
# (amphibians, birds, insects, mammals, and reptiles)
# on data generated with general labels (biological/taxonomic class)
general_model = build_small_cnn(args.dropout, 5, args.class_lr)
log_model_params(general_model, wandb.config, args, img_width)
switch_epochs = args.class_switch
callbacks = [WandbCallback()]
train_generator = train_datagen.flow_from_directory(
general_train,
target_size=(img_width, img_height),
batch_size=args.batch_size,
class_mode='categorical',
follow_links=True)
validation_generator = test_datagen.flow_from_directory(
general_val,
target_size=(img_width, img_height),
batch_size=args.batch_size,
class_mode='categorical',
follow_links=True)
# pre-train on first, general label set (5 classes) for switch_epochs
general_model.fit_generator(
train_generator,
steps_per_epoch=args.num_train // args.batch_size,
epochs=switch_epochs,
validation_data=validation_generator,
callbacks=callbacks,
validation_steps=args.num_valid // args.batch_size)
# recompile the model such that the final layer can predict 25 output labels (25 species)
specific_model = build_small_cnn(args.dropout, 25, args.species_lr)
# copy weights from general to specific model, up until dropout layer
for i, layer in enumerate(specific_model.layers[:-3]):
layer.set_weights(general_model.layers[i].get_weights())
# finetune on second, specific label set (25 species) for finetune_epochs,
# on data generated with specific labels (biological/taxonomic species)
finetune_epochs = args.epochs - switch_epochs
spec_train_generator = train_datagen.flow_from_directory(
specific_train,
target_size=(img_width, img_height),
batch_size=args.batch_size,
class_mode='categorical',
follow_links=True)
spec_validation_generator = test_datagen.flow_from_directory(
specific_val,
target_size=(img_width, img_height),
batch_size=args.batch_size,
class_mode='categorical',
follow_links=True)
specific_model.fit_generator(
spec_train_generator,
steps_per_epoch=args.num_train // args.batch_size,
epochs=finetune_epochs,
validation_data=spec_validation_generator,
callbacks=callbacks,
validation_steps=args.num_valid // args.batch_size)
save_model_filename = args.model_name + ".h5"
specific_model.save_weights(save_model_filename)
def finetune_base_cnn(args):
""" Load a pre-trained model and pre-train it for some epochs (args.pretrain_epochs).
Then freeze learned layers up to args.freeze_layer, and continue training the remaining
layers for the rest of the epochs (args.epochs) """
wandb.init(project=args.project_name)
callbacks = [WandbCallback()]
# basic data augmentation
train_datagen = ImageDataGenerator(
rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1. / 255)
# modify image dims depending on base model (only resnet is different)
if args.initial_model == "resnet":
base_img_width = resnet_img_dim
base_img_height = resnet_img_dim
else:
base_img_width = img_width
base_img_height = img_height
train_generator = train_datagen.flow_from_directory(
args.train_data,
target_size=(base_img_width, base_img_height),
batch_size=args.batch_size,
class_mode='categorical',
follow_links=True)
validation_generator = test_datagen.flow_from_directory(
args.val_data,
target_size=(base_img_width, base_img_height),
batch_size=args.batch_size,
class_mode='categorical',
follow_links=True)
model = load_pretrained_model(args.initial_model, args.fc_size, args.num_classes)
log_model_params(model, wandb.config, args, base_img_width)
# Pre-training phase
#-----------------------
model.fit_generator(
train_generator,
steps_per_epoch=args.num_train // args.batch_size,
epochs=args.pretrain_epochs,
validation_data=validation_generator,
callbacks = callbacks,
validation_steps=args.num_valid // args.batch_size)
# optionally show all layers of the base model
#for i, layer in enumerate(model.layers):
# print i, layer.name
# freeze layers up to the freeze_layer index
for layer in model.layers[:args.freeze_layer]:
layer.trainable = False
for layer in model.layers[args.freeze_layer:]:
layer.trainable = True
# recompile model
model.compile(optimizer=optimizers.SGD(lr=args.learning_rate, momentum=args.momentum), loss='categorical_crossentropy', metrics=["accuracy"])
# Finetuning phase
#-----------------------
model.fit_generator(
train_generator,
steps_per_epoch=args.num_train // args.batch_size,
epochs=args.epochs,
validation_data=validation_generator,
callbacks = callbacks,
validation_steps=args.num_valid // args.batch_size)
save_model_filename = args.model_name + ".h5"
model.save_weights(save_model_filename)
activation='relu',
input_shape=input_shape))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(64, (5, 5), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(1000, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
# In[10]:
model.compile(optimizer=tf.train.AdamOptimizer(),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# In[ ]:
model.fit(
X_train,
y_train,
epochs=config.epochs,
verbose=1,
validation_data=(X_test, y_test),
callbacks=[WandbCallback(data_type="image", labels=signdata.letters)])
# In[ ]:
test_loss, test_acc = model.evaluate(X_test, y_test)
print('Test accuracy:', test_acc)
train_dir = "dogcat-data/train"
val_dir = "dogcat-data-small/validation"
nb_train_samples = get_nb_files(train_dir)
nb_classes = len(glob.glob(train_dir + "/*"))
nb_val_samples = get_nb_files(val_dir)
# data prep
train_generator, validation_generator = generators(preprocess_input, config.img_width, config.img_height, config.batch_size)
# setup model
base_model = InceptionV3(weights='imagenet', include_top=False) #include_top=False excludes final FC layer
model = add_new_last_layer(base_model, nb_classes)
model._is_graph_network = False
# fine-tuning
setup_to_finetune(model)
model.fit_generator(
train_generator,
epochs=config.epochs,
workers=2,
steps_per_epoch=nb_train_samples * 2 / config.batch_size,
validation_data=validation_generator,
validation_steps=nb_train_samples / config.batch_size,
callbacks=[WandbCallback(data_type="image", generator=validation_generator, labels=['cat', 'dog'],save_model=False)],
class_weight='auto')
model.save('transfered.h5')
shuffle=False,
steps_per_epoch=len(df_train) / BATCH_SIZE)
val_generator = validation_datagen.flow_from_dataframe(
dataframe=df_validate,
x_col="file",
y_col="hr",
batch_size=BATCH_SIZE,
shuffle=False,
target_size=INPUT_SHAPE[:2],
class_mode='raw')
run_name = wandb.run.name
callbacks = [WandbCallback(
training_data=train_generator,
validation_data=val_generator,
input_type="images"),
ModelCheckpoint(
filepath=f"models/{run_name}/",
save_weights_only=True,
mode='min',
save_best_only=True),
ReduceLROnPlateau(factor=0.001, patience=15)
# LearningRateScheduler(scheduler)
]
def weight_image(image_pixels):
weight_map = np.load("report_scripts/variance_based_weights_single.npy")
img = image_pixels * weight_map
return img
def main():
print('LOAD PARAMETERS')
args = parse_args()
cfg_params = parse_params(args.config)
params_train = cfg_params['train']
params_model = cfg_params['model']
params_dataloader = cfg_params['dataloader']
params_generator = cfg_params['generator']
tensorboard_save_path, weights_save_file_path, plots_save_path = create_save_folders(
cfg_params['general'])
work_dir_path = os.path.join(cfg_params['general']['work_dir'],
cfg_params['general']['project_name'])
weights_save_path = os.path.join(work_dir_path, 'weights/')
initial_lr = params_train['learning_rate']
decay_factor = params_train['decay_factor']
step_size = params_train['step_size']
if params_dataloader['validate']:
callback_monitor = 'val_loss'
else:
callback_monitor = 'loss'
print('LOADING COMPLETED')
callbacks = [
LearningRateScheduler(
lambda x: initial_lr * decay_factor**np.floor(x / step_size)),
ReduceLROnPlateau(monitor=callback_monitor,
factor=0.1,
patience=4,
verbose=1),
EarlyStopping(monitor=callback_monitor, patience=10, verbose=1),
ModelCheckpoint(filepath=weights_save_file_path,
monitor=callback_monitor,
save_best_only=True,
verbose=1)
]
print('CREATE DATALOADER')
data_loader = ENDataLoader(**params_dataloader)
print('DATALOADER CREATED!')
if cfg_params['general']['tensorboard_callback']:
callbacks.append(TensorBoard(log_dir=tensorboard_save_path))
if cfg_params['general']['wandb_callback']:
import wandb
from wandb.keras import WandbCallback
wandb.init()
callbacks.append(
WandbCallback(data_type="image", labels=data_loader.class_names))
val_generator = None
print('CREATE MODEL AND DATA GENETATORS')
if params_model['mode'] == 'siamese':
model = SiameseNet(cfg_params, training=True)
train_generator = SiameseDataGenerator(
class_files_paths=data_loader.train_data,
class_names=data_loader.class_names,
**params_generator)
if data_loader.validate:
val_generator = SiameseDataGenerator(
class_files_paths=data_loader.val_data,
class_names=data_loader.class_names,
val_gen=True,
**params_generator)
losses = {'output_siamese': contrastive_loss}
metric = {'output_siamese': accuracy}
else:
if cfg_params['general']['gpu_ids']:
print('Multiple gpu mode')
gpu_ids = cfg_params['general']['gpu_ids']
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = gpu_ids
print(f'Using gpu ids: {gpu_ids}')
gpu_ids_list = gpu_ids.split(',')
n_gpu = len(gpu_ids_list)
else:
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
n_gpu = 1
print('Use single gpu mode')
model = TripletNet(cfg_params, training=True)
if n_gpu > 1:
strategy = tf.distribute.MirroredStrategy()
with strategy.scope():
model.base_model = multi_gpu_model(model.base_model,
gpus=n_gpu)
# model.base_model = tf.keras.utils.multi_gpu_model(model.base_model, gpus=n_gpu)
train_generator = TripletsDataGenerator(
embedding_model=model.base_model,
class_files_paths=data_loader.train_data,
class_names=data_loader.class_names,
**params_generator)
if data_loader.validate:
val_generator = SimpleTripletsDataGenerator(
data_loader.val_data, data_loader.class_names,
**params_generator)
losses = triplet_loss(params_generator['margin'])
metric = ['accuracy']
print('DONE')
if args.resume_from is not None:
model.load_model(args.resume_from)
print('COMPILE MODEL')
model.model.compile(loss=losses,
optimizer=params_train['optimizer'],
metrics=metric)
if 'softmax' in cfg_params:
params_softmax = cfg_params['softmax']
params_save_paths = cfg_params['general']
pretrain_backbone_softmax(model.backbone_model, data_loader,
params_softmax, params_save_paths)
history = model.model.fit_generator(train_generator,
validation_data=val_generator,
epochs=params_train['n_epochs'],
callbacks=callbacks,
verbose=1,
use_multiprocessing=False)
if params_train['plot_history']:
plot_grapths(history, plots_save_path)
#model.add(Permute((3,1,2,4)))
#model.add(ConvLSTM2D(16, (3,3), padding='same', recurrent_dropout=0.2, dropout=0.2, activation='tanh', #recurrent_activation='hard_sigmoid', return_sequences=False))
#model.add(Conv2D(32,(3,3),padding='same',activation='relu'))
#model.add(BatchNormalization())
#model.add(Conv2D(3,(3,3),padding='same'))
def perceptual_distance(y_true, y_pred):
rmean = (y_true[:, :, :, 0] + y_pred[:, :, :, 0]) / 2
r = y_true[:, :, :, 0] - y_pred[:, :, :, 0]
g = y_true[:, :, :, 1] - y_pred[:, :, :, 1]
b = y_true[:, :, :, 2] - y_pred[:, :, :, 2]
return K.mean(
K.sqrt((((512 + rmean) * r * r) / 256) + 4 * g * g +
(((767 - rmean) * b * b) / 256)))
model.compile(optimizer='adam',
loss=[perceptual_distance],
metrics=[perceptual_distance])
model.summary()
model.fit_generator(
my_generator(config.batch_size, train_dir),
steps_per_epoch=len(glob.glob(train_dir + "/*")) // config.batch_size,
epochs=config.num_epochs,
callbacks=[ImageCallback(), WandbCallback()],
validation_steps=len(glob.glob(val_dir + "/*")) // config.batch_size,
validation_data=my_generator(config.batch_size, val_dir))
seq1.add(Flatten(input_shape=(28,28))) seq1.add(Dense(128, activation='relu')) seq2 = Sequential() seq2.add(Flatten(input_shape=(28,28))) seq2.add(Dense(128, activation='relu')) merge_layer = Concatenate()([seq1.output, seq2.output]) dense_layer = Dense(1, activation="sigmoid")(merge_layer) model = Model(inputs=[seq1.input, seq2.input], outputs=dense_layer) model.compile(loss = "binary_crossentropy", optimizer="adam", metrics=["accuracy"]) model.summary() wandb.init(project="siamese") model.fit([pairs_train[:,0], pairs_train[:,1]], labels_train[:], batch_size=16, epochs= 10, callbacks=[WandbCallback()]) input = Input((28,28)) x = Flatten()(input) x = Dense(128, activation='relu')(x) # add dense layer of neural network to the model dense = Model(input, x) input1 = Input((28,28)) input2 = Input((28,28)) dense1 = dense(input1) dense2 = dense(input2) merge_layer = Concatenate()([dense1, dense2]) dense_layer = Dense(1, activation="sigmoid")(merge_layer) model = Model(inputs=[input1, input2], outputs=dense_layer)
m.compile(optimizer=opt,
loss="sparse_categorical_crossentropy",
metrics=['accuracy'])
log_dir = "logs/fit/" + datetime.datetime.now().strftime(
"%Y%m%d-%H%M%S")
callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir,
histogram_freq=1)
m.summary()
m.fit(x_train,
y_train,
validation_data=(x_val, y_val),
batch_size=32,
epochs=120,
callbacks=[WandbCallback()])
test_err, test_acc = m.evaluate(x_test, y_test, verbose=1)
print("Accuracy on testing data", test_acc)
model_json = m.to_json()
with open("model.json", "w") as json_file:
json_file.write(model_json)
print("Saved model to disk")
m.save_weights("model.h5")
else:
json_file = open('model.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = keras.models.model_from_json(loaded_model_json)
def create_model_and_train(n_layers, n_filters, load_model_path = None):
if load_model_path:
model = load_model(load_model_path)
else:
skip_layers = []
# First layer
input_gray = Input(shape = (config.height, config.width)) # same as Y channel
CrCb = Reshape((config.height, config.width,1))(input_gray)
if config.l2_loss:
CrCb = Conv2D(n_filters, (3, 3), activation='relu', padding='same',
kernel_regularizer=regularizers.l2(config.l2_loss),
bias_regularizer=regularizers.l2(config.l2_loss))(CrCb)
else:
CrCb = Conv2D(n_filters, (3, 3), activation='relu', padding='same')(CrCb)
CrCb = BatchNormalization()(CrCb)
if config.l2_loss:
CrCb = SeparableConv2D(n_filters, (3, 3), activation='relu', padding='same',
depthwise_regularizer=regularizers.l2(config.l2_loss),
pointwise_regularizer=regularizers.l2(config.l2_loss),
bias_regularizer=regularizers.l2(config.l2_loss))(CrCb)
else:
CrCb = SeparableConv2D(n_filters, (3, 3), activation='relu', padding='same')(CrCb)
CrCb = BatchNormalization()(CrCb)
# Down layers
for n_layer in range(1, n_layers):
skip_layers.append(CrCb)
n_filters *= 2
CrCb = MaxPooling2D(2,2)(CrCb)
for i in range(2):
if config.l2_loss:
CrCb = SeparableConv2D(n_filters, (3, 3), activation='relu', padding='same',
depthwise_regularizer=regularizers.l2(config.l2_loss),
pointwise_regularizer=regularizers.l2(config.l2_loss),
bias_regularizer=regularizers.l2(config.l2_loss))(CrCb)
else:
CrCb = SeparableConv2D(n_filters, (3, 3), activation='relu', padding='same')(CrCb)
CrCb = BatchNormalization()(CrCb)
# Up layers are made of Transposed convolution + 2 sets of separable convolution
for n_layer in range(1, n_layers):
n_filters //= 2
if config.l2_loss:
CrCb = Conv2DTranspose(n_filters, (2, 2), strides=2, activation='relu', padding='same',
kernel_regularizer=regularizers.l2(config.l2_loss),
bias_regularizer=regularizers.l2(config.l2_loss))(CrCb)
else:
CrCb = Conv2DTranspose(n_filters, (2, 2), strides=2, activation='relu', padding='same')(CrCb)
CrCb = concatenate([CrCb, skip_layers[-n_layer]], axis = -1)
CrCb = BatchNormalization()(CrCb)
for i in range(2):
if config.l2_loss:
CrCb = SeparableConv2D(n_filters, (3, 3), activation='relu', padding='same',
depthwise_regularizer=regularizers.l2(config.l2_loss),
pointwise_regularizer=regularizers.l2(config.l2_loss),
bias_regularizer=regularizers.l2(config.l2_loss))(CrCb)
else:
CrCb = SeparableConv2D(n_filters, (3, 3), activation='relu', padding='same')(CrCb)
CrCb = BatchNormalization()(CrCb)
# Create output classes
if config.l2_loss:
CrCb = Conv2D(2, (1, 1), activation='tanh', padding='same',
kernel_regularizer=regularizers.l2(config.l2_loss),
bias_regularizer=regularizers.l2(config.l2_loss))(CrCb)
else:
CrCb = Conv2D(2, (1, 1), activation='tanh', padding='same')(CrCb)
model = Model(inputs=input_gray, outputs = CrCb)
# Set optimizer
adam = optimizers.Adam(lr=config.learning_rate)
model.compile(optimizer=adam, loss='mse')
# Load validation data
(val_bw_images, val_color_images) = next(generator(images_per_val_epoch, valid_dir))
# Train
model.fit_generator(generator(config.batch_size, train_dir, training=True),
steps_per_epoch=int(images_per_train_epoch / config.batch_size),
epochs=config.num_epochs, callbacks=[WandbCallback(data_type='image', predictions=16),
ModelCheckpoint(filepath = 'model/weights.{epoch:03d}.hdf5')], # TODO add datetime
validation_data=(val_bw_images, val_color_images))
embedding_matrix[index] = embedding_vector
'''
model = Sequential()
model.add(Embedding(config.vocab_size, 100, input_length=config.maxlen, weights=[embedding_matrix], trainable=False))
model.add(Flatten())
model.add(Dense(100, activation="relu"))
model.add(Dense(100,activation="relu"))
model.add(Dropout(0.6))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
'''
model = Sequential()
model.add(Embedding(config.vocab_size, 100, input_length=config.maxlen))
model.add(CuDNNLSTM(config.hidden_dims))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
model.fit(X_train, y_train,
batch_size=config.batch_size,
epochs=config.epochs,
validation_data=(X_test, y_test), callbacks=[WandbCallback()])
return cached['train_faces'], cached['train_emotions'], cached['val_faces'], cached['val_emotions']
# loading dataset
train_faces, train_emotions, val_faces, val_emotions = load_fer2013()
num_samples, num_classes = train_emotions.shape
train_faces /= 255.
val_faces /= 255.
# Define the model here, CHANGEME
inp = tf.keras.Input(input_shape)
x = tf.keras.layers.Flatten()(inp)
x = tf.keras.layers.Dense(num_classes, activation="softmax")(x)
model = tf.keras.Model(inp, x)
model.compile(optimizer='adam', loss='categorical_crossentropy',
metrics=['accuracy'])
# log the number of total parameters
config.total_params = model.count_params()
model.fit(train_faces, train_emotions, batch_size=config.batch_size,
epochs=config.num_epochs, verbose=1, callbacks=[
Perf(val_faces),
WandbCallback(data_type="image", labels=[
"Angry", "Disgust", "Fear", "Happy", "Sad", "Surprise", "Neutral"])
], validation_data=(val_faces, val_emotions))
# save the model
model.save("emotion.h5")
config = wandb.config
config.batch_size = 128
config.epochs = 10
config.learn_rate = 1000
class_names = [
'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck'
]
num_classes = len(class_names)
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
# Convert class vectors to binary class matrices.
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
model = Sequential()
model.add(Flatten())
model.add(Dense(num_classes))
model.compile(loss='mse',
optimizer=Adam(config.learn_rate),
metrics=['accuracy'])
model.fit(X_train,
y_train,
epochs=10,
batch_size=128,
validation_data=(X_test, y_test),
callbacks=[WandbCallback(data_type="image", labels=class_names)])
def test_no_init():
with pytest.raises(wandb.errors.Error):
WandbCallback()
wb.login()
wb.init(project='bird_ID', config={'lr': 1e-3, 'bs': 32})
config = wb.config
keras.backend.clear_session()
model = tf.keras.Sequential([
layers.Conv2D(filters=32, kernel_size=(4,4), strides=1, activation='relu', input_shape=(284, 257, 1)),
layers.MaxPool2D(pool_size=(4,4)),
layers.Conv2D(filters=64, kernel_size=(4,4), strides=1, activation='relu'),
layers.MaxPool2D(pool_size=(4,4)),
layers.Flatten(),
layers.Dense(64, activation='relu'),
layers.Dense(3)
])
model.summary()
model.compile(optimizer=tf.optimizers.Adam(learning_rate=config.lr), loss=losses.SparseCategoricalCrossentropy(from_logits=True), metrics='accuracy')
AUTOTUNE = tf.data.AUTOTUNE
train_ds_ = train_ds.shuffle(500, seed=seed).cache().prefetch(AUTOTUNE).batch(config.bs)
val_ds_ = val_ds.shuffle(500, seed=seed).cache().prefetch(AUTOTUNE).batch(config.bs)
#LargeDataset
model.fit(train_ds_, epochs=2, validation_data=val_ds_, callbacks=[WandbCallback()])
wb.finish()
# one hot encode outputs
print("BEFORE")
print(y_train)
print("Size = ")
print(y_train.size)
y_train = np_utils.to_categorical(y_train)
print("AFTER")
print(y_train)
print("Size=")
print(y_train.size)
y_test = np_utils.to_categorical(y_test)
labels = range(10)
num_classes = y_train.shape[1]
# create model
model=Sequential()
model.add(Flatten(input_shape=(img_width,img_height)))
model.add(Dropout(0.5))
model.add(Dense(1000, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax')) #when having categorization, using categorical cross entropy, num_classes=num digits
model.compile(loss='categorical_crossentropy', optimizer='adam',
metrics=['accuracy'])
# Fit the model
model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test),
callbacks=[WandbCallback(validation_data=X_test, labels=labels)])
num_classes = y_test.shape[1]
sgd = SGD(lr=config.learn_rate,
decay=config.decay,
momentum=config.momentum,
nesterov=True)
# build model
model = Sequential()
model.add(
Conv2D(config.layer_1_size, (5, 5),
activation='relu',
input_shape=(img_width, img_height, 1)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(config.layer_2_size, (5, 5), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(config.dropout))
model.add(Flatten())
model.add(Dense(config.hidden_layer_size, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
# Add Keras WandbCallback
model.compile(loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy'])
model.fit(X_train,
y_train,
validation_data=(X_test, y_test),
epochs=config.epochs,
callbacks=[WandbCallback(data_type="image", labels=labels)])
a = dataset[i:(i+config.look_back)]
dataX.append(a)
dataY.append(dataset[i + config.look_back])
return np.array(dataX), np.array(dataY)
data = load_data()
# normalize data to between 0 and 1
max_val = max(data)
min_val = min(data)
data = (data-min_val)/(max_val-min_val)
# split into train and test sets
split = int(len(data) * 0.70)
train = data[:split]
test = data[split:]
trainX, trainY = create_dataset(train)
testX, testY = create_dataset(test)
trainX = trainX[:, :, np.newaxis]
testX = testX[:, :, np.newaxis]
# create and fit the RNN
model = Sequential()
model.add(SimpleRNN(1, input_shape=(config.look_back, 1)))
model.compile(loss='mse', optimizer='adam')
model.fit(trainX, trainY, epochs=500, batch_size=1, validation_data=(testX, testY), callbacks=[
WandbCallback(), PlotCallback(trainX, trainY, testX, testY, config.look_back)])
