def transfer_classifier_params(args): pytorch_model = TorchClassifier() with open(args.torch_classifier_model_path, 'rb') as f: weights = dill.load(f) state_dict = {k: torch.FloatTensor(v) for k, v in weights[0].items()} pytorch_model.load_state_dict(state_dict) for k in state_dict.keys(): print('key: ', k) chainer_model = Classifier() copy_conv_weight(pytorch_model.LeNet[0], chainer_model.conv1) copy_conv_weight(pytorch_model.LeNet[2], chainer_model.conv2) copy_batch_norm_weight(pytorch_model.LeNet[3], chainer_model.batch_norm1) copy_conv_weight(pytorch_model.LeNet[5], chainer_model.conv3) copy_batch_norm_weight(pytorch_model.LeNet[6], chainer_model.batch_norm2) copy_conv_weight(pytorch_model.LeNet[8], chainer_model.conv4) copy_batch_norm_weight(pytorch_model.LeNet[9], chainer_model.batch_norm3) copy_conv_weight(pytorch_model.LeNet[11], chainer_model.conv5) if args.sample_image: subtractor = Subtractor() load_model(args.chainer_subtractor_model_path, subtractor) image1 = convert_to_grayscale(subtractor, args.sample_image).data image2 = np.zeros(shape=image1.shape, dtype=np.float32) print('image1 shape: ', image1.shape) print('image2 shape: ', image2.shape) classify_image_with_pytorch_model(pytorch_model, torch.Tensor(image1), torch.Tensor(image2)) classify_image_with_chainer_model(chainer_model, chainer.Variable(image1), chainer.Variable(image2)) save_model(args.chainer_classifier_save_path, chainer_model)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=0) parser.add_argument('--lstm', action='store_true', help='evaluate lstm network') parser.add_argument('--unroll-steps', type=int, default=20) parser.add_argument('--init-steps', type=int, default=11) parser.add_argument('--mean-image-file', type=str, default='') parser.add_argument('--model-dir', type=str, default='') parser.add_argument('--dataset-dir', type=str, default='') parser.add_argument('--skip-frames', type=int, default=4) parser.add_argument('--batch-size', type=int, default=32) parser.add_argument('--k-step', type=int, default=1) parser.add_argument('--iteration-num', type=int, default=1000000) parser.add_argument('--dataset-num', type=int, default=1) parser.add_argument('--output-file', type=str, default='evaluation_results') args = parser.parse_args() chainer.backends.cuda.set_max_workspace_size(10000000000) chainer.config.autotune = True dataset_files = [ join_path(args.dataset_dir, 'test{}.pickle'.format(index)) for index in range(args.dataset_num) ] dataset = ds.prepare_dataset(dataset_files) mean_image = ds.load_mean_image(args.mean_image_file) iterator = prepare_iterator(dataset, mean_image, args) losses = [] if args.lstm: model = LstmPredictionNetwork() else: model = FeedForwardPredictionNetwork() if not args.gpu < 0: model.to_gpu() with open(args.output_file, "w") as f: f.write('iteration\tloss\n') for iteration in range(830000, args.iteration_num + 1, 10000): model_file = join_path(args.model_dir, 'model_iter-{}'.format(iteration)) print('loading model: {}'.format(model_file)) if files.file_exists(model_file): serializers.load_model(model_file, model) loss = evaluate_model(model, iterator, args) losses.append(dict(iteration=iteration, loss=loss)) f.write('{}\t{}\n'.format(iteration, loss.data)) else: print('Model {} not found. skipping evaluation.'.format( model_file)) print('losses: {}'.format(losses))
def load_params(naf, args): print('loading model params') naf._q.to_cpu() if args.q_params: if not files.file_exists(args.q_params): raise ValueError('Not trained parameter specified!!') serializers.load_model(args.q_params, naf._q) if not args.gpu < 0: naf._q.to_gpu()
def prepare_model(args, num_actions): env_type = args.env_type if env_type == 'mujoco': model = PPOMujocoModel(num_actions) elif env_type == 'atari': model = PPOAtariModel(num_actions, args.atari_model_size) else: NotImplementedError("Unknown ent_type: ", env_type) serializers.load_model(args.model_params, model) return model
def main(): parser = argparse.ArgumentParser() parser.add_argument('--model-file', type=str, default='') parser.add_argument('--mean-image-file', type=str, default='mean_image.pickle') parser.add_argument('--dataset-file', type=str, default='100000.pickle') parser.add_argument('--gpu', type=int, default=0) parser.add_argument('--skip-frames', type=int, default=4) parser.add_argument('--initial-frame', type=int, default=0) parser.add_argument('--last-frame', type=int, default=10000) parser.add_argument('--init-steps', type=int, default=11) parser.add_argument('--show-dataset', action='store_true') parser.add_argument('--show-prediction', action='store_true') parser.add_argument('--show-mean-image', action='store_true') parser.add_argument('--show-sample-frame', action='store_true') parser.add_argument('--lstm', action='store_true') args = parser.parse_args() if args.show_dataset: dataset = load_dataset([args.dataset_file]) animate_dataset(dataset, args) if args.show_prediction: dataset = load_dataset([args.dataset_file]) if args.lstm: model = LstmPredictionNetwork() else: model = FeedForwardPredictionNetwork() serializers.load_model(args.model_file, model) if not args.gpu < 0: model.to_gpu() mean_image = ds.load_mean_image(args.mean_image_file) animate_predictions(model, dataset, mean_image, args) if args.show_mean_image: mean_image = ds.load_mean_image(args.mean_image_file) viewer.show_image(converter.chw2hwc(mean_image), title='mean image') if args.show_sample_frame: dataset = load_dataset([args.dataset_file]) frame = dataset['frames'][args.initial_frame] viewer.show_image(converter.chw2hwc(frame), title='frame')
def load_params(td3, args): print('loading model params') td3._q1.to_cpu() td3._q2.to_cpu() td3._pi.to_cpu() serializers.load_model(args.q1_params, td3._q1) serializers.load_model(args.q2_params, td3._q2) serializers.load_model(args.pi_params, td3._pi) if not args.gpu < 0: td3._q1.to_gpu() td3._q2.to_gpu() td3._pi.to_gpu()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--dataset-dir', type=str, default='dataset') parser.add_argument('--mean-image-file', type=str, default='mean_image.pickle') parser.add_argument('--token', type=str, default=None, help='Slack client token') parser.add_argument('--max-iterations', type=int, default=1500000) parser.add_argument('--test-interval', type=int, default=10000) parser.add_argument('--color-channels', type=int, default=3) parser.add_argument('--skip-frames', type=int, default=4) parser.add_argument('--batch-size', type=int, default=32) parser.add_argument('--k-step', type=int, default=1) parser.add_argument('--num-actions', type=int, default=3) parser.add_argument('--gpu', type=int, default=0) parser.add_argument('--unroll-steps', type=int, default=20) parser.add_argument('--init-steps', type=int, default=11) parser.add_argument('--train-file-num', type=int, default=10) parser.add_argument('--test-file-num', type=int, default=1) parser.add_argument('--verify-batch', action='store_true', help='show created batch') parser.add_argument('--lstm', action='store_true', help='train lstm network') parser.add_argument('--learning-rate', type=float, default=1e-4) parser.add_argument('--model-file', type=str, default='') parser.add_argument('--snapshot-file', type=str, default='') args = parser.parse_args() print('loading mean image') mean_image = ds.load_mean_image( join_path(args.dataset_dir, args.mean_image_file)) assert mean_image.shape == (args.color_channels, IMAGE_HEIGHT, IMAGE_WIDTH) if args.lstm: model = LstmPredictionNetwork() else: model = FeedForwardPredictionNetwork() if files.file_exists(args.model_file): print('loading model from: {}'.format(args.model_file)) serializers.load_model(args.model_file, model) if not args.gpu < 0: model.to_gpu() train_data_files = [ join_path(args.dataset_dir, 'train{}.pickle'.format(index)) for index in range(args.train_file_num) ] test_data_files = [ join_path(args.dataset_dir, 'test{}.pickle'.format(index)) for index in range(args.test_file_num) ] train_iterator, test_iterator = prepare_iterator(train_data_files, test_data_files, mean_image, args) try: train_model(model, train_iterator, test_iterator, args=args) except: print('training finished with exception...')
def prepare_subtractor(args): subtractor = Subtractor() serializers.load_model(args.subtractor_model, subtractor) return subtractor
def prepare_classifier(args): classifier = Classifier() assert files.file_exists(args.classifier_parameter) serializers.load_model(args.classifier_parameter, classifier) return classifier
def prepare_subtractor(args): subtractor = Subtractor() assert files.file_exists(args.subtractor_parameter) serializers.load_model(args.subtractor_parameter, subtractor) return subtractor
def prepare_transition(args): transition = Transition() assert files.file_exists(args.transition_parameter) serializers.load_model(args.transition_parameter, transition) return transition
def prepare_posterior(args): posterior = Posterior() assert files.file_exists(args.posterior_parameter) serializers.load_model(args.posterior_parameter, posterior) return posterior
def prepare_generator(args): generator = Generator() assert files.file_exists(args.generator_parameter) serializers.load_model(args.generator_parameter, generator) return generator
def load_optimizer(filepath, optimizer): serializers.load_model(filepath, optimizer)