def train(text, epochs=100, save_freq=10, resume=False):
global model, idx_to_char, vocab_size
if resume:
print("Attempting to resume last training...")
model_dir = Path(MODEL_DIR)
c2ifile = model_dir.joinpath('char_to_idx.json')
with c2ifile.open('r') as f:
char_to_idx = json.load(f)
checkpoints = list(model_dir.glob('weights.*.h5'))
if not checkpoints:
raise ValueError("No checkpoints found to resume from")
resume_epoch = max(int(p.name.split('.')[1]) for p in checkpoints)
print("Resuming from epoch", resume_epoch)
else:
resume_epoch = 0
char_to_idx = {ch: i for (i, ch) in enumerate(sorted(list(set(text))))}
with open(os.path.join(MODEL_DIR, 'char_to_idx.json'), 'w') as f:
json.dump(char_to_idx, f)
vocab_size = len(char_to_idx)
idx_to_char = {i: ch for (ch, i) in list(char_to_idx.items())}
model = build_model(BATCH_SIZE, SEQ_LENGTH, vocab_size)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
if resume:
load_weights(resume_epoch, model)
T = np.asarray([char_to_idx[c] for c in text], dtype=np.int32)
log = TrainLogger('training_log.csv', resume_epoch)
start = timer()
for epoch in range(resume_epoch, epochs):
elapsed = timer() - start
start = timer()
print(
'\nEpoch {}/{}, previous epoch took %0.3fs or %0.3fms/step'.format(
epoch + 1, epochs) % (elapsed, 1000.0 * elapsed /
(T.shape[0] / BATCH_SIZE / SEQ_LENGTH)))
losses, accs = [], []
for i, (X, Y) in enumerate(read_batches(T, vocab_size)):
loss, acc = model.train_on_batch(X, Y)
print('Batch {}: loss = {:.4f}, acc = {:.5f}\r'.format(
i + 1, loss, acc),
end=" ")
losses.append(loss)
accs.append(acc)
log.add_entry(np.average(losses), np.average(accs))
print()
print(sample(512))
if (epoch + 1) % save_freq == 0:
save_weights(epoch + 1, model)
print('Saved checkpoint to', 'weights.{}.h5'.format(epoch + 1))
def run(args, meta, model, callbacks, exp, id_=100, data=None):
train_ds, val_ds, train_len, validation_len = prerun(args, meta, data)
init_weights_path = Path(args["run_dir"], 'initial_model_weights.h5')
if init_weights_path.exists():
model.load_weights(str(init_weights_path))
if not init_weights_path.exists():
hist = model.fit(train_ds, epochs=1, steps_per_epoch=1)
model.save_weights(str(init_weights_path))
for i, cb in enumerate(callbacks):
if type(cb) == my_callbacks.ValidationMonitor:
cb.set(val_ds, validation_len, id_, exp)
if type(cb) == my_callbacks.ImageLogger:
cb.set_dataset(train_ds, len(args["channels"]))
hist = model.fit(
train_ds,
epochs=args["epochs"],
steps_per_epoch=int(np.ceil(train_len / args["batch_size"])),
callbacks=callbacks,
validation_data=val_ds,
validation_steps=int(np.ceil(validation_len / args["batch_size"])))
return hist
def train(text, epochs=100, save_freq=10):
char_to_idx = {ch: i for (i, ch) in enumerate(sorted(list(set(text))))}
with open(os.path.join(DATA_DIR, 'char_to_idx.json'), 'w') as f:
json.dump(char_to_idx, f)
idx_to_char = {i: ch for (ch, i) in char_to_idx.items()}
vocab_size = len(char_to_idx)
model = build_model(BATCH_SIZE, SEQ_LENGTH, vocab_size)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
T = np.asarray([char_to_idx[c] for c in text], dtype=np.int32)
steps_per_epoch = (len(text) / BATCH_SIZE - 1) / SEQ_LENGTH
log = TrainLogger('training_log.csv')
for epoch in range(epochs):
print('\nEpoch {}/{}'.format(epoch + 1, epochs))
losses, accs = [], []
for i, (X, Y) in enumerate(read_batches(T, vocab_size)):
loss, acc = model.train_on_batch(X, Y)
print('Batch {}: loss = {}, acc = {}'.format(i + 1, loss, acc))
losses.append(loss)
accs.append(acc)
log.add_entry(np.average(losses), np.average(accs))
if (epoch + 1) % save_freq == 0:
save_weights(epoch + 1, model)
print('Saved checkpoint to', 'weights.{}.h5'.format(epoch + 1))
def save_model(model):
json_arch = model.to_json()
json_path = os.path.join("model", "architecture.json")
with open(json_path, 'w') as arch_file:
arch_file.write(json_arch)
model_path = os.path.join("model", "weights.h5")
model.save_weights(model_path)
def save_model(self, name, model):
logging.info("save_model - saving model...")
# serialize model to JSON
model_json = model.to_json()
with open("classifiers/" + name + ".json", "w") as json_file:
json_file.write(model_json)
# serialize weights to HDF5
model.save_weights("classifiers/" + name + "_weights.h5")
logging.info("save_model - saved model to disk")
def train(text, epochs=100, save_freq=10):
# character to index and vice-versa mappings
# Create a set of the input text
# The text contains all unique characters, list it and sort it
# "enumerate" is used to iterate over the elements and store the characters as key and index as values
char_to_idx = {ch: i for (i, ch) in enumerate(sorted(list(set(text))))}
print("Number of unique characters: " + str(len(char_to_idx))) #86
with open(os.path.join(DATA_DIR, 'char_to_idx.json'), 'w') as f:
json.dump(char_to_idx, f)
idx_to_char = {i: ch for (ch, i) in char_to_idx.items()}
vocab_size = len(char_to_idx)
#model_architecture
model = build_model(BATCH_SIZE, SEQ_LENGTH, vocab_size)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
#Train data generation
# Converting the characters of the text to numeric values
T = np.asarray(
[char_to_idx[c] for c in text],
dtype=np.int32) #convert complete text into numerical indices
print("Length of text:" + str(T.size)) #129,665
steps_per_epoch = (len(text) / BATCH_SIZE -
1) / SEQ_LENGTH #(129665/16 - )/64 = 126
log = TrainLogger('training_log.csv')
for epoch in range(epochs):
print('\nEpoch {}/{}'.format(epoch + 1, epochs))
losses, accs = [], []
for i, (X, Y) in enumerate(read_batches(T, vocab_size)):
print(X)
loss, acc = model.train_on_batch(X, Y)
print('Batch {}: loss = {}, acc = {}'.format(i + 1, loss, acc))
losses.append(loss)
accs.append(acc)
log.add_entry(np.average(losses), np.average(accs))
if (epoch + 1) % save_freq == 0:
save_weights(epoch + 1, model)
print('Saved checkpoint to', 'weights.{}.h5'.format(epoch + 1))
def train(text, epochs=100, save_freq=10):
# character to index and vice-versa mappings
char_to_idx = {ch: i for (i, ch) in enumerate(sorted(list(set(text))))}
print("Number of unique characters: " + str(len(char_to_idx))) #86
with open(os.path.join(DATA_DIR, 'char_to_idx.json'), 'w') as f:
json.dump(char_to_idx, f)
idx_to_char = {i: ch for (ch, i) in char_to_idx.items()}
vocab_size = len(char_to_idx)
#model_architecture
model = build_model(BATCH_SIZE, SEQ_LENGTH, vocab_size)
model.summary()
# vizualizing the model in form of png
# plot_model(model, to_file='model.png')
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
#Train data generation
T = np.asarray(
[char_to_idx[c] for c in text],
dtype=np.int32) #convert complete text into numerical indices
print("Length of text:" + str(T.size)) #129,665
steps_per_epoch = (len(text) / BATCH_SIZE -
1) / SEQ_LENGTH # 12, didn't used anywhere
log = TrainLogger(
'training_log.csv') # making a csv file to the log the training
for epoch in range(epochs):
print('\nEpoch {}/{}'.format(epoch + 1, epochs))
losses, accs = [], [
] # they contain loss and accuracy for each batch of all epochs , length of losses would be 128*100
# reading the batches and training on each batch sequentially
for i, (X, Y) in enumerate(read_batches(T, vocab_size)):
print(X)
loss, acc = model.train_on_batch(X, Y)
print('Batch {}: loss = {}, acc = {}'.format(i + 1, loss, acc))
losses.append(loss)
accs.append(acc)
# entries in .csv would be no. of epoches
log.add_entry(np.average(losses), np.average(accs))
# saving the weights at frequency
if (epoch + 1) % save_freq == 0:
save_weights(epoch + 1, model)
print('Saved checkpoint to', 'weights.{}.h5'.format(epoch + 1))
def train(text, epochs=150, save_freq=5, docname=None):
docname = docname[:-4] #Remove .txt from file name
#text = text[0:len(text)//50]
# character to index and vice-versa mappings
char_to_idx = {ch: i for (i, ch) in enumerate(sorted(list(set(text))))}
print("Number of unique characters: " + str(len(char_to_idx))) #75
with open(os.path.join(DATA_DIR, 'char_to_idx_{}.json'.format(docname)),
'w') as f:
json.dump(char_to_idx, f)
idx_to_char = {i: ch for (ch, i) in char_to_idx.items()}
vocab_size = len(char_to_idx)
#model_architecture
model = build_model(BATCH_SIZE, SEQ_LENGTH, vocab_size)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
#Train data generation
T = np.asarray(
[char_to_idx[c] for c in text],
dtype=np.int32) #Convert complete text into numerical indices
print("Length of text:" + str(T.size)) #149,326,361
steps_per_epoch = (len(text) / BATCH_SIZE - 1) / SEQ_LENGTH
log = TrainLogger('training_log_{}.csv'.format(docname))
for epoch in range(epochs):
st = dt.now()
print('\nEpoch {}/{}'.format(epoch + 1, epochs))
losses, accs = [], []
for i, (X, Y) in enumerate(read_batches(T, vocab_size)):
loss, acc = model.train_on_batch(X, Y)
print('Batch {}: loss = {}, acc = {}'.format(i + 1, loss, acc))
losses.append(loss)
accs.append(acc)
log.add_entry(np.average(losses), np.average(accs))
print("Time taken to run epoch {} = {}".format(epoch + 1,
dt.now() - st))
if (epoch + 1) % save_freq == 0:
save_weights(epoch + 1, model, docname)
print('Saved checkpoint to',
'weights.{}_{}.h5'.format(docname, epoch + 1))
def train(text, epochs=100, save_freq=10, resume=False):
if resume:
print("Attempting to resume last training...")
model_dir = Path(MODEL_DIR)
c2ifile = model_dir.joinpath('char_to_idx.json')
with c2ifile.open('r') as f:
char_to_idx = json.load(f)
checkpoints = list(model_dir.glob('weights.*.h5'))
if not checkpoints:
raise ValueError("No checkpoints found to resume from")
resume_epoch = max(int(p.name.split('.')[1]) for p in checkpoints)
print("Resuming from epoch", resume_epoch)
else:
resume_epoch = 0
char_to_idx = {ch: i for (i, ch) in enumerate(sorted(list(set(text))))}
with open(os.path.join(MODEL_DIR, 'char_to_idx.json'), 'w') as f:
json.dump(char_to_idx, f)
vocab_size = len(char_to_idx)
model = build_model(BATCH_SIZE, SEQ_LENGTH, vocab_size)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='adam', metrics=['accuracy'])
if resume:
load_weights(resume_epoch, model)
T = np.asarray([char_to_idx[c] for c in text], dtype=np.int32)
log = TrainLogger('training_log.csv', resume_epoch)
for epoch in range(resume_epoch, epochs):
print('\nEpoch {}/{}'.format(epoch + 1, epochs))
losses, accs = [], []
for i, (X, Y) in enumerate(read_batches(T, vocab_size)):
loss, acc = model.train_on_batch(X, Y)
print('Batch {}: loss = {:.4f}, acc = {:.5f}'.format(i + 1, loss, acc))
losses.append(loss)
accs.append(acc)
log.add_entry(np.average(losses), np.average(accs))
if (epoch + 1) % save_freq == 0:
save_weights(epoch + 1, model)
sample_model = build_sample_model(vocab_size)
load_weights(epoch + 1, sample_model)
sample_model.save('{}/SavedModel-{}'.format(MODEL_DIR, epoch + 1), save_format='tf', overwrite=True)
tfjs.converters.save_keras_model(sample_model, '{}/SavedModel-{}-tfjs'.format(MODEL_DIR, epoch + 1))
print('Saved checkpoint to', 'weights.{}.h5'.format(epoch + 1))
def train(text, epochs=100, save_freq=10):
char_to_idx = {ch: i for (i, ch) in enumerate(sorted(list(set(text))))}
print("Number of unique characters: " + str(len(char_to_idx)))
with open(os.path.join(DATA_DIR, "char_to_idx.json"), "w") as f:
json.dump(char_to_idx, f)
idx_to_char = {i: ch for (ch, i) in char_to_idx.items()}
vocab_size = len(char_to_idx)
model = build_model(BATCH_SIZE, SEQ_LENGTH, vocab_size)
model.summary()
model.compile(
loss="categorical_crossentropy", optimizer='adam', metrics=["accuracy"]
)
T = np.asarray(
[char_to_idx[c] for c in text], dtype=np.int32
)
print("Length of text:" + str(T.size))
steps_per_epoch = (len(text) / BATCH_SIZE - 1) / SEQ_LENGTH
log = TrainLogger("training_log.csv")
for epoch in range(epochs):
print("\nEpoch {}/{}".format(epoch + 1, epochs))
losses, accs = [], []
for i, (X, Y) in enumerate(read_batches(T, vocab_size)):
print(X)
loss, acc = model.train_on_batch(X, Y)
print("Batch {}: loss = {}, acc = {}".format(i + 1, loss, acc))
losses.append(loss)
accs.append(acc)
log.add_entry(np.average(losses), np.average(accs))
if (epoch + 1) % save_freq == 0:
save_weights(epoch + 1, model)
print("Saved checkpoint to", "weights.{}.h5".format(epoch + 1))
def save_model(model):
###############################################################################
# This function saves the weights and the model
#
# Input:
# model: This is the model that it will be saved
# Output:
# None
###############################################################################
model_json = model.to_json()
with open("../resources/model.json", "w") as json_file:
json_file.write(model_json)
model.save_weights("../resources/weights.h5")
def train(notes, char_to_idx, uniqueNotesLen, epochs=100, save_freq=10):
#model_architecture
model = build_model(BATCH_SIZE, SEQ_LENGTH, vocab_size)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
#Train data generation
T = np.asarray(
[char_to_idx[c] for c in notes],
dtype=np.int32) #convert complete text into numerical indices
#T_norm = T / float(uniqueNotesLen)
print("Length of text:" + str(T.size))
print("Length of unique test: ,", uniqueNotesLen)
steps_per_epoch = (len(notes) / BATCH_SIZE - 1) / SEQ_LENGTH
print('Steps per epoch : ', steps_per_epoch)
log = TrainLogger('training_log.csv')
for epoch in range(epochs):
print('\nEpoch {}/{}'.format(epoch + 1, epochs))
losses, accs = [], []
msg = ""
for i, (X, Y) in enumerate(read_batches(T, vocab_size)):
print(X)
loss, acc = model.train_on_batch(X, Y)
print('Batch {}: loss = {}, acc = {}'.format(i + 1, loss, acc))
losses.append(loss)
accs.append(acc)
log.add_entry(np.average(losses), np.average(accs))
if (epoch + 1) % save_freq == 0:
save_weights(epoch + 1, model)
print('Saved checkpoint to', 'weights.{}.h5'.format(epoch + 1))
callback_tensorboard = TensorBoard(log_dir, histogram_freq=1)
callback_checkpoint = ModelCheckpoint(log_dir,
monitor='loss',
verbose=1,
save_best_only=True,
mode='max')
# data generator
data_gen = generator.DataGenerator(x_data,
samples=args['samples'],
batch_size=args['batch'])
# train model
model.fit(x=data_gen,
epochs=args['epochs'],
steps_per_epoch=math.floor(args['samples'] // args['batch']),
callbacks=[
callback_lr_schedule, callback_tensorboard, callback_checkpoint
])
# save model
model_dir = os.path.join(args['datadir'], 'models')
os.makedirs(model_dir, exist_ok=True)
model_hdf5 = '{}-{}-n{}.hdf5'.format(
socket.gethostname(),
datetime.datetime.now().strftime('%Y%m%d_%H%M'),
train_spectrograms_shape[2])
model_path = os.path.join(model_dir, model_hdf5)
model.save_weights(model_path)
log.info('Model weights saved at {}'.format(model_path))
# Load X
img = load_img(filelist_original[i], grayscale=True)
x_img = img_to_array(img)
# --> May not be good for our case, losses information
x_img = resize(x_img, (128, 128, 1), mode='constant', preserve_range=True)
# Load Y
mask = img_to_array(load_img(filelist_masks[i], grayscale=True))
# --> May not be good, same reason
mask = resize(mask, (128, 128, 1), mode='constant', preserve_range=True)
# Save images
X[i] = x_img / 255
y[i] = mask / 255
# Build U-Net model
epochnum = 100
batchnum = 16
input_size = (img_width, img_height, img_chan)
sgd = SGD(lr=0.01, momentum=0.9)
model = model.attn_unet(sgd, input_size, loss.tversky_loss)
hist = model.fit(X,
y,
validation_split=0.15,
shuffle=True,
epochs=epochnum,
batch_size=batchnum,
verbose=True)
model.save_weights('5-10-9p-attn_unet-tverskyloss.h5')
def train(text1, text2, epochs=100, save_freq=10):
# clean input
text1 = unicode(text1, errors='ignore')
text2 = unicode(text2, errors='ignore')
# create character index dictinaries
char_to_idx1 = {ch: i for (i, ch) in enumerate(sorted(list(set(text1))))}
char_to_idx2 = {ch: i for (i, ch) in enumerate(sorted(list(set(text2))))}
# store dicts in files
with open(os.path.join(DATA_DIR, 'char_to_idx1.json'), 'w') as f1:
json.dump(char_to_idx1, f1)
with open(os.path.join(DATA_DIR, 'char_to_idx2.json'), 'w') as f2:
json.dump(char_to_idx2, f2)
# create reverse dictionaries
idx_to_char1 = {i: ch for (ch, i) in char_to_idx1.items()}
idx_to_char2 = {i: ch for (ch, i) in char_to_idx2.items()}
vocab_size = len(char_to_idx1)
# build model with loss and optimization metrics
model = build_model(BATCH_SIZE, SEQ_LENGTH, vocab_size)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# separate training into two texts
T1 = np.asarray([char_to_idx1[c] for c in text1], dtype=np.int32)
T2 = np.asarray([char_to_idx2[c] for c in text2], dtype=np.int32)
# steps_per_epoch = (len(text2) / BATCH_SIZE - 1) / SEQ_LENGTH
log = TrainLogger('training_log.csv')
# train the network
for epoch in range(epochs):
print '\nEpoch {}/{}'.format(epoch + 1, epochs)
losses, accs = [], []
# start training on non-seuss text, switch to Seuss in transfer
# learning after 15 epochs
if epoch < 15:
for i, (X, Y) in enumerate(read_batches(T1, vocab_size)):
loss, acc = model.train_on_batch(X, Y)
# print logs for every batch
print 'Batch {}: loss = {}, acc = {}'.format(i + 1, loss, acc)
losses.append(loss)
accs.append(acc)
else:
for i, (X, Y) in enumerate(read_batches(T2, vocab_size)):
loss, acc = model.train_on_batch(X, Y)
print 'Batch {}: loss = {}, acc = {}'.format(i + 1, loss, acc)
losses.append(loss)
accs.append(acc)
log.add_entry(np.average(losses), np.average(accs))
# save checkpoint data to file
if (epoch + 1) % save_freq == 0:
save_weights(epoch + 1, model)
print 'Saved checkpoint to', 'weights.{}.h5'.format(epoch + 1)
def train(train_text, epochs=100, save_freq=10, resume=False):
resume_epoch = 0
if resume:
model_dir = Path(BASE_DIR + MODEL_DIR)
c2ifile = model_dir.joinpath('char_to_idx.json')
char_to_idx = json.load(c2ifile.open('r'))
checkpoints = list(model_dir.glob('weights.*.h5'))
if not checkpoints:
raise ValueError("체크 포인트 확인 안됨")
resume_epoch = max(int(p.name.split('.')[1]) for p in checkpoints)
else:
char_to_idx = {
ch: i
for (i, ch) in enumerate(sorted(list(set(train_text))))
}
json.dump(
char_to_idx,
open(os.path.join(BASE_DIR + MODEL_DIR, 'char_to_idx.json'), 'w'))
vocab_size = len(char_to_idx)
model = build_model(BATCH_SIZE, SEQ_LENGTH, vocab_size)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
if resume:
load_weights(BASE_DIR, resume_epoch, model)
T = np.asarray([char_to_idx[c] for c in train_text], dtype=np.int32)
log = TrainLogger('training_log.csv', resume_epoch)
losses, accs = [], []
old_time = time.time()
for epoch in range(resume_epoch, epochs):
tmp_losses, tmp_accs = [], []
for i, (X, Y) in enumerate(read_batches(T, vocab_size)):
loss, acc = model.train_on_batch(X, Y)
tmp_losses.append(loss)
tmp_accs.append(acc)
batch_size = len(
train_text) // BATCH_SIZE // SEQ_LENGTH # 한 epoch는 몇 step?
step = epoch * batch_size + i + 1 # 현재 몇 step 실행중?
if step - resume_epoch * batch_size == 1:
print("start!")
old_time = time.time()
last_per = 100 - step * 100 / (epochs * batch_size) # 전체 남은 퍼센트
resume_per = (step - resume_epoch * batch_size) * 100 / (
(epochs - resume_epoch) * batch_size) # 재시작부터 남은 퍼센트
last_sec = round((time.time() - old_time) * (100 - resume_per) /
resume_per) # 남은 시간 = 걸린 시간 * 걸린 퍼센트 / 남은 퍼센트
last_time_str = str(datetime.timedelta(seconds=last_sec)) # 남은 시간
print(
'Last {:.4f}% (남은 시간 : {}) - step {} | epoch : {}/{} | Batch {} | loss = {:.4f}, acc = {:.5f}'
.format(last_per, last_time_str, step, epoch + 1, epochs,
i + 1, loss, acc))
losses.append(tmp_losses)
accs.append(tmp_accs)
if (epoch + 1) % save_freq == 0:
save_weights(BASE_DIR, epoch + 1, model)
for i in range(save_freq):
for j in range(len(losses[0])):
log.add_entry(losses[i][j], accs[i][j])
log.next_epoch()
losses, accs = [], []
print('체크포인트 세이브', 'weights.{}.h5'.format(epoch + 1))
train_data, glove, FILTER)
# Xct, Xqt, Yst, Yet, mappert, maxContextLent, maxQuestionLent = preprocess.preprocess_data(test_data, glove, FILTER)
gen_train = textGen.generate_data(Xc, Xq, Ys, Ye, mapper, maxContextLen,
maxQuestionLen, 128)
# gen_test = textGen.generate_data(Xct, Xqt, Yst, Yet, mappert, maxContextLen, maxQuestionLen, 128)
filepath = "checkpoints/qa-weights-improvement-{epoch:02d}-{loss:.4f}.hdf5"
checkpoint = ModelCheckpoint(filepath,
monitor='loss',
verbose=1,
save_best_only=True,
mode='min')
history = History()
callbacks_list = [checkpoint, history]
print("Max Question Length: {}".format(maxQuestionLen))
print("Max Context Length: {}".format(maxContextLen))
# print("test data len {}".format(len(test_data)))
# print("gen_test {}".format(np.array(next(gen_test)[0]).shape))
model = model.generate_model(maxContextLen, maxQuestionLen)
model.fit_generator(gen_train,
steps_per_epoch=Xq.shape[0] // 128,
epochs=10,
callbacks=callbacks_list)
model.save_weights(WEIGHTS_FILEPATH)
with open('history.pickle', 'wb') as handle:
pickle.dump(a, handle, protocol=pickle.HIGHEST_PROTOCOL)
def train_autoencoder():
print('building model')
layers = model.build_model()
max_epochs = 5000
batch_size = 128
weightsfile = join('weights', 'weights_train_val.pickle')
print('compiling theano functions for training')
print(' encoder/decoder')
encoder_decoder_update = theano_funcs.create_encoder_decoder_func(
layers, apply_updates=True)
print(' discriminator')
discriminator_update = theano_funcs.create_discriminator_func(
layers, apply_updates=True)
print(' generator')
generator_update = theano_funcs.create_generator_func(
layers, apply_updates=True)
print('compiling theano functions for validation')
print(' encoder/decoder')
encoder_decoder_func = theano_funcs.create_encoder_decoder_func(layers)
print(' discriminator')
discriminator_func = theano_funcs.create_discriminator_func(layers)
print(' generator')
generator_func = theano_funcs.create_generator_func(layers)
print('loading data')
X_train, y_train, X_test, y_test = utils.load_mnist()
try:
for epoch in range(1, max_epochs + 1):
print('epoch %d' % (epoch))
# compute loss on training data and apply gradient updates
train_reconstruction_losses = []
train_discriminative_losses = []
train_generative_losses = []
for train_idx in get_batch_idx(X_train.shape[0], batch_size):
X_train_batch = X_train[train_idx]
# 1.) update the encoder/decoder to min. reconstruction loss
train_batch_reconstruction_loss =\
encoder_decoder_update(X_train_batch)
# sample from p(z)
pz_train_batch = np.random.uniform(
low=-2, high=2,
size=(X_train_batch.shape[0], 2)).astype(
np.float32)
# 2.) update discriminator to separate q(z|x) from p(z)
train_batch_discriminative_loss =\
discriminator_update(X_train_batch, pz_train_batch)
# 3.) update generator to output q(z|x) that mimic p(z)
train_batch_generative_loss = generator_update(X_train_batch)
train_reconstruction_losses.append(
train_batch_reconstruction_loss)
train_discriminative_losses.append(
train_batch_discriminative_loss)
train_generative_losses.append(
train_batch_generative_loss)
# average over minibatches
train_reconstruction_losses_mean = np.mean(
train_reconstruction_losses)
train_discriminative_losses_mean = np.mean(
train_discriminative_losses)
train_generative_losses_mean = np.mean(
train_generative_losses)
print(' train: rec = %.6f, dis = %.6f, gen = %.6f' % (
train_reconstruction_losses_mean,
train_discriminative_losses_mean,
train_generative_losses_mean,
))
# compute loss on test data
test_reconstruction_losses = []
test_discriminative_losses = []
test_generative_losses = []
for test_idx in get_batch_idx(X_test.shape[0], batch_size):
X_test_batch = X_test[test_idx]
test_batch_reconstruction_loss =\
encoder_decoder_func(X_test_batch)
# sample from p(z)
pz_test_batch = np.random.uniform(
low=-2, high=2,
size=(X_test.shape[0], 2)).astype(
np.float32)
test_batch_discriminative_loss =\
discriminator_func(X_test_batch, pz_test_batch)
test_batch_generative_loss = generator_func(X_test_batch)
test_reconstruction_losses.append(
test_batch_reconstruction_loss)
test_discriminative_losses.append(
test_batch_discriminative_loss)
test_generative_losses.append(
test_batch_generative_loss)
test_reconstruction_losses_mean = np.mean(
test_reconstruction_losses)
test_discriminative_losses_mean = np.mean(
test_discriminative_losses)
test_generative_losses_mean = np.mean(
test_generative_losses)
print(' test: rec = %.6f, dis = %.6f, gen = %.6f' % (
test_reconstruction_losses_mean,
test_discriminative_losses_mean,
test_generative_losses_mean,
))
except KeyboardInterrupt:
print('caught ctrl-c, stopped training')
weights = get_all_param_values([
layers['l_decoder_out'],
layers['l_discriminator_out'],
])
print('saving weights to %s' % (weightsfile))
model.save_weights(weights, weightsfile)
def train_dcgan(model, epochs=5):
print("done")
generator, discriminator = model.layers
discriminator.compile(loss="binary_crossentropy", optimizer="rmsprop")
discriminator.trainable = False
model.compile(loss="binary_crossentropy", optimizer="rmsprop")
path = '/content/drive/MyDrive/cars_train/'
for epoch in tqdm(range(epochs)):
print("Epoch {}/{}".format(epoch + 1, epochs))
for root, dirnames, filenames in os.walk(path):
i = 0
j = 0
x_train_x = np.zeros((32, 24, 24, 3))
x_train_y = np.zeros((32, 96, 96, 3))
for filename in filenames:
img_path = os.path.join(path, filename)
x_train = cv2.imread(img_path)
x_trainx = cv2.resize(x_train, (24, 24))
x_trainy = cv2.resize(x_train, (96, 96))
x_train_x[i] = x_trainx
x_train_y[i] = x_trainy
i = i + 1
if i == 32:
j = j + 1
print("batch {}/254".format(j))
X_batch, Y_batch = x_train_x, x_train_y
X_batch = tf.cast(X_batch, tf.float32)
Y_batch = tf.cast(Y_batch, tf.float32)
generated_images = generator(X_batch)
X = tf.cast(generated_images, tf.float32)
X_fake_and_real = tf.concat([X, Y_batch], axis=0)
y1 = tf.constant([[0.]] * batch_size + [[1.]] * batch_size)
discriminator.trainable = True
discriminator.train_on_batch(X_fake_and_real, y1)
y2 = tf.constant([[1.]] * batch_size)
discriminator.trainable = False
model.train_on_batch(X_batch, y2)
i = 0
x_train_x = np.zeros((32, 24, 24, 3))
x_train_y = np.zeros((32, 96, 96, 3))
#Check result after every 100 epochs
if (epoch + 1) % 100 == 0:
generator.save_weights("Generator{}.h5".format(epoch))
discriminator.save_weights(
"Discriminator_weights{}.h5".format(epoch))
model.save_weights("Model{}.h5".format(epoch))
from google.colab.patches import cv2_imshow
path = "/content/drive/MyDrive/cars_train/07336.jpg"
X = cv2.imread(path)
X = cv2.resize(X, (24, 24))
X = np.reshape(X, (1, 24, 24, 3))
X_batch = tf.cast(X, tf.float32)
Y = generator(X_batch)
cv2_imshow(X[0])
cv2_imshow(Y[0].numpy())
def saveModel(model, name):
json_string = model.to_json()
open('./model/'+ name +'_model.json', 'w').write(json_string)
model.save_weights('./model/'+ name +'_model_weights.h5', overwrite = True)
print("Saving the Model.")
def train_autoencoder():
print('building model')
layers = model.build_model()
max_epochs = 5000
batch_size = 128
weightsfile = join('weights', 'weights_train_val.pickle')
print('compiling theano functions for training')
print(' encoder/decoder')
encoder_decoder_update = theano_funcs.create_encoder_decoder_func(
layers, apply_updates=True)
print(' discriminator')
discriminator_update = theano_funcs.create_discriminator_func(
layers, apply_updates=True)
print(' generator')
generator_update = theano_funcs.create_generator_func(layers,
apply_updates=True)
print('compiling theano functions for validation')
print(' encoder/decoder')
encoder_decoder_func = theano_funcs.create_encoder_decoder_func(layers)
print(' discriminator')
discriminator_func = theano_funcs.create_discriminator_func(layers)
print(' generator')
generator_func = theano_funcs.create_generator_func(layers)
print('loading data')
X_train, y_train, X_test, y_test = utils.load_mnist()
try:
for epoch in range(1, max_epochs + 1):
print('epoch %d' % (epoch))
# compute loss on training data and apply gradient updates
train_reconstruction_losses = []
train_discriminative_losses = []
train_generative_losses = []
for train_idx in get_batch_idx(X_train.shape[0], batch_size):
X_train_batch = X_train[train_idx]
# 1.) update the encoder/decoder to min. reconstruction loss
train_batch_reconstruction_loss =\
encoder_decoder_update(X_train_batch)
# sample from p(z)
pz_train_batch = np.random.uniform(
low=-2, high=2,
size=(X_train_batch.shape[0], 2)).astype(np.float32)
# 2.) update discriminator to separate q(z|x) from p(z)
train_batch_discriminative_loss =\
discriminator_update(X_train_batch, pz_train_batch)
# 3.) update generator to output q(z|x) that mimic p(z)
train_batch_generative_loss = generator_update(X_train_batch)
train_reconstruction_losses.append(
train_batch_reconstruction_loss)
train_discriminative_losses.append(
train_batch_discriminative_loss)
train_generative_losses.append(train_batch_generative_loss)
# average over minibatches
train_reconstruction_losses_mean = np.mean(
train_reconstruction_losses)
train_discriminative_losses_mean = np.mean(
train_discriminative_losses)
train_generative_losses_mean = np.mean(train_generative_losses)
print(' train: rec = %.6f, dis = %.6f, gen = %.6f' % (
train_reconstruction_losses_mean,
train_discriminative_losses_mean,
train_generative_losses_mean,
))
# compute loss on test data
test_reconstruction_losses = []
test_discriminative_losses = []
test_generative_losses = []
for test_idx in get_batch_idx(X_test.shape[0], batch_size):
X_test_batch = X_test[test_idx]
test_batch_reconstruction_loss =\
encoder_decoder_func(X_test_batch)
# sample from p(z)
pz_test_batch = np.random.uniform(low=-2,
high=2,
size=(X_test.shape[0],
2)).astype(np.float32)
test_batch_discriminative_loss =\
discriminator_func(X_test_batch, pz_test_batch)
test_batch_generative_loss = generator_func(X_test_batch)
test_reconstruction_losses.append(
test_batch_reconstruction_loss)
test_discriminative_losses.append(
test_batch_discriminative_loss)
test_generative_losses.append(test_batch_generative_loss)
test_reconstruction_losses_mean = np.mean(
test_reconstruction_losses)
test_discriminative_losses_mean = np.mean(
test_discriminative_losses)
test_generative_losses_mean = np.mean(test_generative_losses)
print(' test: rec = %.6f, dis = %.6f, gen = %.6f' % (
test_reconstruction_losses_mean,
test_discriminative_losses_mean,
test_generative_losses_mean,
))
except KeyboardInterrupt:
print('caught ctrl-c, stopped training')
weights = get_all_param_values([
layers['l_decoder_out'],
layers['l_discriminator_out'],
])
print('saving weights to %s' % (weightsfile))
model.save_weights(weights, weightsfile)
def train(train_loader, validate_loader):
if use_VAE:
model = MaskDifferNet()
optimizer = torch.optim.Adam([{
'params': model.nf.parameters()
}, {
'params': model.vae.parameters()
}],
lr=c.lr_init,
betas=(0.8, 0.8),
eps=1e-04,
weight_decay=1e-5)
else:
model = DifferNet()
optimizer = torch.optim.Adam([{
'params': model.nf.parameters()
}],
lr=c.lr_init,
betas=(0.8, 0.8),
eps=1e-04,
weight_decay=1e-5)
model.to(c.device)
save_name_pre = '{}_{}_{:.2f}_{:.2f}_{:.2f}_{:.2f}'.format(
c.modelname, c.rotation_degree, c.shrink_scale_top,
c.shrink_scale_left, c.shrink_scale_bot, c.shrink_scale_right)
score_obs = Score_Observer('AUROC')
for epoch in range(c.meta_epochs):
# train some epochs
model.train()
if c.verbose:
print(F'\nTrain epoch {epoch}')
for sub_epoch in range(c.sub_epochs):
train_loss = list()
for i, data in enumerate(
tqdm(train_loader, disable=c.hide_tqdm_bar)):
optimizer.zero_grad()
inputs, labels = preprocess_batch(
data) # move to device and reshape
# TODO inspect
# inputs += torch.randn(*inputs.shape).cuda() * c.add_img_noise
if use_VAE:
z, masks, masked_imgs = model(inputs)
counter_masks = torch.zeros(masks.shape)
# print(masks)
inputs = Variable(inputs, requires_grad=False)
masks = Variable(masks, requires_grad=True)
counter_masks = Variable(counter_masks,
requires_grad=False)
masked_imgs = Variable(masked_imgs, requires_grad=True)
# Reference: https://github.com/Po-Hsun-Su/pytorch-ssim
ssim = pytorch_ssim.SSIM()
counter_masks = counter_masks.to("cuda")
similarity_loss = -ssim(inputs, masked_imgs)
size_loss = -ssim(masks, counter_masks)
ssim_loss = alpha * similarity_loss + beta * size_loss
ssim_loss.backward()
# print("ssim_loss: " + str(ssim_loss))
loss = get_loss(z, model.nf.jacobian(run_forward=False))
train_loss.append(t2np(loss))
loss.backward()
optimizer.step()
else:
z = model(inputs)
loss = get_loss(z, model.nf.jacobian(run_forward=False))
train_loss.append(t2np(loss))
loss.backward()
optimizer.step()
mean_train_loss = np.mean(train_loss)
if c.verbose:
print('Epoch: {:d}.{:d} \t train loss: {:.4f}'.format(
epoch, sub_epoch, mean_train_loss))
if not (validate_loader is None):
# evaluate
model.eval()
if c.verbose:
print('\nCompute loss and scores on validate set:')
test_loss = list()
test_z = list()
test_labels = list()
with torch.no_grad():
for i, data in enumerate(
tqdm(validate_loader, disable=c.hide_tqdm_bar)):
inputs, labels = preprocess_batch(data)
if use_VAE:
z, masks, masked_imgs = model(inputs)
else:
z = model(inputs)
loss = get_loss(z, model.nf.jacobian(run_forward=False))
test_z.append(z)
test_loss.append(t2np(loss))
test_labels.append(t2np(labels))
test_loss = np.mean(np.array(test_loss))
test_labels = np.concatenate(test_labels)
is_anomaly = np.array([0 if l == 0 else 1 for l in test_labels])
z_grouped = torch.cat(test_z, dim=0).view(-1, c.n_transforms_test,
c.n_feat)
anomaly_score = t2np(torch.mean(z_grouped**2, dim=(-2, -1)))
AUROC = roc_auc_score(is_anomaly, anomaly_score)
score_obs.update(AUROC,
epoch,
print_score=c.verbose
or epoch == c.meta_epochs - 1)
fpr, tpr, thresholds = roc_curve(is_anomaly, anomaly_score)
model_parameters = {}
model_parameters['fpr'] = fpr.tolist()
model_parameters['tpr'] = tpr.tolist()
model_parameters['thresholds'] = thresholds.tolist()
model_parameters['AUROC'] = AUROC
save_parameters(model_parameters,
save_name_pre + "_{:.4f}".format(AUROC))
save_roc_plot(fpr, tpr, save_name_pre + "_{:.4f}".format(AUROC))
if c.verbose:
print('Epoch: {:d} \t validate_loss: {:.4f}'.format(
epoch, test_loss))
# compare is_anomaly and anomaly_score
np.set_printoptions(precision=2, suppress=True)
print('is_anomaly: ', is_anomaly)
print('anomaly_score: ', anomaly_score)
print('fpr: ', fpr)
print('tpr: ', tpr)
print('thresholds: ', thresholds)
if c.grad_map_viz and not (validate_loader is None):
export_gradient_maps(model, validate_loader, optimizer, 1)
if c.save_model:
model.to('cpu')
save_model(model, save_name_pre + '.pth')
save_weights(model, save_name_pre + '.weights.pth')
return model, model_parameters
# seed=42
)
checkpoint_dir = os.path.dirname(checkpoint_path)
# Create a callback that saves the model's weights
cp_callback = tf.keras.callbacks.ModelCheckpoint(
filepath=checkpoint_path,
save_weights_only=True,
verbose=1,
save_freq=5 # Save every 5 epoch
)
model = model.get()
model.save_weights(checkpoint_path.format(epoch=0))
STEP_SIZE_TRAIN = train_data_gen.n // train_data_gen.batch_size
STEP_SIZE_VALID = val_data_gen.n // val_data_gen.batch_size
print("steps_per_epoch : {:d} ".format(STEP_SIZE_TRAIN))
print("validation_steps : {:d} ".format(STEP_SIZE_VALID))
history = model.fit_generator(generator=train_data_gen,
steps_per_epoch=STEP_SIZE_TRAIN,
validation_data=val_data_gen,
validation_steps=STEP_SIZE_VALID,
epochs=epochs)
model.summary()
#!/usr/bin/python
import time
import six.moves.cPickle
import model
import yelp_reader
model, tokeniser, dictionarySize = model.train(yelp_reader, oneHot = True, oneHotAveraged = True, contextHashes
= False)
jsonModel = model.to_json()
open('model.json', 'w').write(jsonModel)
open('model-dictionary-size.dat', 'w').write(str(dictionarySize))
six.moves.cPickle.dump(tokeniser, open("tokeniser.pkl", "wb"))
model.save_weights('model-' + str(time.time()) + '.h5')
print("No weights found...... model loaded with image_net weights...")
pass
SavingWeights = ModelCheckpoint('weights.h5',
save_weights_only=True,
verbose=1,
save_best_only=True)
for epoch in range(epochs):
print("Running Epoch No==> " + str(epoch))
train_batches = generator1.data_gen(train_path, desired_size, no_channels,
batch_size, shuffle)
valid_batches = generator1.data_gen(valid_path, desired_size, no_channels,
batch_size, shuffle)
hist = model.fit_generator(train_batches,
steps_per_epoch=np.floor(t_files / batch_size),
epochs=1,
verbose=1,
shuffle=True)
l = model.evaluate_generator(valid_batches,
steps=np.floor(v_files / batch_size),
verbose=1)
new_los = l[0]
print("validation loss==> " + str(l[0]) + " validation Accuracy==> " +
str(l[1]))
if new_los < los:
print("saving Weights")
model.save_weights('weights.h5')
los = new_los
def train(train_loader, test_loader):
model = DifferNet()
optimizer = torch.optim.Adam(model.nf.parameters(),
lr=c.lr_init,
betas=(0.8, 0.8),
eps=1e-04,
weight_decay=1e-5)
model.to(c.device)
score_obs = Score_Observer('AUROC')
for epoch in range(c.meta_epochs):
# train some epochs
model.train()
if c.verbose:
print(F'\nTrain epoch {epoch}')
for sub_epoch in range(c.sub_epochs):
train_loss = list()
for i, data in enumerate(
tqdm(train_loader, disable=c.hide_tqdm_bar)):
optimizer.zero_grad()
inputs, labels = preprocess_batch(
data) # move to device and reshape
# TODO inspect
# inputs += torch.randn(*inputs.shape).cuda() * c.add_img_noise
z = model(inputs)
loss = get_loss(z, model.nf.jacobian(run_forward=False))
train_loss.append(t2np(loss))
loss.backward()
optimizer.step()
mean_train_loss = np.mean(train_loss)
if c.verbose:
print('Epoch: {:d}.{:d} \t train loss: {:.4f}'.format(
epoch, sub_epoch, mean_train_loss))
# evaluate
model.eval()
if c.verbose:
print('\nCompute loss and scores on test set:')
test_loss = list()
test_z = list()
test_labels = list()
with torch.no_grad():
for i, data in enumerate(tqdm(test_loader,
disable=c.hide_tqdm_bar)):
inputs, labels = preprocess_batch(data)
z = model(inputs)
loss = get_loss(z, model.nf.jacobian(run_forward=False))
test_z.append(z)
test_loss.append(t2np(loss))
test_labels.append(t2np(labels))
test_loss = np.mean(np.array(test_loss))
if c.verbose:
print('Epoch: {:d} \t test_loss: {:.4f}'.format(epoch, test_loss))
test_labels = np.concatenate(test_labels)
is_anomaly = np.array([0 if l == 0 else 1 for l in test_labels])
z_grouped = torch.cat(test_z, dim=0).view(-1, c.n_transforms_test,
c.n_feat)
anomaly_score = t2np(torch.mean(z_grouped**2, dim=(-2, -1)))
score_obs.update(roc_auc_score(is_anomaly, anomaly_score),
epoch,
print_score=c.verbose or epoch == c.meta_epochs - 1)
if c.grad_map_viz:
export_gradient_maps(model, test_loader, optimizer, -1)
if c.save_model:
model.to('cpu')
save_model(model, c.modelname)
save_weights(model, c.modelname)
return model
prev_improvement = loss
t2 = time.time()
print(
"Iter : %d / %d, Time elapsed : %0.2f seconds, Loss : %d, Improvement : %0.2f percent."
% (iteration, NUM_ITR, t2 - t1, loss, improvement))
print(
"Detail: content_loss: %0.2f, style_loss_1: %0.2f, style_loss_2: %0.2f,"
" style_loss_3: %0.2f, style_loss_4: %0.2f, tv_loss: %0.2f" %
(res.history["content_loss"][0], res.history["style1_loss"][0],
res.history["style2_loss"][0], res.history["style3_loss"][0],
res.history["style4_loss"][0], res.history["tv_loss"][0]))
if iteration >= NUM_ITR:
break
except KeyboardInterrupt:
print("Keyboard interrupt. Training suspended. Saving weights...")
interrupted = True
break
iteration = 0
if interrupted:
break
t_total_2 = time.time()
print("Training ended. Time used: %0.2f." % (t_total_2 - t_total_1))
model.save_weights(training_model, args.style_name, "weights/")
