def main(): searchPath = "Testdata/*.png" #Please use same patchsize for all images. patchSize = a.scale_size inputs = tf.placeholder(tf.float32, [1, patchSize, patchSize, 3]) with tf.variable_scope("generator") as scope: out_channels = 3 outputs = create_generator(inputs, out_channels) saver = tf.train.Saver() saver.restore(sess, "artificialKi67/compact.ckpt") files = glob.glob(searchPath) print(files) for myfile in files: print(myfile) analyze(myfile, outputs, inputs, patchSize)
def training(epochs=1, batch_size=128): """This function fits a gan model. Parameters ---------- epochs : int, optional Number of epochs (1 by default). batch_size : int, optional Number of steps by epoch (128 by default). Returns ------- """ x_train = numpy.load('../data/train_data.npy') generator = models.create_generator() discriminator = models.create_discriminator() gan = models.create_gan(discriminator, generator) for e in range(1, epochs + 1): for _ in tqdm(range(batch_size), desc="Epoch {}".format(e)): noise = numpy.random.normal(0, 1, [batch_size, 100]) generated_images = generator.predict(noise) image_batch = x_train[numpy.random.randint(low=0, high=x_train.shape[0], size=batch_size)] # x = numpy.concatenate([image_batch, generated_images]) # # y_dis = numpy.zeros(2 * batch_size) # y_dis[:batch_size] = 0.9 # # discriminator.trainable = True # discriminator.train_on_batch(x, y_dis) # # noise = numpy.random.normal(0, 1, [batch_size, 100]) # y_gen = numpy.ones(batch_size) # # discriminator.trainable = False # # gan.train_on_batch(noise, y_gen) if e == 1 or e % 20 == 0: helpers.plot_generated_images(e, generator)
def _subprocess(gpu_queue, args, models_dir, model_name, cv_index, cv_size, split_seed, tta_index): """子プロセスの予測処理。""" if 'CUDA_VISIBLE_DEVICES' not in os.environ: # GPUの固定 gpu_id = gpu_queue.get() os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu_id) # TensorFlowのログ抑止 os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # モデルの読み込み import models _subprocess_context['model'] = models.load(models_dir / model_name) else: import models result_path = pathlib.Path(models_dir / _CACHE_NAME_FORMAT.format( target=args.target, model=model_name, tta=tta_index)) if result_path.is_file(): print('スキップ: {}'.format(result_path)) return else: seed = 1234 + tta_index np.random.seed(seed) assert args.target in ('val', 'test') if args.target == 'val': _, (X_target, _), _ = data.load_data(cv_index, cv_size, split_seed) else: _, _, X_target = data.load_data(cv_index, cv_size, split_seed) pattern_index = len(_SIZE_PATTERNS) * tta_index // args.tta_size img_size = _SIZE_PATTERNS[pattern_index] batch_size = int(_BATCH_SIZE * ((_BASE_SIZE**2) / (img_size[0] * img_size[1]))**1.5) gen = models.create_generator(img_size, mixup=False) proba_target = _subprocess_context['model'].predict_generator( gen.flow(X_target, batch_size=batch_size, data_augmentation=True, shuffle=False, random_state=seed), steps=gen.steps_per_epoch(len(X_target), batch_size), verbose=0) result_path.parent.mkdir(parents=True, exist_ok=True) joblib.dump(proba_target, result_path)
def __init__(self, predict, loss_fn, args, logger=None): super(NoBoxAttack, self).__init__(predict, loss_fn, args.clip_min, args.clip_max) self.args = args flow_args = [args.n_blocks, args.flow_hidden_size, args.flow_hidden, args.flow_model, args.flow_layer_type] self.G = create_generator(args, args.model, args.deterministic_G, args.dataset, flow_args) self.pick_prob_start = None self.robust_train_flag = False if args.train_with_robust: if args.ensemble_adv_trained: if args.dataset=="mnist": adv_model_names = args.adv_models type = get_model_type(adv_model_names[0]) self.robust_critic = load_model(args, adv_model_names[0], type=type).to(args.dev) elif args.dataset =='cifar': adv_model_names = args.adv_models l_test_classif_paths = [] adv_path = os.path.join(args.dir_test_models, "pretrained_classifiers", args.dataset, "ensemble_adv_trained", adv_model_names + '.pt') init_func, _ = ARCHITECTURES[adv_model_names[i]] temp_model = init_func().to(args.dev) self.robust_critic = nn.DataParallel(temp_model) self.robust_critic.load_state_dict(torch.load(adv_path)) else: self.robust_critic = Net(1, 28, 28).to(args.dev) self.robust_critic.load_state_dict(torch.load(args.robust_model_path)) self.robust_train_flag = True self.pick_prob_start = args.robust_sample_prob self.pick_rob_prob = Bernoulli(torch.tensor([1-args.robust_sample_prob])) self.anneal_rate = (1.0 - args.robust_sample_prob) / args.attack_epochs self.logger = logger
def training(epochs, batch_size): X_train = load_data() batch_count = int(X_train.shape[0] / batch_size) generator= create_generator(learning_rate,beta_1,encoding_dims) discriminator= create_discriminator(learning_rate,beta_1) gan = create_gan(discriminator, generator,encoding_dims) valid = np.ones((batch_size, 1)) fake = np.zeros((batch_size, 1)) seed = np.random.normal(0,1, [25, encoding_dims]) for e in range(1,epochs+1 ): print("Epoch %d" %e) for _ in range(batch_count): noise= np.random.normal(0,1, [batch_size, encoding_dims]) generated_images = generator.predict(noise) image_batch = X_train[np.random.randint(low=0,high=X_train.shape[0],size=batch_size)] discriminator.trainable=True d_loss_real = discriminator.train_on_batch(image_batch, valid) d_loss_fake = discriminator.train_on_batch(generated_images, fake) d_loss = 0.5 * np.add(d_loss_real, d_loss_fake) noise= np.random.normal(0,1, [batch_size, encoding_dims]) discriminator.trainable=False g_loss = gan.train_on_batch(noise,valid) print ("%d [D loss: %f] [G loss: %f]" % (e, d_loss, g_loss)) if ipython: display.clear_output(wait=True) plot_generated_images(e, generator,seed,outdir) generator.save('{}/gan_model'.format(outdir))
def _run(): import keras import models logger = tk.log.get(__name__) parser = argparse.ArgumentParser() parser.add_argument('--epochs', help='epoch数。', default=300, type=int) parser.add_argument('--batch-size', help='バッチサイズ。', default=16, type=int) parser.add_argument('--warm', help='models/model.fold{cv_index}.h5を読み込む', action='store_true', default=False) parser.add_argument('--cv-index', help='CVの何番目か。', type=int) parser.add_argument('--cv-size', help='CVの分割数。', default=5, type=int) parser.add_argument('--split-seed', help='分割のシード値。', default=123, type=int) args = parser.parse_args() assert args.cv_index in range(args.cv_size) model_path = _MODELS_DIR / 'model.fold{}.h5'.format(args.cv_index) (X_train, y_train), (X_val, y_val), _ = data.load_data(args.cv_index, args.cv_size, args.split_seed) num_classes = len(np.unique(y_train)) y_train = tk.ml.to_categorical(num_classes)(y_train) y_val = tk.ml.to_categorical(num_classes)(y_val) logger.info('len(X_train) = {} len(X_val) = {}'.format( len(X_train), len(X_val))) model = models.create_network(num_classes) # 学習率: # ・lr 0.5、batch size 256くらいが多いのでその辺を基準に # ・バッチサイズに比例させるのが良いとのうわさ lr = 0.5 * args.batch_size / 256 * hvd.size() opt = keras.optimizers.SGD(lr=lr, momentum=0.9, nesterov=True) opt = hvd.DistributedOptimizer(opt) model.compile(opt, 'categorical_crossentropy', ['acc']) if hvd.rank() == 0 and args.cv_index == 0: model.summary(print_fn=logger.info) logger.info('network depth: %d', tk.dl.count_network_depth(model)) if args.warm: model.load_weights(str(model_path)) logger.info('{} loaded'.format(model_path)) else: assert not model_path.exists() # 誤操作対策 callbacks = [] if args.warm and args.epochs < 300: # 短縮モード callbacks.append(tk.dl.learning_rate_callback((0, 0.5))) else: callbacks.append(tk.dl.learning_rate_callback()) callbacks.append(hvd.callbacks.BroadcastGlobalVariablesCallback(0)) callbacks.append(hvd.callbacks.MetricAverageCallback()) callbacks.append( hvd.callbacks.LearningRateWarmupCallback(warmup_epochs=5, verbose=1)) if hvd.rank() == 0: callbacks.append(tk.dl.tsv_log_callback(_MODELS_DIR / 'history.tsv')) callbacks.append(tk.dl.freeze_bn_callback(0.95)) gen = models.create_generator((299, 299), mixup=True) model.fit_generator( gen.flow(X_train, y_train, batch_size=args.batch_size, data_augmentation=True, shuffle=True), steps_per_epoch=gen.steps_per_epoch(len(X_train), args.batch_size) // hvd.size(), epochs=args.epochs, verbose=1 if hvd.rank() == 0 else 0, validation_data=gen.flow(X_val, y_val, batch_size=args.batch_size, shuffle=True), validation_steps=gen.steps_per_epoch(len(X_val), args.batch_size) // hvd.size(), # * 3は省略 callbacks=callbacks) if hvd.rank() == 0: model.save(str(model_path)) proba_val = model.predict_generator( gen.flow(X_val, y_val, batch_size=args.batch_size), gen.steps_per_epoch(len(X_val), args.batch_size), verbose=1) joblib.dump(proba_val, _MODELS_DIR / 'proba_val.fold{}.pkl'.format(args.cv_index)) pred_val = proba_val.argmax(axis=-1) logger.info('val_acc: {:.1f}%'.format( sklearn.metrics.accuracy_score(y_val.argmax(axis=-1), pred_val) * 100))