def sample(epoch, header, num_chars): with open(os.path.join(DATA_DIR, 'char_to_idx.json'), encoding="utf8") as f: char_to_idx = json.load(f) idx_to_char = {i: ch for (ch, i) in char_to_idx.items()} vocab_size = len(char_to_idx) model = build_sample_model(vocab_size) load_weights(epoch, model) model.save(os.path.join(MODEL_DIR, 'model.{}.h5'.format(epoch))) sampled = [char_to_idx[c] for c in header] print(sampled) for i in range(num_chars): batch = np.zeros((1, 1)) if sampled: batch[0, 0] = sampled[-1] else: batch[0, 0] = np.random.randint(vocab_size) result = model.predict_on_batch(batch).ravel() sample = np.random.choice(range(vocab_size), p=result) sampled.append(sample) return ''.join(idx_to_char[c] for c in sampled)
def sample(epoch, header, num_chars): with open(os.path.join(BASE_DIR, MODEL_DIR, 'char_to_idx.json'), 'r') as f: char_to_idx = json.load(f) idx_to_char = {i: ch for (ch, i) in list(char_to_idx.items())} vocab_size = len(char_to_idx) model = build_sample_model(vocab_size) load_weights(BASE_DIR, epoch, model) model.save(os.path.join(BASE_DIR, MODEL_DIR, 'model.{}.h5'.format(epoch))) sampled = [char_to_idx[c] for c in header] for c in header[:-1]: batch = np.zeros((1, 1)) batch[0, 0] = char_to_idx[c] model.predict_on_batch(batch) for i in range(num_chars): batch = np.zeros((1, 1)) if sampled: batch[0, 0] = sampled[-1] else: batch[0, 0] = np.random.randint(vocab_size) result = model.predict_on_batch(batch).ravel() sampleWord = np.random.choice(list(range(vocab_size)), p=result) sampled.append(sampleWord) return ''.join(idx_to_char[c] for c in sampled)
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 sample(epoch, header, num_lines): with open(os.path.join(MODEL_DIR, 'char_to_idx.json'), 'r') as f: char_to_idx = json.load(f) idx_to_char = {i: ch for (ch, i) in list(char_to_idx.items())} vocab_size = len(char_to_idx) newline_symbol = char_to_idx['\n'] model = build_sample_model(vocab_size) load_weights(epoch, model) sampled = [char_to_idx[c] for c in header] for c in header[:-1]: batch = np.zeros((1, 1)) batch[0, 0] = char_to_idx[c] model.predict_on_batch(batch) for i in range(num_lines): sample = -1 while not sample == newline_symbol: batch = np.zeros((1, 1)) if sampled: batch[0, 0] = sampled[-1] else: batch[0, 0] = np.random.randint(vocab_size) result = model.predict_on_batch(batch).ravel() sample = np.random.choice(list(range(vocab_size)), p=result) sampled.append(sample) return ''.join(idx_to_char[c] for c in sampled).strip()
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 load(self, model_dir, load_optimizer=True, lr_scheduler=None): if not os.path.exists(model_dir): print(f'file: {model_dir} not found') load_weights(self.yolov2, self.opt.github_model) # self.init_weights(self.yolov2) return float('inf'), 0, 0 else: state_dict = torch.load(model_dir) if 'loss' in state_dict: loss = state_dict['loss'] else: loss = float('inf') if 'epoch' in state_dict: epoch = state_dict['epoch'] else: epoch = 0 if 'total_steps' in state_dict: steps = state_dict['total_steps'] else: steps = 0 if 'model' in state_dict: print(f'loading pretrained model: {model_dir}') self.yolov2.load_state_dict(state_dict['model']) if load_optimizer and 'optimizer' in state_dict: self.optimizer.load_state_dict(state_dict['optimizer']) if lr_scheduler is not None and 'lr_scheduler' in state_dict: lr_scheduler.load_state_dict(state_dict['lr_scheduler']) return loss, epoch, steps
def sample(epoch, header, num_chars): # get the character dictionary and build the character-index dict with open(os.path.join(DATA_DIR, 'char_to_idx2.json')) as f: char_to_idx2 = json.load(f) idx_to_char2 = {i: ch for (ch, i) in char_to_idx2.items()} vocab_size = len(char_to_idx2) model = build_model(1, 1, vocab_size) load_weights(epoch, model) # header implementation if needed sampled = [char_to_idx2[c] for c in header] for c in header[:-1]: batch = np.zeros((1, 1)) batch[0, 0] = char_to_idx2[c] model.predict_on_batch(batch) # sample until parameter for i in range(num_chars): batch = np.zeros((1, 1)) if sampled: batch[0, 0] = sampled[-1] else: batch[0, 0] = np.random.randint(vocab_size) result = model.predict_on_batch(batch).ravel() sample = np.random.choice(range(vocab_size), p=result) sampled.append(sample) print ''.join(idx_to_char2[c] for c in sampled)
def init_model(epoch): with open(os.path.join(MODEL_DIR, 'char_to_idx.json'), 'r') as f: char_to_idx = json.load(f) idx_to_char = { i: ch for (ch, i) in list(char_to_idx.items()) } vocab_size = len(char_to_idx) model = build_sample_model(vocab_size) load_weights(epoch, model) return model, vocab_size, idx_to_char
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(self): # self.writer.add_graph(self.trainer.yolov2.cpu(), # input_to_model=torch.rand(opt.batch_size, 3, opt.img_h, opt.img_w, device='cpu')) self.trainer.yolov2.train() loss_tmp = float('inf') if os.path.exists(opt.saved_model_path): self.logger.info(f'Use pretrained model: {opt.saved_model_path}') self.trainer.use_pretrain(opt.saved_model_path) loss_tmp = self.trainer.last_loss start_epoch = self.trainer.epoch_num total_steps = self.trainer.total_steps else: start_epoch = 0 total_steps = 0 self.logger.info('Train from stratch ...') pretrained_ckpt_path = '/home/dk/jyl/V2/COCO/model/ckpt/only_params_trained_yolo_coco' load_weights(self.trainer.yolov2, pretrained_ckpt_path, reinit_last=False) for epoch in range(start_epoch, opt.epochs): for i, (imgs, targets) in tqdm(enumerate(self.VocTrainDataLoader)): imgs, tragets = imgs.to(opt.device), targets.to(opt.device) self.trainer.train_step(imgs, tragets, epoch + 1) total_steps += 1 mean_loss = self.trainer.loss_meter.mean loss_dict = self.trainer.loss_dict self.add_train_summary(loss_dict, total_steps) if total_steps % opt.display_step == 0: message = f'Epoch[{epoch: 03}] Step[{(epoch * self.train_data_length + i + 1): 06}]] \n' \ f'mean_loss : {mean_loss:.3f} \n' \ f'xy_loss : {loss_dict["dxdy_loss"]:.3f} \n' \ f'wh_loss : {loss_dict["twth_loss"]:.3f} \n' \ f'conf_loss : {loss_dict["conf_loss"]:.3f} \n' \ f'class_loss: {loss_dict["class_loss"]:.3f} \n' \ f'obj_loss : {loss_dict["obj_loss"]:.3f} \n' \ f'noobj_loss: {loss_dict["noobj_loss"]:.3f} \n' \ f'total_loss: {loss_dict["total_loss"]:.3f} \n' \ f'current learning rate: {self.scheduler.get_lr()}' self.logger.info(message) if total_steps % opt.eval_step == 0: self.eval(epoch, i + 1) if mean_loss < loss_tmp: loss_tmp = mean_loss self.trainer.save( epoch, total_steps, mean_loss, opt.model_save_dir + f'/model_best_{opt.optimizer_type}_2.pkl') if total_steps % opt.save_step == 0: self.trainer.save( epoch, total_steps, mean_loss, opt.model_save_dir + f'/model_every_2.pkl') self.scheduler.step()
def test(lowlight_test_images_path): input_img = Input(shape=(512, 512, 3)) conv1 = Conv2D(32, (3, 3), strides=(1,1), activation='relu', padding='same')(input_img) conv2 = Conv2D(32, (3, 3), strides=(1,1), activation='relu', padding='same')(conv1) conv3 = Conv2D(32, (3, 3), strides=(1,1), activation='relu', padding='same')(conv2) conv4 = Conv2D(32, (3, 3), strides=(1,1), activation='relu', padding='same')(conv3) int_con1 = Concatenate(axis=-1)([conv4, conv3]) conv5 = Conv2D(32, (3, 3), strides=(1,1), activation='relu', padding='same')(int_con1) int_con2 = Concatenate(axis=-1)([conv5, conv2]) conv6 = Conv2D(32, (3, 3), strides=(1,1), activation='relu', padding='same')(int_con2) int_con3 = Concatenate(axis=-1)([conv6, conv1]) x_r = Conv2D(24, (3,3), strides=(1,1), activation='tanh', padding='same')(int_con3) model = Model(inputs=input_img, outputs = x_r) model.load_weights("weights/ep_2_it_200.h5") ### load image ### for test_file in glob.glob(lowlight_test_images_path + "*.jpg"): data_lowlight_path = test_file original_img = Image.open(data_lowlight_path) original_size = (np.array(original_img).shape[1], np.array(original_img).shape[0]) original_img = original_img.resize((512,512), Image.ANTIALIAS) original_img = (np.asarray(original_img)/255.0) img_lowlight = Image.open(data_lowlight_path) img_lowlight = img_lowlight.resize((512,512), Image.ANTIALIAS) img_lowlight = (np.asarray(img_lowlight)/255.0) img_lowlight = np.expand_dims(img_lowlight, 0) # img_lowlight = K.constant(img_lowlight) ### process image ### A = model.predict(img_lowlight) r1, r2, r3, r4, r5, r6, r7, r8 = A[:,:,:,:3], A[:,:,:,3:6], A[:,:,:,6:9], A[:,:,:,9:12], A[:,:,:,12:15], A[:,:,:,15:18], A[:,:,:,18:21], A[:,:,:,21:24] x = original_img + r1 * (K.pow(original_img,2)-original_img) x = x + r2 * (K.pow(x,2)-x) x = x + r3 * (K.pow(x,2)-x) enhanced_image_1 = x + r4*(K.pow(x,2)-x) x = enhanced_image_1 + r5*(K.pow(enhanced_image_1,2)-enhanced_image_1) x = x + r6*(K.pow(x,2)-x) x = x + r7*(K.pow(x,2)-x) enhance_image = x + r8*(K.pow(x,2)-x) enhance_image = tf.cast((enhance_image[0,:,:,:] * 255), dtype=np.uint8) enhance_image = Image.fromarray(enhance_image.numpy()) enhance_image = enhance_image.resize(original_size, Image.ANTIALIAS) enhance_image.save(test_file.replace(".jpg", "_rs.jpg"))
def simple_model(pretrained_weights=None, input_size=(256, 256, 1)): inputs = tf.keras.Input(input_size) conv1 = tf.keras.layers.Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')( inputs) # 256 conv1 = tf.keras.layers.Conv2D(32, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv1) conv1 = tf.keras.layers.Conv2D(32, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv1) conv1 = tf.keras.layers.Conv2D(16, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv1) conv1 = tf.keras.layers.Conv2D(8, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv1) conv1 = tf.keras.layers.Conv2D(1, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv1) model = tf.keras.models.Model(inputs=inputs, outputs=conv1) model.compile(optimizer=tf.keras.optimizers.Adam(lr=1e-4), loss="mean_absolute_error", metrics=['accuracy'], run_eagerly=True) model.summary() if (pretrained_weights): model.load_weights(pretrained_weights) return model
def plot_latent_space(weightsfile): print('building model') layers = model.build_model() batch_size = 128 decoder_func = theano_funcs.create_decoder_func(layers) print('loading weights from %s' % (weightsfile)) model.load_weights([ layers['l_decoder_out'], layers['l_discriminator_out'], ], weightsfile) # regularly-spaced grid of points sampled from p(z) Z = np.mgrid[2:-2.2:-0.2, -2:2.2:0.2].reshape(2, -1).T[:, ::-1].astype(np.float32) reconstructions = [] print('generating samples') for idx in get_batch_idx(Z.shape[0], batch_size): Z_batch = Z[idx] X_batch = decoder_func(Z_batch) reconstructions.append(X_batch) X = np.vstack(reconstructions) X = X.reshape(X.shape[0], 28, 28) fig = plt.figure(1, (12., 12.)) ax1 = plt.axes(frameon=False) ax1.get_xaxis().set_visible(False) ax1.get_yaxis().set_visible(False) plt.title('samples generated from latent space of autoencoder') grid = ImageGrid( fig, 111, nrows_ncols=(21, 21), share_all=True) print('plotting latent space') for i, x in enumerate(X): img = (x * 255).astype(np.uint8) grid[i].imshow(img, cmap='Greys_r') grid[i].get_xaxis().set_visible(False) grid[i].get_yaxis().set_visible(False) grid[i].set_frame_on(False) plt.savefig('latent_train_val.png', bbox_inches='tight')
def plot_latent_space(weightsfile): print('building model') layers = model.build_model() batch_size = 128 decoder_func = theano_funcs.create_decoder_func(layers) print('loading weights from %s' % (weightsfile)) model.load_weights([ layers['l_decoder_out'], layers['l_discriminator_out'], ], weightsfile) # regularly-spaced grid of points sampled from p(z) Z = np.mgrid[2:-2.2:-0.2, -2:2.2:0.2].reshape(2, -1).T[:, ::-1].astype(np.float32) reconstructions = [] print('generating samples') for idx in get_batch_idx(Z.shape[0], batch_size): Z_batch = Z[idx] X_batch = decoder_func(Z_batch) reconstructions.append(X_batch) X = np.vstack(reconstructions) X = X.reshape(X.shape[0], 28, 28) fig = plt.figure(1, (12., 12.)) ax1 = plt.axes(frameon=False) ax1.get_xaxis().set_visible(False) ax1.get_yaxis().set_visible(False) plt.title('samples generated from latent space of autoencoder') grid = ImageGrid(fig, 111, nrows_ncols=(21, 21), share_all=True) print('plotting latent space') for i, x in enumerate(X): img = (x * 255).astype(np.uint8) grid[i].imshow(img, cmap='Greys_r') grid[i].get_xaxis().set_visible(False) grid[i].get_yaxis().set_visible(False) grid[i].set_frame_on(False) plt.savefig('latent_train_val.png', bbox_inches='tight')
def __init__(self, iter_no=None): weight_joint, weight_joint_group, weight_full = 1. / (3 * 17), 1. / ( 3 * 5), 1. / (3 * 1) self.weight_vec = np.array([1. / 51] * 17 + [1. / 15] * 5 + [1. / 3]) self.config = tf.ConfigProto() self.config.gpu_options.allow_growth = True self.session = tf.InteractiveSession(config=self.config) self.session.run(tf.global_variables_initializer()) if iter_no is not None: self.iter_no = iter_no print('Trying to load iter no:', self.iter_no) M.load_weights(self.iter_no, self.session, H.best_weights_path, H.best_weights_tag) else: self.iter_no = H.best_iter_no print('Trying to load iter no:', self.iter_no) M.load_weights(self.iter_no, self.session, H.best_weights_path, H.best_weights_tag)
def plot_autoencoder(weightsfile): print('building model') layers = model.build_model() batch_size = 128 print('compiling theano function') encoder_func = theano_funcs.create_encoder_func(layers) print('loading weights from %s' % (weightsfile)) model.load_weights([ layers['l_decoder_out'], layers['l_discriminator_out'], ], weightsfile) print('loading data') X_train, y_train, X_test, y_test = utils.load_mnist() train_datapoints = [] print('transforming training data') for train_idx in get_batch_idx(X_train.shape[0], batch_size): X_train_batch = X_train[train_idx] train_batch_codes = encoder_func(X_train_batch) train_datapoints.append(train_batch_codes) test_datapoints = [] print('transforming test data') for test_idx in get_batch_idx(X_test.shape[0], batch_size): X_test_batch = X_test[test_idx] test_batch_codes = encoder_func(X_test_batch) test_datapoints.append(test_batch_codes) Z_train = np.vstack(train_datapoints) Z_test = np.vstack(test_datapoints) plot(Z_train, y_train, Z_test, y_test, filename='adversarial_train_val.png', title='projected onto latent space of autoencoder')
def sample(epoch, num_chars): with open(os.path.join(DATA_DIR, 'char_to_idxi1522879818.json'), 'rb') as f: print(f) char_to_idx = json.load(f) idx_to_char = {i: ch for (ch, i) in char_to_idx.items()} vocab_size = len(char_to_idx) model = build_sample_model(vocab_size) load_weights(epoch, model) model.save( os.path.join(MODEL_DIR, 'model1522879818weights.{}.h5'.format(epoch))) li = " " treat = " " file = open(os.path.join(DATA_DIR, "result.csv"), "w") with open(os.path.join(DATA_DIR, args.seed), 'r') as myfile: for line in myfile: #li = line.rstrip() vals = line.split("#") li = vals[1] treat = vals[0] + "#" sampled = [char_to_idx[c] for c in treat] for c in treat[:-1]: batch = np.zeros((1, 1)) batch[0, 0] = char_to_idx[c] model.predict_on_batch(batch) for i in range(num_chars): batch = np.zeros((1, 1)) if sampled: batch[0, 0] = sampled[-1] else: batch[0, 0] = np.random.randint(vocab_size) result = model.predict_on_batch(batch).ravel() sample = np.random.choice(range(vocab_size), p=result) sampled.append(sample) #print(idx_to_char[c] for c in sampled) generated = ''.join(idx_to_char[c] for c in sampled) values = generated.split("#") print(generated, end='$') file.write(values[0] + ", " + values[1] + ", " + li + "\n")
def plot_autoencoder(weightsfile): print('building model') layers = model.build_model() batch_size = 128 print('compiling theano function') encoder_func = theano_funcs.create_encoder_func(layers) print('loading weights from %s' % (weightsfile)) model.load_weights([ layers['l_decoder_out'], layers['l_discriminator_out'], ], weightsfile) print('loading data') X_train, y_train, X_test, y_test = utils.load_mnist() train_datapoints = [] print('transforming training data') for train_idx in get_batch_idx(X_train.shape[0], batch_size): X_train_batch = X_train[train_idx] train_batch_codes = encoder_func(X_train_batch) train_datapoints.append(train_batch_codes) test_datapoints = [] print('transforming test data') for test_idx in get_batch_idx(X_test.shape[0], batch_size): X_test_batch = X_test[test_idx] test_batch_codes = encoder_func(X_test_batch) test_datapoints.append(test_batch_codes) Z_train = np.vstack(train_datapoints) Z_test = np.vstack(test_datapoints) plot(Z_train, y_train, Z_test, y_test, filename='adversarial_train_val.png', title='projected onto latent space of autoencoder')
def captcha_reco(): pic = flask.request.files('imagefile', '') x = prep_data.get_data(pic) model_arc = m.load_cnn.save_model_arc() cnn_model = keras.models.model_from_json(model_arc) directory = sys.path.append( os.path.join(os.path.dirname(__file__), '..', 'model')) cnn_model_final = load_weights(cnn_model, directory) result = cnn_model_final.predict({'input': x}) out = [ np.argmax(result['out'][0]), np.argmax(result['out'][1]), np.argmax(result['out'][2]), np.argmax(result['out'][3]), np.argmax(result['out'][4]) ] r = [prep_data.asc_chr(i) for i in out] result_json = json.dump(dict(r), ensure_ascii=False) return flask.Response(result_json, mimetype='application/json')
def loadModel(name): model = model_from_json(open('./model/'+ name +'_model.json').read()) model.load_weights('./model/best_validation_'+ name +'_model_weights.h5') return model
# Create a function that saves the model's weights cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath = model_name, save_weights_only=True, verbose=0, save_freq="epoch") # model.load_weights(model_name) model.fit(X_train, Y_train, batch_size = batch_size, epochs = epochs, validation_data= (X_valid,Y_valid), callbacks = [cp_callback]) # Step 6: Evaluation mae, mse = model.evaluate(X_valid, Y_valid, verbose = 2) print("Evaluation, MAE: {:2.4f}, MSE: {:2.4f}".format(mae, mse)) elif sys.argv[1] == "predict": # Step 3: Loads the weights model.load_weights(model_name) my_model = tf.keras.Sequential([model]) # Step 4: Get Normalization values stats = pd.read_csv("data/wine_stats.csv", sep = ',', header = 0) # Step 5: Prepare the input AND predict input = sys.argv[2].split(",") input = np.array([float(x) for x in input]) input = loader.normalize(input, stats).values print(input) preds = my_model.predict(np.array([input])) print(preds[0])
if distributional: if alpha > 0: modelbest = file0 + "Sen2LCZ_" + str(batch_size) + "_lr_" + str( lrate) + "_urban_d" + str(alpha) + "_weights_best.hdf5" else: modelbest = file0 + "Sen2LCZ_" + str(batch_size) + "_lr_" + str( lrate) + "_urban_d" + "_weights_best.hdf5" else: modelbest = file0 + "Sen2LCZ_" + str(batch_size) + "_lr_" + str( lrate) + "_urban" + "_weights_best.hdf5" else: modelbest = file0 + "Sen2LCZ_" + str(batch_size) + "_lr_" + str( lrate) + "_weights_best.hdf5" 'load saved best model' model.load_weights(modelbest, by_name=False) # 4. test phase y_pre = model.predict(x_tst, batch_size=batch_size) y_pre = y_pre.argmax(axis=-1) + 1 y_testV = y_tst.argmax(axis=-1) + 1 # Add training data as well #y_pre_trn = model.predict(x_trn, batch_size = batch_size) #y_pre_trn = y_pre_trn.argmax(axis=-1)+1 #y_trnV = y_trn.argmax(axis=-1)+1 #y_pre = np.hstack((y_pre, y_pre_trn)) #y_testV = np.hstack((y_testV, y_trnV)) labels = [
def main(): """main function Main function... (what do you expect me to say...) Args: - none Returns: - none """ # Main function for evaluate parser = argparse.ArgumentParser( description="A testing framework for semantic segmentation.") parser.add_argument( "--net", required=True, default="unet", type=str, help= "(str) The type of net work which is either unet, deeplab or custom.") parser.add_argument("--epochs", required=False, default=500, type=int) parser.add_argument("--batch_size", required=False, default=16, type=int) parser.add_argument("--gpu_id", required=False, default="0", type=str, help="(str) The id of the gpu used when training.") parser.add_argument("--img_size", required=False, default=192, type=int, help="(int) The size of input image") parser.add_argument( "--load_weights", required=False, default=False, type=bool, help="(bool) Use old weights or not (named net_imgSize.h5)") # Parse argument args = parser.parse_args() net_type = args.net epochs = args.epochs batch_size = args.batch_size gpu_number = args.gpu_id img_size = args.img_size import os os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" os.environ["CUDA_VISIBLE_DEVICES"] = gpu_number # Argument check if not (net_type in {"unet", "deeplab", "custom"}): raise ValueError("netType should be either unet, deeplab and custom.") # Get config Config = cfg.Config() # COCO instance print("Reading COCO ground truth...") cocoGt = COCO(Config.COCO_training_ann_path) cocoValGt = COCO(Config.COCO_validation_ann_path) print("Finished") # Get all classes classes = len(cocoGt.getCatIds()) id_to_index = dict() # There is a wired class of 0 in the feature map of type zero index_to_id = dict() # Because the id of COCO dataset starts from 92, we should project those id to index so that keras # utils can convert the segmentation map into one hot categorical encoding. for index, id in enumerate(cocoGt.getCatIds()): id_to_index[id] = index index_to_id[index] = id if net_type == "unet": model = basic_model.unet(input_size=(img_size, img_size, 3), classes=len(id_to_index)) elif net_type == "deeplab": deeplab_model = basic_model.Deeplabv3(input_shape=(img_size, img_size, 3), classes=len(id_to_index), backbone="xception") output = KL.Activation("softmax")(deeplab_model.output) model = KM.Model(deeplab_model.input, output) elif net_type == "custom": model = model.custom_model(input_shape=(img_size, img_size, 3), classes=len(id_to_index)) file_list = glob(Config.COCO_training_path + '*') val_list = glob(Config.COCO_validation_path + '*') if args.load_weights: try: model.load_weights(net_type + "_" + str(img_size) + ".h5") print("weights loaded!") except: print("weights not found!") checkpointer = KC.ModelCheckpoint(filepath=net_type + "_" + str(img_size) + ".h5", verbose=1, save_best_only=True) model.compile(optimizer=KO.Adam(), loss="categorical_crossentropy", metrics=["accuracy"]) model.fit_generator(data.generator(batch_size, file_list, (img_size, img_size), cocoGt, id_to_index, True), validation_data=data.generator(batch_size, val_list, (img_size, img_size), cocoValGt, id_to_index, False), validation_steps=10, steps_per_epoch=100, epochs=epochs, use_multiprocessing=True, workers=8, callbacks=[checkpointer]) print("Prediction start...") vfunc = np.vectorize(lambda index: index_to_id[index]) anns = [] # Convert into COCO annotation for i in trange(len(val_list)): image = val_list[i] image_id = int(image.replace(".jpg", '')[-12:]) cropping_image, padding_dims, original_size = utils.padding_and_cropping( image, (img_size, img_size)) cropping_image = preprocess_input(cropping_image, mode="torch") result = model.predict(cropping_image) result = np.argmax(result, axis=3) seg_result = utils.reverse_padding_and_cropping( result, padding_dims, original_size) seg_result = vfunc(seg_result) COCO_ann = cocostuffhelper.segmentationToCocoResult(seg_result, imgId=image_id) for ann in COCO_ann: ann["segmentation"]["counts"] = ann["segmentation"][ "counts"].decode("ascii") # json can't dump byte string anns += COCO_ann with open("result.json", "w") as file: json.dump(anns, file) # Read result file # Test for fake result #resFile = Config.fake_result # Evaluate result resFile = "result.json" cocoDt = cocoValGt.loadRes(resFile) cocoEval = COCOStuffeval(cocoValGt, cocoDt) cocoEval.evaluate() cocoEval.summarize()
import model model = model.create_model() # print(X_train) # print(y_train) callback = tf.keras.callbacks.ModelCheckpoint( 'Transformer+TimeEmbedding_avg.hdf5', monitor='val_loss', save_best_only=True, verbose=1) history = model.fit(X_train, y_train, batch_size=batch_size, epochs=10, callbacks=[callback], validation_data=(X_val, y_val)) model.load_weights('Transformer+TimeEmbedding_avg.hdf5') y = model.predict(X_test) fig = plt.figure() import datetime test_tick = test_tick.apply( lambda x: datetime.datetime.strptime(x, '%Y-%m-%d')) true_y = y * (max_return - min_return) + min_return true_ytest = y_test * (max_return - min_return) + min_return df = pd.read_csv('./input/index.csv', delimiter=',', usecols=['Date', 'Open', 'High', 'Low', 'Close', 'Volume']) real_close = df[(df.index >= last_10pct)]['Close'][49:-1].values pre_close = [] for i in range(len(real_close)):
print('RE FPR, TPR: (%.3f, %.3f)' % (fpr_re[idx3RE], tpr_re[idx3RE])) print('RE FPR, TPR: (%.3f, %.3f)' % (fpr_re[idx4RE], tpr_re[idx4RE])) print('DeepIso AUC: %.5f' % metrics.auc(fpr_nn, tpr_nn)) print('DeepIso AUC (training set): %.5f' % metrics.auc(fpr_nn_train, tpr_nn_train)) print('RelIso AUC: %.5f' % metrics.auc(fpr_re, tpr_re)) print('Now making convergence plot') auc_test = numpy.zeros(nEpochs) auc_train = numpy.zeros(nEpochs) x = numpy.linspace(1, nEpochs, nEpochs) for i in range(nEpochs): print(i) model.load_weights("weights/" + savename + "_weights_" + str(i + 1).zfill(2) + ".hdf5") prediction = model.predict([ charged_pf_features[nTrain:], photon_pf_features[nTrain:], neutralHad_pf_features[nTrain:], global_features[nTrain:] ], batch_size=nBatch) prediction_training_set = model.predict([ charged_pf_features[:nTrain], photon_pf_features[:nTrain], neutralHad_pf_features[:nTrain], global_features[:nTrain] ], batch_size=nBatch) #plt.figure() #plt.hist(prediction[(label[nTrain:]).astype(bool)], bins = 100, label = 'Signal', color = 'red') #plt.hist(prediction[numpy.logical_not(label[nTrain:])], bins = 100, label = 'Background', color = 'blue') #plt.legend(loc = 'upper left')
_, frame = vc.read() img = frame face_image = lib.align_image(img) if face_image is not None: #face_image = frame[max(0, y1):min(height, y2), max(0, x1):min(width, x2)] identity = recognize_face(face_image, input_embeddings, model) if identity is not None: #img = cv2.rectangle(frame,(x1, y1),(x2, y2),(255,255,255),2) #cv2.putText(img, str(identity), (4,30), font, 1, (255,255,255), 2) print(str(identity)) else: print("Não reconhecido") key = cv2.waitKey(100) #cv2.imshow("Face Recognizer", img) if key == 27: # exit on ESC break else: print("Nenhuma face detectada!") vc.release() cv2.destroyAllWindows() model = create_model() model.load_weights('nn4.small2.v1.h5') input_embeddings = create_input_image_embeddings(model) recognize_faces_in_cam(input_embeddings, model)
model = model.model() los = 99999 t = [] for (dirpath, dirnames, filenames) in walk(train_path): t.extend(filenames) v = [] for (dirpath, dirnames, filenames) in walk(valid_path): v.extend(filenames) t_files = len(t) v_files = len(v) try: model.load_weights("weights.h5", by_name=True) print("Loading Exiting weights........ please wait") except: 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,
X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1) X_val = X_val.reshape(X_val.shape[0], img_rows, img_cols, 1) X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1) input_shape = (img_rows, img_cols, 1) print('X_train shape:', X_train.shape) # np_utils.to_categorical将整型标签转为onehot。 # 在这里将向量转成了矩阵 Y_train = np_utils.to_categorical(y_train, 40) Y_val = np_utils.to_categorical(y_val, 40) Y_test = np_utils.to_categorical(y_test, 40) model = model.cnn_model() # 训练模型 train.train_model(model, X_train, Y_train, X_val, Y_val, epochs) # 测试模型 score = test.test_model(model, X_test, Y_test) print(score) # 加载训练好的模型 model.load_weights('model_weights.h5') # 计算预测的类别 classes = model.predict_classes(X_test, verbose=0) # 计算正确率 test_accuracy = np.mean(np.equal(y_test, classes)) print("last accuarcy:", test_accuracy) error_num = 0 for i in range(0, 40): if y_test[i] != classes[i]: error_num += 1 print(y_test[i], '被错误分成', classes[i]) print("共有" + str(error_num) + "张图片被识别错了")
def main(): """main function Main function... (what do you expect me to say...) Args: - none Returns: - none """ # Main function for evaluate parser = argparse.ArgumentParser(description="Evaluate the model") parser.add_argument( "--net", help= "The type of net work which is either mrcnn, unet, deeplab or custom.", required=True, default="unet") parser.add_argument("--img_size", required=True, type=int, help="The size of input image") parser.add_argument("--gpu_id", required=False, default="0", type=str, help="The id of the gpu used when training.") parser.add_argument( "--weight_path", required - False, defalut=None, type=str, help= "The name of trained weights. If not specified, the model will use 'net_imgSize.h5'. " ) # Parse argument args = parser.parse_args() net_type = args.net gpu_number = args.gpu_id img_size = args.img_size weight_path = args.weight_path import os os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" os.environ["CUDA_VISIBLE_DEVICES"] = gpu_number # Argument check if not (net_type in {"unet", "deeplab", "custom", "mrcnn"}): raise ValueError( "netType should be either unet, deeplab, mrcnn and custom.") if net_type in {"unet", "deeplab", "custom"}: # Get config Config = cfg.Config() # COCO instance print("Reading COCO ground truth...") cocoGt = COCO(Config.COCO_training_ann_path) cocoValGt = COCO(Config.COCO_validation_ann_path) print("Finished") # Get all classes classes = len(cocoGt.getCatIds()) id_to_index = dict() # There is a wired class of 0 in the feature map of type zero index_to_id = dict() # Because the id of COCO dataset starts from 92, we should project those id to index so that keras # utils can convert the segmentation map into one hot categorical encoding. for index, id in enumerate(cocoGt.getCatIds()): id_to_index[id] = index index_to_id[index] = id if net_type == "unet": model = basic_model.unet(input_size=(img_size, img_size, 3), classes=len(id_to_index)) elif net_type == "deeplab": deeplab_model = basic_model.Deeplabv3(input_shape=(img_size, img_size, 3), classes=len(id_to_index), backbone="xception") output = KL.Activation("softmax")(deeplab_model.output) model = KM.Model(deeplab_model.input, output) elif net_type == "custom": model = model.custom_model(input_shape=(img_size, img_size, 3), classes=len(id_to_index)) if net_type in {"unet", "deeplab", "custom"}: file_list = glob(Config.COCO_training_path + '*') val_list = glob(Config.COCO_validation_path + '*') if weight_path in None: model.load_weights(net_type + "_" + str(img_size) + ".h5") print("weights loaded!") else: model.load_weights(weight_path) print("weights loaded!") #model.compile(optimizer = KO.Adam(clipvalue=2.), loss="categorical_crossentropy", metrics=["accuracy"]) model.compile(optimizer=KO.Adam(), loss="categorical_crossentropy", metrics=["accuracy"]) print("Prediction start...") vfunc = np.vectorize(lambda index: index_to_id[index]) anns = [] # Convert into COCO annotation for i in trange(len(val_list)): image = val_list[i] image_id = int(image.replace(".jpg", '')[-12:]) cropping_image, padding_dims, original_size = utils.padding_and_cropping( image, (img_size, img_size)) cropping_image = preprocess_input(cropping_image, mode="torch") result = model.predict(cropping_image) result = np.argmax(result, axis=3) seg_result = utils.reverse_padding_and_cropping( result, padding_dims, original_size) seg_result = vfunc(seg_result) COCO_ann = cocostuffhelper.segmentationToCocoResult(seg_result, imgId=image_id) for ann in COCO_ann: ann["segmentation"]["counts"] = ann["segmentation"][ "counts"].decode("ascii") # json can't dump byte string anns += COCO_ann with open("result.json", "w") as file: json.dump(anns, file) # Evaluate result resFile = "result.json" cocoDt = cocoValGt.loadRes(resFile) cocoEval = COCOStuffeval(cocoValGt, cocoDt) cocoEval.evaluate() cocoEval.summarize()
if args.command == "train": model = model.MaskRCNN(config=config, model_dir=args.logs, test_flag=False) else: model = model.MaskRCNN(config=config, model_dir=args.logs, test_flag=True) if config.GPU_COUNT: model = model.cuda() if args.weights.lower() != "none": # Select weights file to load weights_path = args.weights # Load weights print("Loading weights ", weights_path) model.load_weights(weights_path) # Train or evaluate if args.command == "train": print("Training...") train(model) elif args.command == "test": print("Testing...") test(model, int(args.limit.lower()), args.save.lower(), args.bbox.lower()) else: print("'{}' is not recognized. " "Use 'train' or 'test'".format(args.command))
tf.keras.backend.set_session(sess) # モデルを作成 model = model.make(tflite=False) # 最適化を定義 optimizer = tf.keras.optimizers.Adam(lr=0.001) model.compile(optimizer=optimizer, loss="categorical_crossentropy", metrics=["categorical_accuracy"]) # コールバック class Callback(tf.keras.callbacks.Callback): def on_epoch_end(self, epoch, logs=None): "各エポック終了時に重みを保存する" model.save("weight.hdf5") cb = Callback() # 途中から学習する場合 initial_epoch = 0 if initial_epoch >= 1: model.load_weights("weight.hdf5") # 学習する model.fit_generator(g.generator(), validation_data=g.generator_test(), validation_steps=g.test_steps(), callbacks=[cb], steps_per_epoch=data.TRAIN_SIZE / data.BATCH_SIZE, epochs=50, initial_epoch=initial_epoch)
def full_model(pretrained_weights=None, input_size=(256, 256, 1)): inputs = tf.keras.Input(input_size) conv1 = tf.keras.layers.Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')( inputs) # 256 conv1 = tf.keras.layers.Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv1) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool1) # 128 conv2 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv2) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool2) # 64 conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv3) pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool3) # 32 conv4 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv4) drop4 = Dropout(0.5)(conv4) pool4 = MaxPooling2D(pool_size=(2, 2))(drop4) conv5 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool4) # 16 conv5 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv5) drop5 = Dropout(0.5)(conv5) up6 = Conv2D(512, 2, activation='relu', padding='same', kernel_initializer='he_normal')(UpSampling2D(size=(2, 2))(drop5)) merge6 = concatenate([drop4, up6], axis=3) conv6 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge6) conv6 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv6) up7 = Conv2D(256, 2, activation='relu', padding='same', kernel_initializer='he_normal')(UpSampling2D(size=(2, 2))(conv6)) merge7 = concatenate([conv3, up7], axis=3) conv7 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge7) conv7 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv7) up8 = Conv2D(128, 2, activation='relu', padding='same', kernel_initializer='he_normal')(UpSampling2D(size=(2, 2))(conv7)) merge8 = concatenate([conv2, up8], axis=3) conv8 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge8) conv8 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv8) up9 = Conv2D(64, 2, activation='relu', padding='same', kernel_initializer='he_normal')(UpSampling2D(size=(2, 2))(conv8)) merge9 = concatenate([conv1, up9], axis=3) conv9 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge9) conv9 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv9) conv9 = Conv2D(2, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv9) # conv10 = Conv2D(1, 1, activation = 'relu')(conv9) # conv10 = Conv2D(1, 1, activation = 'sigmoid')(conv10) conv10 = Conv2D(1, 1, activation='sigmoid')(conv9) model = tf.keras.models.Model(inputs=inputs, outputs=conv10) model.compile(optimizer=tf.keras.optimizers.Adam(lr=1e-4), loss="mean_absolute_error", metrics=['accuracy'], run_eagerly=True) model.summary() if (pretrained_weights): model.load_weights(pretrained_weights) return model
# load nlp model # nlp_model = NLPModel() out_idx = nlp_model.load_output_term_index() print(repr(out_idx)) dictionary, max_len = nlp_model.load_input_dict() print repr(dictionary) model = nlp_model.create_keras_model() model.load_weights(KERAS_WEIGHTS_FN) # # main # db = LogicDB(session) engine = PrologEngine(db) prolog_builtins.register_builtins(engine) parser = PrologParser() while True: line = raw_input('nlp> ')
import glob import six.moves.cPickle from keras.models import model_from_json import model tokeniser = six.moves.cPickle.load(open("tokeniser.pkl", 'rb')) lastModel = sorted(glob.glob('model-*.h5'))[-1] model = model_from_json(open("model.json").read()) model.load_weights(lastModel) dictionarySize = int(open('model-dictionary-size.dat').read()) print(model.query(model, tokeniser, dictionarySize, "It is bad")) print(model.query(model, tokeniser, dictionarySize, "It is good"))