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/")