def test_split_dataset_random(self): original = [1, 2, 3, 4, 5] subset1, subset2 = datasets.split_dataset_random(original, 2) reconst = sorted(set(subset1).union(subset2)) self.assertEqual(reconst, original) subset1a, subset2a = datasets.split_dataset_random(original, 2, seed=3) reconst = sorted(set(subset1a).union(subset2a)) self.assertEqual(reconst, original) subset1b, subset2b = datasets.split_dataset_random(original, 2, seed=3) self.assertEqual(set(subset1a), set(subset1b)) self.assertEqual(set(subset2a), set(subset2b)) reconst = sorted(set(subset1a).union(subset2a)) self.assertEqual(reconst, original)
# xに設計変数を格納 x = input_data.loc[:, ["Column_num","Color_white","Color_black", "Icon_A", "Icon_B", "Icon_C", "Layout_thin", "Layout_thick", "Layout_ratio", "Menu_rectangle", "Menu_float", "Menu_convex", "Shape_corner", "Shape_round", "Shape_chamfer", "Header_none", "Header_half", "Header_full", "Char_none", "Char_half", "Char_full"]] #df.loc[:, ['col_1','col_2']]で烈ラベル指定 # tに15点満点のアンケート結果(Total)を格納 t = input_data.loc[:,["Total"]] #Chainerがデフォルトで用いるfloat32型に変換 x = np.array(x,np.float32) t = np.array(t,np.float32) # 分類型のときはint, 回帰型のときはfloat # TupleDatasetを使ってxとtをセットにする from chainer.datasets import TupleDataset dataset = TupleDataset(x,t) # datasetを任意の割合でtrain(学習用データ)とvalid(検証用データ)に分割する from chainer.datasets import split_dataset_random train, valid = split_dataset_random(dataset, int(len(dataset) * 0.8), seed=0) # 抽出するデータは固定 # 用意したデータをどう抽出し,どうグループ(バッチ)わけするか設定する from chainer import iterators batchsize = 128 train_iter = iterators.SerialIterator(train, batchsize, shuffle=True, repeat=True) valid_iter = iterators.SerialIterator(valid, batchsize, shuffle=True, repeat=True) # 何周も何周も全データを繰り返し読み出す必要がある場合はrepeat引数をTrue # 1周が終わったらそれ以上データを取り出したくない場合はこれをFalse # デフォルトではTrueなので本当は書かなくてもいい # ------------------------------------------------------------------------------ # ネットワークの定義と最適化手法の選択 import chainer.links as L import chainer.functions as F # ネットワークの定義
def test_split_dataset_random(self): original = [1, 2, 3, 4, 5] subset1, subset2 = datasets.split_dataset_random(original, 2) reconst = sorted(set(subset1).union(subset2)) self.assertEqual(reconst, original)
def main(): # Parse the arguments. args = parse_arguments() # Set up some useful variables that will be used later on. method = args.method if args.label != 'all': labels = args.label cache_dir = os.path.join('input', '{}_{}'.format(method, labels)) class_num = len(labels) if isinstance(labels, list) else 1 else: labels = None cache_dir = os.path.join('input', '{}_all'.format(method)) class_num = len(D.get_qm9_label_names()) # Get the filename corresponding to the cached dataset, based on the amount # of data samples that need to be parsed from the original dataset. num_data = args.num_data if num_data >= 0: dataset_filename = 'data_{}.npz'.format(num_data) else: dataset_filename = 'data.npz' # Load the cached dataset. dataset_cache_path = os.path.join(cache_dir, dataset_filename) dataset = None if os.path.exists(dataset_cache_path): print('Loading cached dataset from {}.'.format(dataset_cache_path)) dataset = NumpyTupleDataset.load(dataset_cache_path) if dataset is None: print('Preprocessing dataset...') preprocessor = preprocess_method_dict[method]() if num_data >= 0: # Select the first `num_data` samples from the dataset. target_index = numpy.arange(num_data) dataset = D.get_qm9(preprocessor, labels=labels, target_index=target_index) else: # Load the entire dataset. dataset = D.get_qm9(preprocessor, labels=labels) # Cache the laded dataset. if not os.path.exists(cache_dir): os.makedirs(cache_dir) if isinstance(dataset, NumpyTupleDataset): NumpyTupleDataset.save(dataset_cache_path, dataset) # Scale the label values, if necessary. if args.scale == 'standardize': print('Fit StandardScaler to the labels.') scaler = StandardScaler() if isinstance(dataset, NumpyTupleDataset): scaler.fit(dataset.get_datasets()[-1]) else: y = numpy.array([data.y for data in dataset]) scaler.fit(y) else: print('No standard scaling was selected.') scaler = None # Split the dataset into training and validation. train_data_size = int(len(dataset) * args.train_data_ratio) train, valid = split_dataset_random(dataset, train_data_size, args.seed) # Set up the predictor. predictor = set_up_predictor(method, args.unit_num, args.conv_layers, class_num, scaler) # Set up the regressor. device = chainer.get_device(args.device) metrics_fun = {'mae': F.mean_absolute_error, 'rmse': rmse} regressor = Regressor(predictor, lossfun=F.mean_squared_error, metrics_fun=metrics_fun, device=device) print('Training...') run_train(regressor, train, valid=valid, batch_size=args.batchsize, epoch=args.epoch, out=args.out, extensions_list=None, device=device, converter=dataset.converter, resume_path=None) # Save the regressor's parameters. model_path = os.path.join(args.out, args.model_filename) print('Saving the trained model to {}...'.format(model_path)) regressor.save_pickle(model_path, protocol=args.protocol)
def main(): # Supported preprocessing/network list method_list = ['nfp', 'ggnn', 'schnet', 'weavenet', 'rsgcn'] label_names = [ 'A', 'B', 'C', 'mu', 'alpha', 'h**o', 'lumo', 'gap', 'r2', 'zpve', 'U0', 'U', 'H', 'G', 'Cv' ] scale_list = ['standardize', 'none'] parser = argparse.ArgumentParser(description='Regression with QM9.') parser.add_argument('--method', '-m', type=str, choices=method_list, default='nfp') parser.add_argument('--label', '-l', type=str, choices=label_names, default='', help='target label for regression, ' 'empty string means to predict all ' 'property at once') parser.add_argument('--scale', type=str, choices=scale_list, default='standardize', help='Label scaling method') parser.add_argument('--conv-layers', '-c', type=int, default=4) parser.add_argument('--batchsize', '-b', type=int, default=32) parser.add_argument('--gpu', '-g', type=int, default=-1) parser.add_argument('--out', '-o', type=str, default='result') parser.add_argument('--epoch', '-e', type=int, default=20) parser.add_argument('--unit-num', '-u', type=int, default=16) parser.add_argument('--seed', '-s', type=int, default=777) parser.add_argument('--train-data-ratio', '-t', type=float, default=0.7) args = parser.parse_args() seed = args.seed train_data_ratio = args.train_data_ratio method = args.method if args.label: labels = args.label cache_dir = os.path.join('input', '{}_{}'.format(method, labels)) class_num = len(labels) if isinstance(labels, list) else 1 else: labels = None cache_dir = os.path.join('input', '{}_all'.format(method)) class_num = len(D.get_qm9_label_names()) # Dataset preparation dataset = None if os.path.exists(cache_dir): print('load from cache {}'.format(cache_dir)) dataset = NumpyTupleDataset.load(os.path.join(cache_dir, 'data.npz')) if dataset is None: print('preprocessing dataset...') preprocessor = preprocess_method_dict[method]() dataset = D.get_qm9(preprocessor, labels=labels) os.makedirs(cache_dir) NumpyTupleDataset.save(os.path.join(cache_dir, 'data.npz'), dataset) if args.scale == 'standardize': # Standard Scaler for labels ss = StandardScaler() labels = ss.fit_transform(dataset.get_datasets()[-1]) dataset = NumpyTupleDataset(*dataset.get_datasets()[:-1], labels) train_data_size = int(len(dataset) * train_data_ratio) train, val = split_dataset_random(dataset, train_data_size, seed) # Network n_unit = args.unit_num conv_layers = args.conv_layers if method == 'nfp': print('Train NFP model...') model = GraphConvPredictor( NFP(out_dim=n_unit, hidden_dim=n_unit, n_layers=conv_layers), MLP(out_dim=class_num, hidden_dim=n_unit)) elif method == 'ggnn': print('Train GGNN model...') model = GraphConvPredictor( GGNN(out_dim=n_unit, hidden_dim=n_unit, n_layers=conv_layers), MLP(out_dim=class_num, hidden_dim=n_unit)) elif method == 'schnet': print('Train SchNet model...') model = GraphConvPredictor( SchNet(out_dim=class_num, hidden_dim=n_unit, n_layers=conv_layers), None) elif method == 'weavenet': print('Train WeaveNet model...') n_atom = 20 n_sub_layer = 1 weave_channels = [50] * conv_layers model = GraphConvPredictor( WeaveNet(weave_channels=weave_channels, hidden_dim=n_unit, n_sub_layer=n_sub_layer, n_atom=n_atom), MLP(out_dim=class_num, hidden_dim=n_unit)) elif method == 'rsgcn': print('Train RSGCN model...') model = GraphConvPredictor( RSGCN(out_dim=n_unit, hidden_dim=n_unit, n_layers=conv_layers), MLP(out_dim=class_num, hidden_dim=n_unit)) else: raise ValueError('[ERROR] Invalid method {}'.format(method)) train_iter = I.SerialIterator(train, args.batchsize) val_iter = I.SerialIterator(val, args.batchsize, repeat=False, shuffle=False) def scaled_abs_error(x0, x1): if isinstance(x0, Variable): x0 = cuda.to_cpu(x0.data) if isinstance(x1, Variable): x1 = cuda.to_cpu(x1.data) if args.scale == 'standardize': scaled_x0 = ss.inverse_transform(cuda.to_cpu(x0)) scaled_x1 = ss.inverse_transform(cuda.to_cpu(x1)) diff = scaled_x0 - scaled_x1 elif args.scale == 'none': diff = cuda.to_cpu(x0) - cuda.to_cpu(x1) return numpy.mean(numpy.absolute(diff), axis=0)[0] classifier = L.Classifier(model, lossfun=F.mean_squared_error, accfun=scaled_abs_error) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() classifier.to_gpu() optimizer = O.Adam() optimizer.setup(classifier) updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu, converter=concat_mols) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend( E.Evaluator(val_iter, classifier, device=args.gpu, converter=concat_mols)) trainer.extend(E.snapshot(), trigger=(args.epoch, 'epoch')) trainer.extend(E.LogReport()) trainer.extend( E.PrintReport([ 'epoch', 'main/loss', 'main/accuracy', 'validation/main/loss', 'validation/main/accuracy', 'elapsed_time' ])) trainer.extend(E.ProgressBar()) trainer.run()
def get_mpii_dataset(insize, image_root, annotations, train_size=0.5, min_num_keypoints=1, use_cache=False, seed=0): dataset_type = 'mpii' annotations = json.load(open(annotations, 'r')) # filename => keypoints, bbox, is_visible, is_labeled images = {} # DEBUGGING OVERFITTING # create a list containing the actual iamges in folder -> for debugging from os import listdir files = listdir(image_root) for filename in np.unique([anno['filename'] for anno in annotations]): if filename in files: images[filename] = [], [], [], [], [], [ ] # include scale and position for anno in annotations: if anno['filename'] in files: is_visible = [anno['is_visible'][k] for k in KEYPOINT_NAMES[1:]] if sum(is_visible) < min_num_keypoints: continue keypoints = [ anno['joint_pos'][k][::-1] for k in KEYPOINT_NAMES[1:] ] x1, y1, x2, y2 = anno['head_rect'] entry = images[anno['filename']] entry[0].append(np.array(keypoints)) # array of y,x entry[1].append(np.array([x1, y1, x2 - x1, y2 - y1])) # x, y, w, h entry[2].append(np.array(is_visible, dtype=np.bool)) is_labeled = np.ones(len(is_visible), dtype=np.bool) entry[3].append(is_labeled) entry[4].append(np.array(anno['scale'])) entry[5].append(np.array(anno['position'])) # THIS IS THE OFFICIAL CODE WHEN ALL IMAGES OR USED # for filename in np.unique([anno['filename'] for anno in annotations]): # images[filename] = [], [], [], [], [], [] # include scale and position # # for anno in annotations: # is_visible = [anno['is_visible'][k] for k in KEYPOINT_NAMES[1:]] # if sum(is_visible) < min_num_keypoints: # continue # keypoints = [anno['joint_pos'][k][::-1] for k in KEYPOINT_NAMES[1:]] # # x1, y1, x2, y2 = anno['head_rect'] # # entry = images[anno['filename']] # entry[0].append(np.array(keypoints)) # array of y,x # entry[1].append(np.array([x1, y1, x2 - x1, y2 - y1])) # x, y, w, h # entry[2].append(np.array(is_visible, dtype=np.bool)) # is_labeled = np.ones(len(is_visible), dtype=np.bool) # entry[3].append(is_labeled) # entry[4].append(np.array(anno['scale'])) # entry[5].append(np.array(anno['position'])) # split dataset train_images, test_images = split_dataset_random( list(images.keys()), int(len(images) * train_size), seed=seed) train_set = KeypointDataset2D( dataset_type=dataset_type, insize=insize, keypoint_names=KEYPOINT_NAMES, edges=np.array(EDGES), flip_indices=FLIP_INDICES, keypoints=[images[i][0] for i in train_images], bbox=[images[i][1] for i in train_images], is_visible=[images[i][2] for i in train_images], is_labeled=[images[i][3] for i in train_images], scale=[images[i][4] for i in train_images], position=[images[i][5] for i in train_images], image_paths=train_images, image_root=image_root, use_cache=use_cache, do_augmentation=False # TODO must be True ) test_set = KeypointDataset2D( dataset_type=dataset_type, insize=insize, keypoint_names=KEYPOINT_NAMES, edges=np.array(EDGES), flip_indices=FLIP_INDICES, keypoints=[images[i][0] for i in test_images], bbox=[images[i][1] for i in test_images], is_visible=[images[i][2] for i in test_images], is_labeled=[images[i][3] for i in test_images], scale=[images[i][4] for i in test_images], position=[images[i][5] for i in test_images], image_paths=test_images, image_root=image_root, use_cache=use_cache, do_augmentation=False) return train_set, test_set
def main(): parser = argparse.ArgumentParser(description='Chainer CIFAR example:') parser.add_argument('--dataset', '-d', default='cifar10', help='The dataset to use: cifar10 or cifar100') parser.add_argument('--batchsize', '-b', type=int, default=64, help='Number of images in each mini-batch') parser.add_argument('--learnrate', '-l', type=float, default=0.05, help='Learning rate for SGD') parser.add_argument('--epoch', '-e', type=int, default=300, help='Number of sweeps over the dataset to train') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') parser.add_argument('--out', '-o', default='result', help='Directory to output the result') parser.add_argument('--resume', '-r', default='', help='Resume the training from snapshot') parser.add_argument('--seed', '-s', type=int, default=123, help='seed for split dataset into train & validation') parser.add_argument('--augment', '-a', type=bool, default=True, help='whether augment dataset or not') parser.add_argument('--parallel', '-p', type=bool, default=True, help='use multiprocess iterator or not') args = parser.parse_args() print('GPU: {}'.format(args.gpu)) print('# Minibatch-size: {}'.format(args.batchsize)) print('# epoch: {}'.format(args.epoch)) print('') # Set up a neural network to train. # Classifier reports softmax cross entropy loss and accuracy at every # iteration, which will be used by the PrintReport extension below. if args.dataset == 'cifar10': print('Using CIFAR10 dataset.') class_labels = 10 train, test = get_cifar10() elif args.dataset == 'cifar100': print('Using CIFAR100 dataset.') class_labels = 100 train, test = get_cifar100() else: raise RuntimeError('Invalid dataset choice.') if args.augment: train = TransformDataset(train, transform) else: train, val = split_dataset_random(train, 45000, seed=args.seed) model = L.Classifier(DenseNetCifar(n_class=class_labels)) if args.gpu >= 0: # Make a specified GPU current chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() # Copy the model to the GPU optimizer = chainer.optimizers.NesterovAG(lr=args.learnrate, momentum=0.9) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4)) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) test_iter = chainer.iterators.SerialIterator(test, args.batchsize, repeat=False, shuffle=False) if args.parallel: train_iter = chainer.iterators.MultiprocessIterator( train, args.batchsize, n_processes=2) test_iter = chainer.iterators.MultiprocessIterator( test, args.batchsize, repeat=False, shuffle=False, n_processes=2) # Set up a trainer updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) # Evaluate the model with the test dataset for each epoch trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu)) # Reduce the learning rate by half every 25 epochs. trainer.extend(extensions.ExponentialShift('lr', 0.5), trigger=(25, 'epoch')) # Dump a computational graph from 'loss' variable at the first iteration # The "main" refers to the target link of the "main" optimizer. trainer.extend(extensions.dump_graph('main/loss')) # Take a snapshot at each epoch trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch')) trainer.extend(extensions.snapshot_object(model.predictor, filename='densenet.model'), trigger=(args.epoch, 'epoch')) trainer.extend(extensions.observe_lr(), trigger=(1, 'epoch')) # Write a log of evaluation statistics for each epoch trainer.extend(extensions.LogReport()) # Print selected entries of the log to stdout # Here "main" refers to the target link of the "main" optimizer again, and # "validation" refers to the default name of the Evaluator extension. # Entries other than 'epoch' are reported by the Classifier link, called by # either the updater or the evaluator. trainer.extend(extensions.PrintReport( ['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'lr', 'elapsed_time'])) trainer.extend(extensions.PlotReport( y_keys=['main/loss', 'validation/main/loss'], file_name='loss.png')) trainer.extend(extensions.PlotReport( y_keys=['main/accuracy', 'validation/main/accuracy'], file_name='accuracy.png')) # Print a progress bar to stdout trainer.extend(extensions.ProgressBar()) if args.resume: # Resume from a snapshot chainer.serializers.load_npz(args.resume, trainer) # Run the training trainer.run()
def main(): parser = argparse.ArgumentParser( description='Chainer example: POS-tagging') parser.add_argument('--batchsize', '-b', type=int, default=30, help='Number of images in each mini batch') parser.add_argument('--epoch', '-e', type=int, default=20, help='Number of sweeps over the dataset to train') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') parser.add_argument('--out', '-o', default='result', help='Directory to output the result') parser.add_argument('--resume', '-r', default='', help='Resume the training from snapshot') args = parser.parse_args() vocab = collections.defaultdict(lambda: len(vocab)) pos_vocab = collections.defaultdict(lambda: len(pos_vocab)) # Convert word sequences and pos sequences to integer sequences. nltk.download('brown') data = [] for sentence in nltk.corpus.brown.tagged_sents(): xs = numpy.array([vocab[lex] for lex, _ in sentence], 'i') ys = numpy.array([pos_vocab[pos] for _, pos in sentence], 'i') data.append((xs, ys)) print('# of sentences: {}'.format(len(data))) print('# of words: {}'.format(len(vocab))) print('# of pos: {}'.format(len(pos_vocab))) model = CRF(len(vocab), len(pos_vocab)) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() model.to_gpu(args.gpu) optimizer = chainer.optimizers.Adam() optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001)) test_data, train_data = datasets.split_dataset_random( data, len(data) // 10, seed=0) train_iter = chainer.iterators.SerialIterator(train_data, args.batchsize) test_iter = chainer.iterators.SerialIterator(test_data, args.batchsize, repeat=False, shuffle=False) updater = training.StandardUpdater( train_iter, optimizer, converter=convert, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) evaluator = extensions.Evaluator( test_iter, model, device=args.gpu, converter=convert) # Only validate in each 1000 iteration trainer.extend(evaluator, trigger=(1000, 'iteration')) trainer.extend(extensions.LogReport(trigger=(100, 'iteration')), trigger=(100, 'iteration')) trainer.extend( extensions.MicroAverage( 'main/correct', 'main/total', 'main/accuracy')) trainer.extend( extensions.MicroAverage( 'validation/main/correct', 'validation/main/total', 'validation/main/accuracy')) trainer.extend( extensions.PrintReport( ['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time']), trigger=(100, 'iteration')) trainer.extend(extensions.ProgressBar(update_interval=10)) if args.resume: chainer.serializers.load_npz(args.resume, trainer) trainer.run()
def main(): parser = argparse.ArgumentParser(description="DCGAN") parser.add_argument("--batchsize", "-b", type=int, default=128) parser.add_argument("--epoch", "-e", type=int, default=100) parser.add_argument("--gpu", "-g", type=int, default=0) parser.add_argument("--snapshot_interval", "-s", type=int, default=10) parser.add_argument("--display_interval", "-d", type=int, default=1) parser.add_argument("--n_dimz", "-z", type=int, default=100) parser.add_argument("--dataset", "-ds", type=str, default="mnist") parser.add_argument("--seed", type=int, default=0) parser.add_argument("--out", "-o", type=str, default="result") parser.add_argument("--resume", '-r', default='') args = parser.parse_args() #import .py import Updater import Visualize import Network.mnist_net as Network #print settings print("GPU:{}".format(args.gpu)) print("epoch:{}".format(args.epoch)) print("Minibatch_size:{}".format(args.batchsize)) print("Dataset:{}".format(args.dataset)) print('') out = os.path.join(args.out, args.dataset) #Set up NN gen = Network.Generator(n_hidden=args.n_dimz) dis = Network.Discriminator() enc = Network.Encoder(n_hidden=args.n_dimz) if args.gpu >= 0: chainer.backends.cuda.get_device_from_id(args.gpu).use() gen.to_gpu() dis.to_gpu() #Make optimizer def make_optimizer(model, alpha=0.0002, beta1=0.5): optimizer = optimizers.Adam(alpha=alpha, beta1=beta1) #init_lr = alpha optimizer.setup(model) optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(0.0001), 'hook_dec') return optimizer opt_gen = make_optimizer(gen) opt_dis = make_optimizer(dis) opt_enc = make_optimizer(enc) #Get dataset train_valid, test = mnist.get_mnist(withlabel=True, ndim=3) train, valid = split_dataset_random(train_valid, 50000, seed=0) train = [i[0] for i in train if(i[1]==1)] #ラベル1のみを選択 #Setup iterator train_iter = iterators.SerialIterator(train, args.batchsize) #Setup updater updater = Updater.DCGANUpdater( models=(gen, dis, enc), iterator=train_iter, optimizer={'gen':opt_gen, 'dis':opt_dis, 'enc':opt_enc}, device=args.gpu) #Setup trainer trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=out) snapshot_interval = (args.snapshot_interval, 'epoch') display_interval = (args.display_interval, 'epoch') trainer.extend(extensions.snapshot_object( gen, 'gen_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.snapshot_object( dis, 'dis_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.snapshot_object( enc, 'enc_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.LogReport( trigger=display_interval)) trainer.extend(extensions.PrintReport([ 'epoch', 'gen/loss', 'dis/loss', 'enc/loss', 'elapsed_time' ]), trigger=display_interval) trainer.extend(extensions.ProgressBar()) trainer.extend(Visualize.out_generated_image( gen, dis, enc, 10, 10, args.seed, args.out, args.dataset), trigger=snapshot_interval) if args.resume: chainer.serializers.load_npz(args.resume, trainer) trainer.run()
def main(): # Parse the arguments. args = parse_arguments() if args.label: labels = args.label class_num = len(labels) if isinstance(labels, list) else 1 else: raise ValueError('No target label was specified.') # Dataset preparation. Postprocessing is required for the regression task. def postprocess_label(label_list): return numpy.asarray(label_list, dtype=numpy.float32) # Apply a preprocessor to the dataset. print('Preprocessing dataset...') preprocessor = preprocess_method_dict[args.method]() parser = CSVFileParser(preprocessor, postprocess_label=postprocess_label, labels=labels, smiles_col='SMILES') dataset = parser.parse(args.datafile)['dataset'] # Scale the label values, if necessary. if args.scale == 'standardize': scaler = StandardScaler() scaler.fit(dataset.get_datasets()[-1]) else: scaler = None # Split the dataset into training and validation. train_data_size = int(len(dataset) * args.train_data_ratio) train, _ = split_dataset_random(dataset, train_data_size, args.seed) # Set up the predictor. predictor = set_up_predictor(args.method, args.unit_num, args.conv_layers, class_num, label_scaler=scaler) # Set up the regressor. device = chainer.get_device(args.device) metrics_fun = {'mae': F.mean_absolute_error, 'rmse': rmse} regressor = Regressor(predictor, lossfun=F.mean_squared_error, metrics_fun=metrics_fun, device=device) print('Training...') converter = converter_method_dict[args.method] run_train(regressor, train, valid=None, batch_size=args.batchsize, epoch=args.epoch, out=args.out, extensions_list=None, device=device, converter=converter, resume_path=None) # Save the regressor's parameters. model_path = os.path.join(args.out, args.model_filename) print('Saving the trained model to {}...'.format(model_path)) # TODO(nakago): ChainerX array cannot be sent to numpy array when internal # state has gradients. if hasattr(regressor.predictor.graph_conv, 'reset_state'): regressor.predictor.graph_conv.reset_state() regressor.save_pickle(model_path, protocol=args.protocol)
def main(): # Parse the arguments. args = parse_arguments() if args.label: labels = args.label class_num = len(labels) if isinstance(labels, list) else 1 else: raise ValueError('No target label was specified.') # Dataset preparation. Postprocessing is required for the regression task. def postprocess_label(label_list): label_arr = np.asarray(label_list, dtype=np.int32) return label_arr # Apply a preprocessor to the dataset. print('Preprocessing dataset...') preprocessor = preprocess_method_dict[args.method]() parser = CSVFileParserForPair(preprocessor, postprocess_label=postprocess_label, labels=labels, smiles_cols=['smiles_1', 'smiles_2']) dataset = parser.parse(args.datafile)['dataset'] # Split the dataset into training and validation. train_data_size = int(len(dataset) * args.train_data_ratio) train, val = split_dataset_random(dataset, train_data_size, args.seed) # Set up the predictor. predictor = set_up_predictor(args.method, args.unit_num, args.conv_layers, class_num) # Set up the iterator. train_iter = SerialIterator(train, args.batchsize) val_iter = SerialIterator(val, args.batchsize, repeat=False, shuffle=False) # Set up the regressor. metric_fun = { 'accuracy': F.accuracy, # 'precision': F.precision, # 'recall': F.recall, # 'F1-score': F.f1_score, } classifier = Classifier(predictor, lossfun=F.sigmoid_cross_entropy, metrics_fun=F.accuracy, device=args.gpu) # Set up the optimizer. optimizer = optimizers.Adam() optimizer.setup(classifier) # Set up the updater. updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu, converter=concat_mols) # updater = training.ParallelUpdater(train_iter, optimizer, devices={'main': 0, 'second': 1}, # converter=concat_mols) # Set up the trainer. print('Training...') trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend( E.Evaluator(val_iter, classifier, device=args.gpu, converter=concat_mols)) train_eval_iter = SerialIterator(train, args.batchsize, repeat=False, shuffle=False) trainer.extend( ROCAUCEvaluator(train_eval_iter, classifier, eval_func=predictor, device=args.gpu, converter=concat_mols, name='train_roc', pos_labels=1, ignore_labels=-1, raise_value_error=False)) # extension name='validation' is already used by `Evaluator`, # instead extension name `val` is used. trainer.extend( ROCAUCEvaluator(val_iter, classifier, eval_func=predictor, device=args.gpu, converter=concat_mols, name='val_roc', pos_labels=1, ignore_labels=-1)) trainer.extend( PRCAUCEvaluator(train_eval_iter, classifier, eval_func=predictor, device=args.gpu, converter=concat_mols, name='train_prc', pos_labels=1, ignore_labels=-1, raise_value_error=False)) # extension name='validation' is already used by `Evaluator`, # instead extension name `val` is used. trainer.extend( PRCAUCEvaluator(val_iter, classifier, eval_func=predictor, device=args.gpu, converter=concat_mols, name='val_prc', pos_labels=1, ignore_labels=-1)) trainer.extend( E.PrintReport([ 'epoch', 'main/loss', 'main/accuracy', # 'train_roc/main/roc_auc', 'train_prc/main/prc_auc', 'validation/main/loss', 'validation/main/accuracy', # 'val_roc/main/roc_auc', 'val_prc/main/prc_auc', 'elapsed_time' ])) trainer.extend(E.snapshot(), trigger=(args.epoch, 'epoch')) trainer.extend(E.LogReport()) trainer.extend(E.ProgressBar()) trainer.run() # Save the regressor's parameters. model_path = os.path.join(args.out, args.model_filename) print('Saving the trained models to {}...'.format(model_path)) classifier.save_pickle(model_path, protocol=args.protocol)
print(ans) imagedata = Image.open(imgname[i]) imgarr = [np.asarray(imagedata)] arr.append(np.asarray(imgarr)) arr = np.asarray(arr) pictureArray = arr.reshape(imglen, 1, 795, 492).astype(np.float32) pictureArray /= pictureArray.max() npAnserArray = np.asarray(anserArray) npAnserArray = npAnserArray.reshape(imglen).astype(np.int32) #%% train, test = datasets.split_dataset_random( chainer.datasets.TupleDataset(pictureArray, npAnserArray), 700) #%% train_iter = iterators.SerialIterator(train, 50) test_iter = iterators.SerialIterator(test, 1, repeat=False, shuffle=False) #%% class MLP(Chain): def __init__(self): super(MLP, self).__init__( conv1=F.Convolution2D(1, 30, 5, stride=1), # 入力3 枚、出力30枚、フィルタサイズ5ピクセル conv2=F.Convolution2D(30, 30, 6, stride=1), # 入力30>枚、出力30枚、フィルタサイズ5ピクセル conv3=F.Convolution2D(30, 30, 5, stride=1), # 入力30>枚、出力30枚、フィルタサイズ6ピクセル
from chainer.training import extensions import numpy as np import matplotlib matplotlib.use('Agg') mushroomsfile = 'mushrooms.csv' data_array = np.genfromtxt( mushroomsfile, delimiter=',', dtype=str, skip_header=1) for col in range(data_array.shape[1]): data_array[:, col] = np.unique(data_array[:, col], return_inverse=True)[1] X = data_array[:, 1:].astype(np.float32) Y = data_array[:, 0].astype(np.int32)[:, None] train, test = datasets.split_dataset_random( datasets.TupleDataset(X, Y), int(data_array.shape[0] * .7)) train_iter = ch.iterators.SerialIterator(train, 100) test_iter = ch.iterators.SerialIterator( test, 100, repeat=False, shuffle=False) # Network definition def MLP(n_units, n_out): layer = ch.Sequential(L.Linear(n_units), F.relu) model = layer.repeat(2) model.append(L.Linear(n_out)) return model
def split_train(train_val, num=50000, seed=0): train, valid = split_dataset_random(train_val, num, seed) return train, valid
from chainer.datasets import mnist from chainer.datasets import split_dataset_random from network import network from chainer import training from chainer import optimizers from chainer import iterators from chainer.training import extensions import chainer.links as L import numpy as np # setup mnist dataset(example) train_val, test = mnist.get_mnist(withlabel=True, ndim=1) train, valid = split_dataset_random(train_val, round(len(train_val) * 0.8)) # training params batchsize = 64 # setup iterators train_iter = iterators.SerialIterator(train, batchsize) valid_iter = iterators.SerialIterator(valid, batchsize, False, False) test_iter = iterators.SerialIterator(test, batchsize, False, False) # gpu params gpu_id = 0 # defining updater net = L.Classifier(network()) # optimizer optimizer = optimizers.SGD(lr=0.01).setup(net)
def main(): # Parse the arguments. args = parse_arguments() # Set up some useful variables that will be used later on. method = args.method if args.label: labels = args.label cache_dir = os.path.join('input', '{}_{}'.format(method, labels)) else: labels = D.get_qm9_label_names() cache_dir = os.path.join('input', '{}_all'.format(method)) # Get the filename corresponding to the cached dataset, based on the amount # of data samples that need to be parsed from the original dataset. num_data = args.num_data if num_data >= 0: dataset_filename = 'data_{}.npz'.format(num_data) else: dataset_filename = 'data.npz' # Load the cached dataset. dataset_cache_path = os.path.join(cache_dir, dataset_filename) dataset = None if os.path.exists(dataset_cache_path): print('Loading cached data from {}.'.format(dataset_cache_path)) dataset = NumpyTupleDataset.load(dataset_cache_path) if dataset is None: print('Preprocessing dataset...') preprocessor = preprocess_method_dict[method]() dataset = D.get_qm9(preprocessor, labels=labels) # Cache the newly preprocessed dataset. if not os.path.exists(cache_dir): os.mkdir(cache_dir) NumpyTupleDataset.save(dataset_cache_path, dataset) # Load the standard scaler parameters, if necessary. if args.scale == 'standardize': scaler_path = os.path.join(args.in_dir, 'scaler.pkl') print('Loading scaler parameters from {}.'.format(scaler_path)) with open(scaler_path, mode='rb') as f: scaler = pickle.load(f) else: print('No standard scaling was selected.') scaler = None # Split the dataset into training and testing. train_data_size = int(len(dataset) * args.train_data_ratio) _, test = split_dataset_random(dataset, train_data_size, args.seed) # Use a predictor with scaled output labels. model_path = os.path.join(args.in_dir, args.model_filename) regressor = Regressor.load_pickle(model_path, device=args.gpu) # Replace the default predictor with one that scales the output labels. scaled_predictor = ScaledGraphConvPredictor(regressor.predictor) scaled_predictor.scaler = scaler regressor.predictor = scaled_predictor # This callback function extracts only the inputs and discards the labels. def extract_inputs(batch, device=None): return concat_mols(batch, device=device)[:-1] # Predict the output labels. print('Predicting...') y_pred = regressor.predict(test, converter=extract_inputs) # Extract the ground-truth labels. t = concat_mols(test, device=-1)[-1] n_eval = 10 # Construct dataframe. df_dict = {} for i, l in enumerate(labels): df_dict.update({ 'y_pred_{}'.format(l): y_pred[:, i], 't_{}'.format(l): t[:, i], }) df = pandas.DataFrame(df_dict) # Show a prediction/ground truth table with 5 random examples. print(df.sample(5)) for target_label in range(y_pred.shape[1]): diff = y_pred[:n_eval, target_label] - t[:n_eval, target_label] print('target_label = {}, y_pred = {}, t = {}, diff = {}'.format( target_label, y_pred[:n_eval, target_label], t[:n_eval, target_label], diff)) # Run an evaluator on the test dataset. print('Evaluating...') test_iterator = SerialIterator(test, 16, repeat=False, shuffle=False) eval_result = Evaluator(test_iterator, regressor, converter=concat_mols, device=args.gpu)() print('Evaluation result: ', eval_result) # Save the evaluation results. with open(os.path.join(args.in_dir, 'eval_result.json'), 'w') as f: json.dump(eval_result, f)
def main(): parser = argparse.ArgumentParser(description='Chanier example: MNIST') parser.add_argument('--batchsize', '-b', type=int, default=32, help='Number of sweeps over the dataset to train') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') parser.add_argument('--epoch', '-e', type=int, default=40, help='Number of sweeps over the datasdt to train') parser.add_argument('--out', '-o', default='result', help='Directory to output the result') parser.add_argument('--resume', '-r', default='', help='Resume the training from snapshot') parser.add_argument('--unit', '-u', type=int, default=1000, help='Number of units') args = parser.parse_args() print('GPU: {}'.format(args.gpu)) print('# unit: {}'.format(args.unit)) print('# Minibatch-size: {}'.format(args.batchsize)) print('# epoch: {}'.format(args.epoch)) print('') dataset_gomi = [] preprocessing(dataset_gomi, "sample_images_can1/pic", 10, 1) preprocessing(dataset_gomi, "sample_images_can2/pic", 10, 1) preprocessing(dataset_gomi, "sample_images_can3/pic", 20, 1) preprocessing(dataset_gomi, "sample_images_can4/pic", 10, 1) preprocessing(dataset_gomi, "sample_images_can5/pic", 10, 1) preprocessing(dataset_gomi, "sample_images_bin1/pic", 10, 2) preprocessing(dataset_gomi, "sample_images_bin2/pic", 10, 2) preprocessing(dataset_gomi, "sample_images_bin3/pic", 20, 2) preprocessing(dataset_gomi, "sample_images_pet1/pic", 10, 3) preprocessing(dataset_gomi, "sample_images_pet2/pic", 10, 3) preprocessing(dataset_gomi, "sample_images_pet3/pic", 10, 3) preprocessing(dataset_gomi, "sample_images_pet4/pic", 10, 3) train, test = split_dataset_random(dataset_gomi, 120, seed=0) model = L.Classifier(MLP(), lossfun=F.softmax_cross_entropy) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).user() model.to_gpu() optimizer = chainer.optimizers.Adam() optimizer.setup(model) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) test_iter = chainer.iterators.SerialIterator(test, args.batchsize, repeat=False, shuffle=False) updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu)) trainer.extend(extensions.dump_graph('main/loss')) trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch')) #trainer.extend(extensions.PlotReport(['main/loss','validation/main/accuracy'],'epoch',file_name='loss.png')) trainer.extend( extensions.PlotReport(['main/accuracy', 'validation/main/accuracy'], 'epoch', file_name='accuracy.png')) trainer.extend( extensions.PrintReport([ 'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time' ])) trainer.extend(extensions.ProgressBar()) trainer.extend(extensions.LogReport()) if args.resume: chainer.serializers.load_npz(args.resume, trainer) trainer.run() model.to_cpu() modelname = args.out + "/MLP.model" print('same the trained model: {}'.format(modelname)) chainer.serializers.save_npz("model.npz", model)
def main(): # Parse the arguments. args = parse_arguments() if args.label: labels = args.label class_num = len(labels) if isinstance(labels, list) else 1 else: raise ValueError('No target label was specified.') # Dataset preparation. Postprocessing is required for the regression task. def postprocess_label(label_list): return numpy.asarray(label_list, dtype=numpy.float32) # Apply a preprocessor to the dataset. print('Preprocessing dataset...') preprocessor = preprocess_method_dict[args.method]() parser = CSVFileParser(preprocessor, postprocess_label=postprocess_label, labels=labels, smiles_col='SMILES') dataset = parser.parse(args.datafile)['dataset'] # Scale the label values, if necessary. if args.scale == 'standardize': scaler = StandardScaler() labels = scaler.fit_transform(dataset.get_datasets()[-1]) dataset = NumpyTupleDataset(*(dataset.get_datasets()[:-1] + (labels,))) else: scaler = None # Split the dataset into training and validation. train_data_size = int(len(dataset) * args.train_data_ratio) train, _ = split_dataset_random(dataset, train_data_size, args.seed) # Set up the predictor. predictor = set_up_predictor(args.method, args.unit_num, args.conv_layers, class_num) # Set up the iterator. train_iter = SerialIterator(train, args.batchsize) # Set up the regressor. metrics_fun = {'mean_abs_error': MeanAbsError(scaler=scaler), 'root_mean_sqr_error': RootMeanSqrError(scaler=scaler)} regressor = Regressor(predictor, lossfun=F.mean_squared_error, metrics_fun=metrics_fun, device=args.gpu) # Set up the optimizer. optimizer = optimizers.Adam() optimizer.setup(regressor) # Set up the updater. updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu, converter=concat_mols) # Set up the trainer. print('Training...') trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend(E.snapshot(), trigger=(args.epoch, 'epoch')) trainer.extend(E.LogReport()) trainer.extend(E.PrintReport(['epoch', 'main/loss', 'main/mean_abs_error', 'main/root_mean_sqr_error', 'elapsed_time'])) trainer.extend(E.ProgressBar()) trainer.run() # Save the regressor's parameters. model_path = os.path.join(args.out, args.model_filename) print('Saving the trained model to {}...'.format(model_path)) regressor.save_pickle(model_path, protocol=args.protocol) # Save the standard scaler's parameters. if scaler is not None: with open(os.path.join(args.out, 'scaler.pkl'), mode='wb') as f: pickle.dump(scaler, f, protocol=args.protocol)
# In[] batchsize = 256 learnrate = 0.05 epoch = 300 gpu = 0 out = 'result' resume = '' # In[] class_labels = 5 train_val, test = make_datasets() # model = L.Classifier(VGG16Net.VGG16Net(class_labels)) train_size = int(len(train_val) * 0.9) train, valid = split_dataset_random(train_val, train_size, seed=0) model = L.Classifier(VGG_chainer.VGG(class_labels)) #GPUのセットアップ if gpu >= 0: # Make a specified GPU current chainer.backends.cuda.get_device_from_id(gpu).use() model.to_gpu(gpu) # Copy the model to the GPU xp = cuda.cupy optimizer = chainer.optimizers.MomentumSGD(lr=learnrate).setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(0.0005)) # In[] train_iter = chainer.iterators.SerialIterator(train, batchsize) valid_iter = chainer.iterators.SerialIterator(valid, batchsize,
def main(): parser = argparse.ArgumentParser(description="Vanilla_AE") parser.add_argument("--batchsize", "-b", type=int, default=64) parser.add_argument("--epoch", "-e", type=int, default=100) parser.add_argument("--gpu", "-g", type=int, default=0) parser.add_argument("--snapshot", "-s", type=int, default=10) parser.add_argument("--n_dimz", "-z", type=int, default=64) parser.add_argument("--dataset", "-d", type=str, default='mnist') args = parser.parse_args() #import program import Updater import Evaluator #print settings print("GPU:{}".format(args.gpu)) print("epoch:{}".format(args.epoch)) print("Minibatch_size:{}".format(args.batchsize)) print('') batchsize = args.batchsize gpu_id = args.gpu max_epoch = args.epoch if args.dataset == "mnist": train_val, test = mnist.get_mnist(withlabel=False, ndim=3, scale=255.) import Network.mnist_net as Network else: train_val, test = chainer.datasets.get_cifar10(withlabel=False, scale=255.) import Network.cifar10_net as Network train, valid = split_dataset_random(train_val, 50000, seed=0) model = Network.AE(n_dimz=args.n_dimz) #set iterator train_iter = iterators.SerialIterator(train, batchsize) valid_iter = iterators.SerialIterator(valid, batchsize, repeat=False, shuffle=False) #optimizer def make_optimizer(model, alpha=0.0002, beta1=0.5): optimizer = optimizers.Adam(alpha=alpha, beta1=beta1) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001)) return optimizer opt = make_optimizer(model) #trainer updater = Updater.AEUpdater(model=model, iterator=train_iter, optimizer=opt, device=args.gpu) trainer = training.Trainer(updater, (max_epoch, 'epoch'), out='result') #trainer.extend(extensions.ExponentialShift('lr', 0.5),trigger=(30, 'epoch')) trainer.extend(extensions.LogReport(log_name='log')) trainer.extend( Evaluator.AEEvaluator(iterator=valid_iter, target=model, device=args.gpu)) trainer.extend(extensions.snapshot_object( model, filename='model_snapshot_epoch_{.updater.epoch}.npz'), trigger=(args.snapshot, 'epoch')) #trainer.extend(extensions.snapshot_object(optimizer, filename='optimizer_snapshot_epoch_{.updater.epoch}'), trigger=(args.snapshot, 'epoch')) trainer.extend( extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss'])) trainer.extend(extensions.ProgressBar()) trainer.run() del trainer
def iris_nn(): """Untitled1.ipynb Automatically generated by Colaboratory. Original file is located at https://colab.research.google.com/drive/1VP7qclm8kv1T7PDDy7l2cW1IjjnlUBCr """ epochnum = 1000 from sklearn.datasets import load_iris iris = load_iris() # print(iris) # print(len(iris.data)) # print(len(iris.target)) from chainer import functions as F from chainer import links as L import chainer from chainer.datasets import split_dataset_random class MyNN(chainer.Chain): def __init__(self, output_label): super(MyNN, self).__init__() weight_initializer = chainer.initializers.Normal(scale=0.08, dtype=None) with self.init_scope(): self.l1 = L.Linear(4, 128) self.l2 = L.Linear(None, 128) self.l3 = L.Linear(None, 128) self.l4 = L.Linear(None, 256) self.l5 = L.Linear(None, 512) self.fc1 = L.Linear(None, 256) self.fc2 = L.Linear(None, output_label) def __call__(self, x, t=None, train=True): h1 = F.relu(self.l1(x)) h2 = F.relu(self.l2(h1)) h3 = F.relu(h2) h4 = F.dropout(h3) h6 = self.fc1(h4) h7 = self.fc2(h6) return h7 # y if train else F.softmax(h5) model = MyNN(3) model = L.Classifier(model) optimizer = chainer.optimizers.SGD() optimizer.setup(model) iris["data"] = iris["data"].astype(np.float32) data_and_labels = list(zip(iris["data"], iris["target"])) np.random.shuffle(data_and_labels) threshold = 0.7 l = len(data_and_labels) lth = int(l * threshold) print(lth) print("************") data = [d[0] for d in data_and_labels] labels = [d[1] for d in data_and_labels] """ classnum = np.max(labels) tmplabels = np.zeros((len(labels), classnum + 1), dtype=np.int) for i, j in zip(tmplabels, labels): i[j] = 1 print(tmplabels) labels = tmplabels """ train = chainer.datasets.tuple_dataset.TupleDataset( data[:lth], labels[:lth]) test = chainer.datasets.tuple_dataset.TupleDataset(data[lth:], labels[lth:]) split_at = int(len(data) * 0.7) train, test = split_dataset_random( chainer.datasets.tuple_dataset.TupleDataset(data, labels), split_at) batch_size = 16 test_batch_size = 32 train_iter = chainer.iterators.SerialIterator(train, batch_size, shuffle=True) test_iter = chainer.iterators.SerialIterator(test, test_batch_size, repeat=False, shuffle=False) from chainer import training, datasets, iterators, optimizers from chainer.training import extensions from chainer.training.extensions import LogReport from chainer.backends import cuda updater = training.StandardUpdater(train_iter, optimizer) trainer = training.Trainer(updater, (epochnum, 'epoch'), out='result') trainer.extend(extensions.Evaluator(test_iter, model), name='validation') trainer.extend(extensions.LogReport()) trainer.extend( extensions.PrintReport([ 'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time' ])) # trainer.extend(extensions.PrintReport(['epoch', 'val/main/loss'])) trainer.extend(extensions.ProgressBar()) trainer.run()
def main(): # Supported preprocessing/network list method_list = ['nfp', 'ggnn', 'schnet', 'weavenet', 'rsgcn'] label_names = [ 'A', 'B', 'C', 'mu', 'alpha', 'h**o', 'lumo', 'gap', 'r2', 'zpve', 'U0', 'U', 'H', 'G', 'Cv' ] scale_list = ['standardize', 'none'] parser = argparse.ArgumentParser(description='Regression with QM9.') parser.add_argument('--method', '-m', type=str, choices=method_list, default='nfp') parser.add_argument('--label', '-l', type=str, choices=label_names, default='', help='target label for regression, ' 'empty string means to predict all ' 'property at once') parser.add_argument('--scale', type=str, choices=scale_list, default='standardize', help='Label scaling method') parser.add_argument('--conv-layers', '-c', type=int, default=4) parser.add_argument('--batchsize', '-b', type=int, default=32) parser.add_argument('--gpu', '-g', type=int, default=-1) parser.add_argument('--out', '-o', type=str, default='result') parser.add_argument('--epoch', '-e', type=int, default=20) parser.add_argument('--unit-num', '-u', type=int, default=16) parser.add_argument('--seed', '-s', type=int, default=777) parser.add_argument('--train-data-ratio', '-t', type=float, default=0.7) parser.add_argument('--protocol', type=int, default=2) parser.add_argument('--model-filename', type=str, default='regressor.pkl') parser.add_argument('--num-data', type=int, default=-1, help='Number of data to be parsed from parser.' '-1 indicates to parse all data.') args = parser.parse_args() seed = args.seed train_data_ratio = args.train_data_ratio method = args.method if args.label: labels = args.label cache_dir = os.path.join('input', '{}_{}'.format(method, labels)) class_num = len(labels) if isinstance(labels, list) else 1 else: labels = None cache_dir = os.path.join('input', '{}_all'.format(method)) class_num = len(D.get_qm9_label_names()) # Dataset preparation dataset = None num_data = args.num_data if num_data >= 0: dataset_filename = 'data_{}.npz'.format(num_data) else: dataset_filename = 'data.npz' dataset_cache_path = os.path.join(cache_dir, dataset_filename) if os.path.exists(dataset_cache_path): print('load from cache {}'.format(dataset_cache_path)) dataset = NumpyTupleDataset.load(dataset_cache_path) if dataset is None: print('preprocessing dataset...') preprocessor = preprocess_method_dict[method]() if num_data >= 0: # only use first 100 for debug target_index = numpy.arange(num_data) dataset = D.get_qm9(preprocessor, labels=labels, target_index=target_index) else: dataset = D.get_qm9(preprocessor, labels=labels) os.makedirs(cache_dir) NumpyTupleDataset.save(dataset_cache_path, dataset) if args.scale == 'standardize': # Standard Scaler for labels ss = StandardScaler() labels = ss.fit_transform(dataset.get_datasets()[-1]) else: ss = None dataset = NumpyTupleDataset(*(dataset.get_datasets()[:-1] + (labels, ))) train_data_size = int(len(dataset) * train_data_ratio) train, val = split_dataset_random(dataset, train_data_size, seed) # Network n_unit = args.unit_num conv_layers = args.conv_layers if method == 'nfp': print('Train NFP model...') model = GraphConvPredictor( NFP(out_dim=n_unit, hidden_dim=n_unit, n_layers=conv_layers), MLP(out_dim=class_num, hidden_dim=n_unit)) elif method == 'ggnn': print('Train GGNN model...') model = GraphConvPredictor( GGNN(out_dim=n_unit, hidden_dim=n_unit, n_layers=conv_layers), MLP(out_dim=class_num, hidden_dim=n_unit)) elif method == 'schnet': print('Train SchNet model...') model = GraphConvPredictor( SchNet(out_dim=class_num, hidden_dim=n_unit, n_layers=conv_layers), None) elif method == 'weavenet': print('Train WeaveNet model...') n_atom = 20 n_sub_layer = 1 weave_channels = [50] * conv_layers model = GraphConvPredictor( WeaveNet(weave_channels=weave_channels, hidden_dim=n_unit, n_sub_layer=n_sub_layer, n_atom=n_atom), MLP(out_dim=class_num, hidden_dim=n_unit)) elif method == 'rsgcn': print('Train RSGCN model...') model = GraphConvPredictor( RSGCN(out_dim=n_unit, hidden_dim=n_unit, n_layers=conv_layers), MLP(out_dim=class_num, hidden_dim=n_unit)) else: raise ValueError('[ERROR] Invalid method {}'.format(method)) train_iter = I.SerialIterator(train, args.batchsize) val_iter = I.SerialIterator(val, args.batchsize, repeat=False, shuffle=False) regressor = Regressor( model, lossfun=F.mean_squared_error, metrics_fun={'abs_error': ScaledAbsError(scale=args.scale, ss=ss)}, device=args.gpu) optimizer = O.Adam() optimizer.setup(regressor) updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu, converter=concat_mols) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend( E.Evaluator(val_iter, regressor, device=args.gpu, converter=concat_mols)) trainer.extend(E.snapshot(), trigger=(args.epoch, 'epoch')) trainer.extend(E.LogReport()) trainer.extend( E.PrintReport([ 'epoch', 'main/loss', 'main/abs_error', 'validation/main/loss', 'validation/main/abs_error', 'elapsed_time' ])) trainer.extend(E.ProgressBar()) trainer.run() # --- save regressor & standardscaler --- protocol = args.protocol regressor.save_pickle(os.path.join(args.out, args.model_filename), protocol=protocol) if args.scale == 'standardize': with open(os.path.join(args.out, 'ss.pkl'), mode='wb') as f: pickle.dump(ss, f, protocol=protocol)
def main(): set_random_seed(0) parser = argparse.ArgumentParser( description='Document Classification Example') parser.add_argument('--batchsize', '-b', type=int, default=64, help='Number of documents in each mini-batch') parser.add_argument('--epoch', '-e', type=int, default=30, help='Number of training epochs') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') parser.add_argument('--out', '-o', default='result', help='Directory to output the result') parser.add_argument('--unit', '-u', type=int, default=200, help='Number of units') parser.add_argument('--vocab', '-v', type=int, default=50000, help='Vocabulary size') parser.add_argument('--layer', '-l', type=int, default=1, help='Number of layers of LSMT') parser.add_argument('--dropout', '-d', type=float, default=0.4, help='Dropout rate') parser.add_argument('--gradclip', type=float, default=5, help='Gradient clipping threshold') parser.add_argument('--train_file', '-train', default='data/train.seg.csv', help='Trainig data file.') parser.add_argument('--test_file', '-test', default='data/test.seg.csv', help='Test data file.') parser.add_argument('--model', '-m', help='read model parameters from npz file') parser.add_argument( '--vcb_file', '-vf', default= '/mnt/gold/users/s18153/prjPyCharm/prjNLP_GPU/data/vocab_train_w_NoReplace.vocab_file', help='Vocabulary data file.') parser.add_argument('--case', '-c', default='original', help='Select NN Architecture.') parser.add_argument('--opt', default='sgd', help='Select Optimizer.') parser.add_argument('--dbg_on', action='store_true', help='No save, MiniTrain') args = parser.parse_args() print(args) # train_val = data.DocDataset(args.train_file, vocab_size=args.vocab) if os.path.exists(args.vcb_file): # args.vocab_fileの存在確認(作成済みの場合ロード) with open(args.vcb_file, 'rb') as f_vocab_data: train_val = pickle.load(f_vocab_data) if len(train_val.get_vocab()) != args.vocab: warnings.warn('vocab size incorrect (not implemented...)') else: train_val = data.DocDataset( args.train_file, vocab_size=args.vocab) # make vocab from training data with open(args.vcb_file, 'wb') as f_vocab_save: pickle.dump(train_val, f_vocab_save) if args.dbg_on: len_train_data = len(train_val) N = 1000 print('N', N) rnd_ind = np.random.permutation(range(len_train_data))[:N] train_val = train_val[rnd_ind] (train, valid) = split_dataset_random(train_val, 800, seed=0) else: (train, valid) = split_dataset_random(train_val, 4000, seed=0) train_iter = iterators.SerialIterator(train, args.batchsize) valid_iter = iterators.SerialIterator(valid, args.batchsize, repeat=False, shuffle=False) # test = data.DocDataset(args.test_file, train_val.get_vocab()) # test_iter = iterators.SerialIterator(test, args.batchsize, repeat=False, shuffle=False) print('case', args.case) if args.case == 'original': print('originalで実行されます') result_path = 'result/original' model = L.Classifier( nets_B.DocClassify(n_vocab=args.vocab + 1, n_units=args.unit, n_layers=args.layer, n_out=4, dropout=args.dropout)) elif args.case == 'bi': print('biで実行されます') result_path = 'result/bi' model = L.Classifier( nets_B.DocClassifyBi(n_vocab=args.vocab + 1, n_units=args.unit, n_layers=args.layer, n_out=4, dropout=args.dropout)) elif args.case == 'bi2' or args.case == 'bi_adam_2layer': print('bi改良版') result_path = 'result/bi2' model = L.Classifier( nets_B.DocClassifyBi2(n_vocab=args.vocab + 1, n_units=args.unit, n_layers=args.layer, n_out=4, dropout=args.dropout)) else: warnings.warn('指定したケースは存在しません。デフォルトで実行します') result_path = 'result/sample_result' model = L.Classifier( nets_B.DocClassify(n_vocab=args.vocab + 1, n_units=args.unit, n_layers=args.layer, n_out=4, dropout=args.dropout)) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() # get_device_from_id(args.gpu).use() model.to_gpu() if args.opt == 'sgd': result_path += '_sgd' print('SGD') optimizer = optimizers.SGD(lr=0.01) elif args.opt == 'adam': result_path += '_adam' print('Adam') optimizer = optimizers.Adam() elif args.opt == 'bi_adam_2layer': result_path += '_adam_2layer' print('Adam') optimizer = optimizers.Adam() else: print('指定なしのためSGDで実行') optimizer = optimizers.SGD(lr=0.01) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.GradientClipping(args.gradclip)) # optimizer.add_hook(chainer.optimizer.Lasso(0.01)) updater = training.StandardUpdater(train_iter, optimizer, converter=convert_seq, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=result_path) trainer.extend(extensions.LogReport()) if not args.dbg_on: trainer.extend( extensions.snapshot(filename='snapshot_epoch-{.updater.epoch}')) trainer.extend(extensions.Evaluator(valid_iter, model, converter=convert_seq, device=args.gpu), name='val') trainer.extend( extensions.PrintReport([ 'epoch', 'main/loss', 'main/accuracy', 'val/main/loss', 'val/main/accuracy', 'elapsed_time' ])) trainer.extend( extensions.ParameterStatistics(model.predictor.doc_enc, {'std': np.std})) trainer.extend( extensions.PlotReport(['main/loss', 'val/main/loss'], x_key='epoch', file_name='loss.png')) trainer.extend( extensions.PlotReport(['main/accuracy', 'val/main/accuracy'], x_key='epoch', file_name='accuracy.png')) trainer.extend(extensions.dump_graph('main/loss')) if args.model: serializers.load_npz(args.model, trainer) trainer.run() pass
def run_train(net, optimizer, dataset, save_dir, gpu_id): n_batch = 64 n_epoch = 50 SAVE_MODEL_PER_ITER = 1000 # GPUに転送 if gpu_id is not None: net.to_gpu(gpu_id) # log results_train, results_valid = {}, {} results_train['loss'], results_train['accuracy'] = [], [] results_valid['loss'], results_valid['accuracy'] = [], [] # 入力データを分割 train_val, test_data = split_dataset_random(dataset, int(len(dataset) * 0.8), seed=0) train, valid = split_dataset_random(train_val, int(len(train_val) * 0.8), seed=0) # iteration数出力 print('# of epoch:', n_epoch) print('# of batch:', n_batch) print('# of train data:', len(train)) print('# of valid data:', len(valid)) print('# of iteration:', int(max(n_epoch, n_epoch * len(train) / n_batch)), '\n') # ぷよぷよAIを参考にbatch_sizeは64 train_iter = SerialIterator(train, batch_size=n_batch, repeat=True, shuffle=True) count = 0 for epoch in range(n_epoch): while True: # ミニバッチの取得 train_batch = train_iter.next() # [(x1,t1), (x2, t2), ...]形式から,[[x1,x2,x3,...], [t1,t2,t3,...]]形式へ x0_train, x1_train, t_train = concat_samples(train_batch, gpu_id) # 予測値と目的関数の計算 y_train = net(x0_train, x1_train) loss_train = F.softmax_cross_entropy(y_train, t_train) acc_train = F.accuracy(y_train, t_train) # 勾配の初期化と勾配の計算 net.cleargrads() loss_train.backward() # パラメータの更新 optimizer.update() # iteration カウントアップ count += 1 # SAVE_MODEL_PER_ITER iterationごとにモデルを保存 if count % SAVE_MODEL_PER_ITER == 0: # 各epochのモデルの保存 save_filename = os.path.join(save_dir, 'net_{:03d}.npz'.format(count)) save_model(net, gpu_id, save_filename) print('save model (iteration {}) to {}\n'.format( count, save_filename)) # 1エポック終えたら、valid データで評価する if train_iter.is_new_epoch or count % SAVE_MODEL_PER_ITER == 0: # 検証用データに対する結果の確認 with chainer.using_config('train', False), chainer.using_config( 'enable_backprop', False): # x_valid, t_valid = chainer.dataset.concat_examples(valid, gpu_id) x0_valid, x1_valid, t_valid = concat_samples(valid, gpu_id) y_valid = net(x0_valid, x1_valid) loss_valid = F.softmax_cross_entropy(y_valid, t_valid) acc_valid = F.accuracy(y_valid, t_valid) # 注意:GPU で計算した結果はGPU上に存在するため、CPU上に転送します if gpu_id is not None: loss_train.to_cpu() loss_valid.to_cpu() acc_train.to_cpu() acc_valid.to_cpu() # 結果の表示 print( 'epoch: {}, iteration: {}, loss (train): {:.4f}, loss (valid): {:.4f}\n' 'acc (train): {:.4f}, acc (valid): {:.4f}\n'.format( epoch, count, loss_train.array.mean(), loss_valid.array.mean(), acc_train.array.mean(), acc_valid.array.mean())) if train_iter.is_new_epoch: # 可視化用に保存 results_train['loss'].append(loss_train.array) results_train['accuracy'].append(acc_train.array) results_valid['loss'].append(loss_valid.array) results_valid['accuracy'].append(acc_valid.array) break # モデルの保存 save_filename = os.path.join(save_dir, 'net_final.npz') save_model(net, gpu_id, save_filename) print('save model to {} at {}\n'.format(count, save_filename)) # 損失 (loss) plt.plot(results_train['loss'], label='train') # label で凡例の設定 plt.plot(results_valid['loss'], label='valid') # label で凡例の設定 plt.legend() # 凡例の表示 plt.savefig(os.path.join(save_dir, 'loss.png')) plt.figure() # 精度 (accuracy) plt.plot(results_train['accuracy'], label='train') # label で凡例の設定 plt.plot(results_valid['accuracy'], label='valid') # label で凡例の設定 plt.legend() # 凡例の表示 plt.savefig(os.path.join(save_dir, 'accuracy.png'))
def get_datasets(): labels = pd.read_csv(LabelsPath, index_col=0) # label: 1 -> 102 ds = datasets.LabeledImageDataset(list(zip(labels["image"], labels["label"] - 1)), PreProcessedFlowerImagesDirectory) return datasets.split_dataset_random(ds, int(len(ds) * 0.8), seed=SplitDatasetSeed)
from chainer import datasets from chainer import training from chainer.training import extensions import numpy as np mushroomsfile = 'mushrooms.csv' data_array = np.genfromtxt( mushroomsfile, delimiter=',', dtype=str, skip_header=1) for col in range(data_array.shape[1]): data_array[:, col] = np.unique(data_array[:, col], return_inverse=True)[1] X = data_array[:, 1:].astype(np.float32) Y = data_array[:, 0].astype(np.int32)[:, None] train, test = datasets.split_dataset_random( datasets.TupleDataset(X, Y), int(data_array.shape[0] * .7)) train_iter = chainer.iterators.SerialIterator(train, 100) test_iter = chainer.iterators.SerialIterator( test, 100, repeat=False, shuffle=False) # Network definition class MLP(chainer.Chain): def __init__(self, n_units, n_out): super(MLP, self).__init__() with self.init_scope(): # the input size to each layer inferred from the layer before self.l1 = L.Linear(n_units) # n_in -> n_units self.l2 = L.Linear(n_units) # n_units -> n_units self.l3 = L.Linear(n_out) # n_units -> n_out
def TrainUNet(X, Y, model_=None, optimizer_=None, epoch=40, alpha=0.001, gpu_id=0, loop=1, earlystop=True): assert (len(X) == len(Y)) d_time = datetime.datetime.now().strftime("%m-%d-%H-%M-%S") # 1. Model load. # print(sum(p.data.size for p in model.unet.params())) if model_ is not None: model = Regressor(model_) print("## model loaded.") else: model = Regressor(UNet()) model.compute_accuracy = False if gpu_id >= 0: model.to_gpu(gpu_id) # 2. optimizer load. if optimizer_ is not None: opt = optimizer_ print("## optimizer loaded.") else: opt = optimizers.Adam(alpha=alpha) opt.setup(model) # 3. Data Split. dataset = Unet_DataSet(X, Y) print("# number of patterns", len(dataset)) train, valid = \ split_dataset_random(dataset, int(len(dataset) * 0.8), seed=0) # 4. Iterator train_iter = SerialIterator(train, batch_size=C.BATCH_SIZE) test_iter = SerialIterator(valid, batch_size=C.BATCH_SIZE, repeat=False, shuffle=False) # 5. config train, enable backprop chainer.config.train = True chainer.config.enable_backprop = True # 6. UnetUpdater updater = UnetUpdater(train_iter, opt, model, device=gpu_id) # 7. EarlyStopping if earlystop: stop_trigger = triggers.EarlyStoppingTrigger( monitor='validation/main/loss', max_trigger=(epoch, 'epoch'), patients=5) else: stop_trigger = (epoch, 'epoch') # 8. Trainer trainer = training.Trainer(updater, stop_trigger, out=C.PATH_TRAINRESULT) # 8.1. UnetEvaluator trainer.extend(UnetEvaluator(test_iter, model, device=gpu_id)) trainer.extend(SaveRestore(), trigger=triggers.MinValueTrigger('validation/main/loss')) # 8.2. Extensions LogReport trainer.extend(extensions.LogReport()) # 8.3. Extension Snapshot # trainer.extend(extensions.snapshot(filename='snapshot_epoch-{.updater.epoch}')) # trainer.extend(extensions.snapshot_object(model.unet, filename='loop' + str(loop) + '.model')) # 8.4. Print Report trainer.extend(extensions.observe_lr()) trainer.extend( extensions.PrintReport([ 'epoch', 'main/loss', 'validation/main/loss', 'elapsed_time', 'lr' ])) # 8.5. Extension Graph trainer.extend( extensions.PlotReport(['main/loss', 'validation/main/loss'], x_key='epoch', file_name='loop-' + str(loop) + '-loss' + d_time + '.png')) # trainer.extend(extensions.dump_graph('main/loss')) # 8.6. Progree Bar trainer.extend(extensions.ProgressBar()) # 9. Trainer run trainer.run() chainer.serializers.save_npz(C.PATH_TRAINRESULT / ('loop' + str(loop)), model.unet) return model.unet, opt
def main(): # オプション処理 parser = argparse.ArgumentParser(description='話者認識モデルの学習') parser.add_argument('--batchsize', '-b', type=int, default=50, help='Number of images in each mini-batch') parser.add_argument('--epoch', '-e', type=int, default=20, help='Number of sweeps over the dataset to train') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') parser.add_argument('--out', '-o', default='result', help='Directory to output the result') parser.add_argument('--datadir', '-d', default='train', help='学習データのディレクトリ') args = parser.parse_args() sys.stderr.write('GPU: {}\n'.format(args.gpu)) sys.stderr.write('# minibatch-size: {}\n'.format(args.batchsize)) sys.stderr.write('# epoch: {}\n'.format(args.epoch)) trainf = [] label = 0 print('loading dataset') mfcc = os.listdir(args.datadir) for i in [f for f in mfcc if ('mfcc' in f)]: trainf.append([os.path.join(args.datadir, i), label]) label += 1 #print('{}'.format(trainf)) input = [] target = [] if not os.path.exists(args.out): os.mkdir(args.out) log = open(args.out+"/class_log",'w') for file in trainf: print('{}'.format(file)) log.write('{},{}\n'.format(file[0].strip().split("/")[-1].split(".")[0],file[1])) with open(file[0], 'r') as f: lines = f.readlines() for i, l in enumerate(lines): #print('{}'.format(len(lines))) tmp = [] flag = False for j in range(3): # 3フレームで評価 if i + 2 < len(lines): frame = lines[i+j].strip().split(" ") #print("i:{},file:{}".format(i,file)) np.array(frame,dtype=np.float32) tmp.extend(frame) flag = True #print('{}'.format(tmp)) if flag: input.append(tmp) target.append(file[1]) # print('{}'.format(input)) log.close() #print('{}'.format(input)) #sys.exit() #print(np.array(input)) input = np.array(input).astype(np.float32) target = np.array(target).astype(np.int32) #print('{},{}'.format(len(input), len(target))) train = D.TupleDataset(input, target) #sys.stderr.write(train) #print(len(input)*0.9) train, test = D.split_dataset_random(train, int(len(input)*0.9)) print('{},{}'.format(len(train), len(test))) #sys.exit() model = L.Classifier(DNN(label)) # CNNにする if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current model.to_gpu() # Copy the model to the GPU # Setup an optimizer optimizer = chainer.optimizers.Adam() optimizer.setup(model) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) test_iter = chainer.iterators.SerialIterator(test, args.batchsize, repeat=False, shuffle=False) updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu)) trainer.extend(extensions.dump_graph('main/loss')) trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch')) trainer.extend(extensions.LogReport()) # trainer.extend( # extensions.PlotReport('main/loss', 'epoch', file_name='loss.png')) # trainer.extend( # extensions.PlotReport('main/accuracy', 'epoch', file_name='accuracy.png')) trainer.extend(extensions.PrintReport( ['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time'])) #trainer.extend(extensions.PrintReport( # ['epoch', 'main/loss', 'main/accuracy', 'elapsed_time'])) trainer.extend(extensions.ProgressBar()) print('training start!') trainer.run() # モデルをCPU対応へ model.to_cpu() # 保存 modelname = args.out + "/speaker.model" print('save the trained model: {}'.format(modelname)) chainer.serializers.save_npz(modelname, model)
def main(): # Parse the arguments. args = parse_arguments() device = args.gpu # Set up some useful variables that will be used later on. method = args.method if args.label != 'all': label = args.label cache_dir = os.path.join('input', '{}_{}'.format(method, label)) labels = [label] else: labels = D.get_qm9_label_names() cache_dir = os.path.join('input', '{}_all'.format(method)) # Get the filename corresponding to the cached dataset, based on the amount # of data samples that need to be parsed from the original dataset. num_data = args.num_data if num_data >= 0: dataset_filename = 'data_{}.npz'.format(num_data) else: dataset_filename = 'data.npz' # Load the cached dataset. dataset_cache_path = os.path.join(cache_dir, dataset_filename) dataset = None if os.path.exists(dataset_cache_path): print('Loading cached data from {}.'.format(dataset_cache_path)) dataset = NumpyTupleDataset.load(dataset_cache_path) if dataset is None: print('Preprocessing dataset...') preprocessor = preprocess_method_dict[method]() dataset = D.get_qm9(preprocessor, labels=labels) # Cache the newly preprocessed dataset. if not os.path.exists(cache_dir): os.mkdir(cache_dir) NumpyTupleDataset.save(dataset_cache_path, dataset) # Use a predictor with scaled output labels. model_path = os.path.join(args.in_dir, args.model_filename) regressor = Regressor.load_pickle(model_path, device=device) scaler = regressor.predictor.scaler if scaler is not None: original_t = dataset.get_datasets()[-1] if args.gpu >= 0: scaled_t = cuda.to_cpu(scaler.transform( cuda.to_gpu(original_t))) else: scaled_t = scaler.transform(original_t) dataset = NumpyTupleDataset(*(dataset.get_datasets()[:-1] + (scaled_t,))) # Split the dataset into training and testing. train_data_size = int(len(dataset) * args.train_data_ratio) _, test = split_dataset_random(dataset, train_data_size, args.seed) # This callback function extracts only the inputs and discards the labels. def extract_inputs(batch, device=None): return concat_mols(batch, device=device)[:-1] def postprocess_fn(x): if scaler is not None: scaled_x = scaler.inverse_transform(x) return scaled_x else: return x # Predict the output labels. print('Predicting...') y_pred = regressor.predict( test, converter=extract_inputs, postprocess_fn=postprocess_fn) # Extract the ground-truth labels. t = concat_mols(test, device=device)[-1] original_t = cuda.to_cpu(scaler.inverse_transform(t)) # Construct dataframe. df_dict = {} for i, l in enumerate(labels): df_dict.update({'y_pred_{}'.format(l): y_pred[:, i], 't_{}'.format(l): original_t[:, i], }) df = pandas.DataFrame(df_dict) # Show a prediction/ground truth table with 5 random examples. print(df.sample(5)) n_eval = 10 for target_label in range(y_pred.shape[1]): label_name = labels[target_label] diff = y_pred[:n_eval, target_label] - original_t[:n_eval, target_label] print('label_name = {}, y_pred = {}, t = {}, diff = {}' .format(label_name, y_pred[:n_eval, target_label], original_t[:n_eval, target_label], diff)) # Run an evaluator on the test dataset. print('Evaluating...') test_iterator = SerialIterator(test, 16, repeat=False, shuffle=False) eval_result = Evaluator(test_iterator, regressor, converter=concat_mols, device=device)() print('Evaluation result: ', eval_result) # Save the evaluation results. save_json(os.path.join(args.in_dir, 'eval_result.json'), eval_result) # Calculate mean abs error for each label mae = numpy.mean(numpy.abs(y_pred - original_t), axis=0) eval_result = {} for i, l in enumerate(labels): eval_result.update({l: mae[i]}) save_json(os.path.join(args.in_dir, 'eval_result_mae.json'), eval_result)
def main(): # Supported preprocessing/network list method_list = ['nfp', 'ggnn', 'schnet', 'weavenet', 'rsgcn'] label_names = [ 'A', 'B', 'C', 'mu', 'alpha', 'h**o', 'lumo', 'gap', 'r2', 'zpve', 'U0', 'U', 'H', 'G', 'Cv' ] scale_list = ['standardize', 'none'] parser = argparse.ArgumentParser(description='Regression with QM9.') parser.add_argument('--method', '-m', type=str, choices=method_list, default='nfp') parser.add_argument('--label', '-l', type=str, choices=label_names, default='', help='target label for regression, ' 'empty string means to predict all ' 'property at once') parser.add_argument('--scale', type=str, choices=scale_list, default='standardize', help='Label scaling method') parser.add_argument('--batchsize', '-b', type=int, default=32) parser.add_argument('--gpu', '-g', type=int, default=-1) parser.add_argument('--in-dir', '-i', type=str, default='result') parser.add_argument('--seed', '-s', type=int, default=777) parser.add_argument('--train-data-ratio', '-t', type=float, default=0.7) parser.add_argument('--model-filename', type=str, default='regressor.pkl') parser.add_argument('--num-data', type=int, default=-1, help='Number of data to be parsed from parser.' '-1 indicates to parse all data.') args = parser.parse_args() seed = args.seed train_data_ratio = args.train_data_ratio method = args.method if args.label: labels = args.label cache_dir = os.path.join('input', '{}_{}'.format(method, labels)) # class_num = len(labels) if isinstance(labels, list) else 1 else: labels = D.get_qm9_label_names() cache_dir = os.path.join('input', '{}_all'.format(method)) # class_num = len(labels) # Dataset preparation dataset = None num_data = args.num_data if num_data >= 0: dataset_filename = 'data_{}.npz'.format(num_data) else: dataset_filename = 'data.npz' dataset_cache_path = os.path.join(cache_dir, dataset_filename) if os.path.exists(dataset_cache_path): print('load from cache {}'.format(dataset_cache_path)) dataset = NumpyTupleDataset.load(dataset_cache_path) if dataset is None: print('preprocessing dataset...') preprocessor = preprocess_method_dict[method]() dataset = D.get_qm9(preprocessor, labels=labels) if not os.path.exists(cache_dir): os.mkdir(cache_dir) NumpyTupleDataset.save(dataset_cache_path, dataset) if args.scale == 'standardize': # Standard Scaler for labels with open(os.path.join(args.in_dir, 'ss.pkl'), mode='rb') as f: ss = pickle.load(f) else: ss = None train_data_size = int(len(dataset) * train_data_ratio) train, val = split_dataset_random(dataset, train_data_size, seed) regressor = Regressor.load_pickle(os.path.join(args.in_dir, args.model_filename), device=args.gpu) # type: Regressor # We need to feed only input features `x` to `predict`/`predict_proba`. # This converter extracts only inputs (x1, x2, ...) from the features which # consist of input `x` and label `t` (x1, x2, ..., t). def extract_inputs(batch, device=None): return concat_mols(batch, device=device)[:-1] def postprocess_fn(x): if ss is not None: # Model's output is scaled by StandardScaler, # so we need to rescale back. if isinstance(x, Variable): x = x.data scaled_x = ss.inverse_transform(cuda.to_cpu(x)) return scaled_x else: return x print('Predicting...') y_pred = regressor.predict(val, converter=extract_inputs, postprocess_fn=postprocess_fn) print('y_pred.shape = {}, y_pred[:5, 0] = {}'.format( y_pred.shape, y_pred[:5, 0])) t = concat_mols(val, device=-1)[-1] n_eval = 10 # Construct dataframe df_dict = {} for i, l in enumerate(labels): df_dict.update({ 'y_pred_{}'.format(l): y_pred[:, i], 't_{}'.format(l): t[:, i], }) df = pandas.DataFrame(df_dict) # Show random 5 example's prediction/ground truth table print(df.sample(5)) for target_label in range(y_pred.shape[1]): diff = y_pred[:n_eval, target_label] - t[:n_eval, target_label] print('target_label = {}, y_pred = {}, t = {}, diff = {}'.format( target_label, y_pred[:n_eval, target_label], t[:n_eval, target_label], diff)) # --- evaluate --- # To calc loss/accuracy, we can use `Evaluator`, `ROCAUCEvaluator` print('Evaluating...') val_iterator = SerialIterator(val, 16, repeat=False, shuffle=False) eval_result = Evaluator(val_iterator, regressor, converter=concat_mols, device=args.gpu)() print('Evaluation result: ', eval_result)
def main(): # Supported preprocessing/network list method_list = ['nfp', 'ggnn', 'schnet', 'weavenet', 'rsgcn'] scale_list = ['standardize', 'none'] parser = argparse.ArgumentParser( description='Regression with own dataset.') parser.add_argument('--datafile', type=str, default='dataset.csv') parser.add_argument('--method', '-m', type=str, choices=method_list, default='nfp') parser.add_argument('--label', '-l', nargs='+', default=['value1', 'value2'], help='target label for regression') parser.add_argument('--scale', type=str, choices=scale_list, default='standardize', help='Label scaling method') parser.add_argument('--conv-layers', '-c', type=int, default=4) parser.add_argument('--batchsize', '-b', type=int, default=32) parser.add_argument('--gpu', '-g', type=int, default=-1) parser.add_argument('--out', '-o', type=str, default='result') parser.add_argument('--epoch', '-e', type=int, default=20) parser.add_argument('--unit-num', '-u', type=int, default=16) parser.add_argument('--seed', '-s', type=int, default=777) parser.add_argument('--train-data-ratio', '-t', type=float, default=0.7) parser.add_argument('--protocol', type=int, default=2) args = parser.parse_args() seed = args.seed train_data_ratio = args.train_data_ratio method = args.method if args.label: labels = args.label class_num = len(labels) if isinstance(labels, list) else 1 else: sys.exit("Error: No target label is specified.") # Dataset preparation # Postprocess is required for regression task def postprocess_label(label_list): return numpy.asarray(label_list, dtype=numpy.float32) print('Preprocessing dataset...') preprocessor = preprocess_method_dict[method]() parser = CSVFileParser(preprocessor, postprocess_label=postprocess_label, labels=labels, smiles_col='SMILES') dataset = parser.parse(args.datafile)["dataset"] if args.scale == 'standardize': # Standard Scaler for labels scaler = StandardScaler() labels = scaler.fit_transform(dataset.get_datasets()[-1]) dataset = NumpyTupleDataset(*(dataset.get_datasets()[:-1] + (labels, ))) else: # Not use scaler scaler = None train_data_size = int(len(dataset) * train_data_ratio) train, val = split_dataset_random(dataset, train_data_size, seed) # Network n_unit = args.unit_num conv_layers = args.conv_layers if method == 'nfp': print('Train NFP model...') model = GraphConvPredictor( NFP(out_dim=n_unit, hidden_dim=n_unit, n_layers=conv_layers), MLP(out_dim=class_num, hidden_dim=n_unit)) elif method == 'ggnn': print('Train GGNN model...') model = GraphConvPredictor( GGNN(out_dim=n_unit, hidden_dim=n_unit, n_layers=conv_layers), MLP(out_dim=class_num, hidden_dim=n_unit)) elif method == 'schnet': print('Train SchNet model...') model = GraphConvPredictor( SchNet(out_dim=class_num, hidden_dim=n_unit, n_layers=conv_layers), None) elif method == 'weavenet': print('Train WeaveNet model...') n_atom = 20 n_sub_layer = 1 weave_channels = [50] * conv_layers model = GraphConvPredictor( WeaveNet(weave_channels=weave_channels, hidden_dim=n_unit, n_sub_layer=n_sub_layer, n_atom=n_atom), MLP(out_dim=class_num, hidden_dim=n_unit)) elif method == 'rsgcn': print('Train RSGCN model...') model = GraphConvPredictor( RSGCN(out_dim=n_unit, hidden_dim=n_unit, n_layers=conv_layers), MLP(out_dim=class_num, hidden_dim=n_unit)) else: raise ValueError('[ERROR] Invalid method {}'.format(method)) train_iter = iterators.SerialIterator(train, args.batchsize) val_iter = iterators.SerialIterator(val, args.batchsize, repeat=False, shuffle=False) regressor = Regressor( model, lossfun=F.mean_squared_error, metrics_fun={'abs_error': ScaledAbsError(scaler=scaler)}, device=args.gpu) optimizer = optimizers.Adam() optimizer.setup(regressor) updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu, converter=concat_mols) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend( E.Evaluator(val_iter, regressor, device=args.gpu, converter=concat_mols)) trainer.extend(E.snapshot(), trigger=(args.epoch, 'epoch')) trainer.extend(E.LogReport()) # Note that original scale absolute errors are reported in # (validation/)main/abs_error trainer.extend( E.PrintReport([ 'epoch', 'main/loss', 'main/abs_error', 'validation/main/loss', 'validation/main/abs_error', 'elapsed_time' ])) trainer.extend(E.ProgressBar()) trainer.run() # --- save regressor's parameters --- protocol = args.protocol model_path = os.path.join(args.out, 'model.npz') print('saving trained model to {}'.format(model_path)) serializers.save_npz(model_path, regressor) if scaler is not None: with open(os.path.join(args.out, 'scaler.pkl'), mode='wb') as f: pickle.dump(scaler, f, protocol=protocol) # Example of prediction using trained model smiles = 'c1ccccc1' mol = Chem.MolFromSmiles(smiles) preprocessor = preprocess_method_dict[method]() standardized_smiles, mol = preprocessor.prepare_smiles_and_mol(mol) input_features = preprocessor.get_input_features(mol) atoms, adjs = concat_mols([input_features], device=args.gpu) prediction = model(atoms, adjs).data[0] print('Prediction for {}:'.format(smiles)) for i, label in enumerate(args.label): print('{}: {}'.format(label, prediction[i]))
def main(): # Parse the arguments. args = parse_arguments() device = chainer.get_device(args.device) # Set up some useful variables that will be used later on. method = args.method if args.label != 'all': label = args.label cache_dir = os.path.join('input', '{}_{}'.format(method, label)) labels = [label] else: labels = D.get_qm9_label_names() cache_dir = os.path.join('input', '{}_all'.format(method)) # Get the filename corresponding to the cached dataset, based on the amount # of data samples that need to be parsed from the original dataset. num_data = args.num_data if num_data >= 0: dataset_filename = 'data_{}.npz'.format(num_data) else: dataset_filename = 'data.npz' # Load the cached dataset. dataset_cache_path = os.path.join(cache_dir, dataset_filename) dataset = None if os.path.exists(dataset_cache_path): print('Loading cached data from {}.'.format(dataset_cache_path)) dataset = NumpyTupleDataset.load(dataset_cache_path) if dataset is None: print('Preprocessing dataset...') preprocessor = preprocess_method_dict[method]() if num_data >= 0: # Select the first `num_data` samples from the dataset. target_index = numpy.arange(num_data) dataset = D.get_qm9(preprocessor, labels=labels, target_index=target_index) else: # Load the entire dataset. dataset = D.get_qm9(preprocessor, labels=labels) # Cache the newly preprocessed dataset. if not os.path.exists(cache_dir): os.mkdir(cache_dir) if isinstance(dataset, NumpyTupleDataset): NumpyTupleDataset.save(dataset_cache_path, dataset) # Use a predictor with scaled output labels. model_path = os.path.join(args.in_dir, args.model_filename) regressor = Regressor.load_pickle(model_path, device=device) # Split the dataset into training and testing. train_data_size = int(len(dataset) * args.train_data_ratio) _, test = split_dataset_random(dataset, train_data_size, args.seed) # This callback function extracts only the inputs and discards the labels. # TODO(nakago): consider how to switch which `converter` to use. if isinstance(dataset, NumpyTupleDataset): converter = converter_method_dict[method] @chainer.dataset.converter() def extract_inputs(batch, device=None): return converter(batch, device=device)[:-1] # Extract the ground-truth labels as numpy array. original_t = converter(test, device=-1)[-1] else: converter = dataset.converter extract_inputs = converter # Extract the ground-truth labels as numpy array. original_t = converter(test, device=-1).y # Predict the output labels. print('Predicting...') y_pred = regressor.predict(test, converter=extract_inputs) df_dict = {} for i, l in enumerate(labels): df_dict.update({ 'y_pred_{}'.format(l): y_pred[:, i], 't_{}'.format(l): original_t[:, i], }) df = pandas.DataFrame(df_dict) # Show a prediction/ground truth table with 5 random examples. print(df.sample(5)) n_eval = 10 for target_label in range(y_pred.shape[1]): label_name = labels[target_label] diff = y_pred[:n_eval, target_label] - original_t[:n_eval, target_label] print('label_name = {}, y_pred = {}, t = {}, diff = {}'.format( label_name, y_pred[:n_eval, target_label], original_t[:n_eval, target_label], diff)) # Run an evaluator on the test dataset. print('Evaluating...') test_iterator = SerialIterator(test, 16, repeat=False, shuffle=False) eval_result = Evaluator(test_iterator, regressor, converter=converter, device=device)() print('Evaluation result: ', eval_result) # Save the evaluation results. save_json(os.path.join(args.in_dir, 'eval_result.json'), eval_result) # Calculate mean abs error for each label mae = numpy.mean(numpy.abs(y_pred - original_t), axis=0) eval_result = {} for i, l in enumerate(labels): eval_result.update({l: mae[i]}) save_json(os.path.join(args.in_dir, 'eval_result_mae.json'), eval_result)
for j in range(len(dataset)): if dataset[j][1] == labelids[i]: for k in range(int(max(labeldist) / labeldist[i])): for l in range(extend): datas.append(dataset[j][0]) labels.append(i) conf = np.unique(labels, return_counts=True) header = ['Label_No', 'ExtendedCount', 'Probability'] table = [conf[0], conf[1], ext] result = tabulate(np.array(table).transpose(), header, tablefmt="grid") log.write(result + "\n") dataset = TupleDataset(datas, labels) log.write("data extended\n") #データをシャッフルする from chainer.datasets import split_dataset_random dataset, null = split_dataset_random(dataset, len(dataset), seed=0) log.write("data randomized\n") #データセット全体を 7 : 3 の比率でランダム分割し、学習用、検証用のデータセットとする from chainer.datasets import split_dataset_random n_train = int(len(dataset) * 0.7) n_valid = int(len(dataset) * 0.3) train, valid = split_dataset_random(dataset, n_train, seed=0) train_len = len(train) valid_len = len(valid) log.write('Training dataset size:' + str(train_len) + "\n") log.write('Validation dataset size:' + str(valid_len) + "\n") train_datas = [] train_labels = [] valid_datas = [] valid_labels = []
def get_mpii_dataset(insize, image_root, annotations, train_size=0.5, min_num_keypoints=1, use_cache=False, seed=0): dataset_type = 'mpii' annotations = json.load(open(annotations, 'r')) # filename => keypoints, bbox, is_visible, is_labeled images = {} for filename in np.unique([anno['filename'] for anno in annotations]): images[filename] = [], [], [], [] for anno in annotations: is_visible = [anno['is_visible'][k] for k in KEYPOINT_NAMES[1:]] if sum(is_visible) < min_num_keypoints: continue keypoints = [anno['joint_pos'][k][::-1] for k in KEYPOINT_NAMES[1:]] x1, y1, x2, y2 = anno['head_rect'] entry = images[anno['filename']] entry[0].append(np.array(keypoints)) # array of y,x entry[1].append(np.array([x1, y1, x2 - x1, y2 - y1])) # x, y, w, h entry[2].append(np.array(is_visible, dtype=np.bool)) entry[3].append(np.ones(len(is_visible), dtype=np.bool)) # split dataset train_images, test_images = split_dataset_random( list(images.keys()), int(len(images) * train_size), seed=seed) train_set = KeypointDataset2D( dataset_type=dataset_type, insize=insize, keypoint_names=KEYPOINT_NAMES, edges=np.array(EDGES), flip_indices=FLIP_INDICES, keypoints=[images[i][0] for i in train_images], bbox=[images[i][1] for i in train_images], is_visible=[images[i][2] for i in train_images], is_labeled=[images[i][3] for i in train_images], image_paths=train_images, image_root=image_root, use_cache=use_cache, do_augmentation=True) test_set = KeypointDataset2D( dataset_type=dataset_type, insize=insize, keypoint_names=KEYPOINT_NAMES, edges=np.array(EDGES), flip_indices=FLIP_INDICES, keypoints=[images[i][0] for i in test_images], bbox=[images[i][1] for i in test_images], is_visible=[images[i][2] for i in test_images], is_labeled=[images[i][3] for i in test_images], image_paths=test_images, image_root=image_root, use_cache=use_cache, do_augmentation=False) return train_set, test_set
def main(): parser = argparse.ArgumentParser( description='Chainer example: POS-tagging') parser.add_argument('--batchsize', '-b', type=int, default=30, help='Number of images in each mini batch') parser.add_argument('--epoch', '-e', type=int, default=20, help='Number of sweeps over the dataset to train') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') parser.add_argument('--out', '-o', default='result', help='Directory to output the result') parser.add_argument('--resume', '-r', default='', help='Resume the training from snapshot') args = parser.parse_args() vocab = collections.defaultdict(lambda: len(vocab)) pos_vocab = collections.defaultdict(lambda: len(pos_vocab)) # Convert word sequences and pos sequences to integer sequences. nltk.download('brown') data = [] for sentence in nltk.corpus.brown.tagged_sents(): xs = numpy.array([vocab[lex] for lex, _ in sentence], numpy.int32) ys = numpy.array([pos_vocab[pos] for _, pos in sentence], numpy.int32) data.append((xs, ys)) print('# of sentences: {}'.format(len(data))) print('# of words: {}'.format(len(vocab))) print('# of pos: {}'.format(len(pos_vocab))) model = CRF(len(vocab), len(pos_vocab)) if args.gpu >= 0: chainer.backends.cuda.get_device_from_id(args.gpu).use() model.to_gpu(args.gpu) optimizer = chainer.optimizers.Adam() optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001)) test_data, train_data = datasets.split_dataset_random( data, len(data) // 10, seed=0) train_iter = chainer.iterators.SerialIterator(train_data, args.batchsize) test_iter = chainer.iterators.SerialIterator(test_data, args.batchsize, repeat=False, shuffle=False) updater = training.updaters.StandardUpdater( train_iter, optimizer, converter=convert, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) evaluator = extensions.Evaluator( test_iter, model, device=args.gpu, converter=convert) # Only validate in each 1000 iteration trainer.extend(evaluator, trigger=(1000, 'iteration')) trainer.extend(extensions.LogReport(trigger=(100, 'iteration')), trigger=(100, 'iteration')) trainer.extend( extensions.MicroAverage( 'main/correct', 'main/total', 'main/accuracy')) trainer.extend( extensions.MicroAverage( 'validation/main/correct', 'validation/main/total', 'validation/main/accuracy')) trainer.extend( extensions.PrintReport( ['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time']), trigger=(100, 'iteration')) trainer.extend(extensions.ProgressBar(update_interval=10)) if args.resume: chainer.serializers.load_npz(args.resume, trainer) trainer.run()
def main(): # Parse the arguments. args = parse_arguments() # Set up some useful variables that will be used later on. method = args.method if args.label != 'all': labels = args.label cache_dir = os.path.join('input', '{}_{}'.format(method, labels)) class_num = len(labels) if isinstance(labels, list) else 1 else: labels = None cache_dir = os.path.join('input', '{}_all'.format(method)) class_num = len(D.get_qm9_label_names()) # Get the filename corresponding to the cached dataset, based on the amount # of data samples that need to be parsed from the original dataset. num_data = args.num_data if num_data >= 0: dataset_filename = 'data_{}.npz'.format(num_data) else: dataset_filename = 'data.npz' # Load the cached dataset. dataset_cache_path = os.path.join(cache_dir, dataset_filename) dataset = None if os.path.exists(dataset_cache_path): print('Loading cached dataset from {}.'.format(dataset_cache_path)) dataset = NumpyTupleDataset.load(dataset_cache_path) if dataset is None: print('Preprocessing dataset...') preprocessor = preprocess_method_dict[method]() if num_data >= 0: # Select the first `num_data` samples from the dataset. target_index = numpy.arange(num_data) dataset = D.get_qm9(preprocessor, labels=labels, target_index=target_index) else: # Load the entire dataset. dataset = D.get_qm9(preprocessor, labels=labels) # Cache the laded dataset. if not os.path.exists(cache_dir): os.makedirs(cache_dir) NumpyTupleDataset.save(dataset_cache_path, dataset) # Scale the label values, if necessary. if args.scale == 'standardize': print('Applying standard scaling to the labels.') scaler = StandardScaler() scaled_t = scaler.fit_transform(dataset.get_datasets()[-1]) dataset = NumpyTupleDataset(*(dataset.get_datasets()[:-1] + (scaled_t, ))) else: print('No standard scaling was selected.') scaler = None # Split the dataset into training and validation. train_data_size = int(len(dataset) * args.train_data_ratio) train, valid = split_dataset_random(dataset, train_data_size, args.seed) # Set up the predictor. predictor = set_up_predictor(method, args.unit_num, args.conv_layers, class_num, scaler) # Set up the iterators. train_iter = iterators.SerialIterator(train, args.batchsize) valid_iter = iterators.SerialIterator(valid, args.batchsize, repeat=False, shuffle=False) # Set up the regressor. device = args.gpu metrics_fun = { 'mae': MeanAbsError(scaler=scaler), 'rmse': RootMeanSqrError(scaler=scaler) } regressor = Regressor(predictor, lossfun=F.mean_squared_error, metrics_fun=metrics_fun, device=device) # Set up the optimizer. optimizer = optimizers.Adam() optimizer.setup(regressor) # Set up the updater. updater = training.StandardUpdater(train_iter, optimizer, device=device, converter=concat_mols) # Set up the trainer. trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend( E.Evaluator(valid_iter, regressor, device=device, converter=concat_mols)) trainer.extend(E.snapshot(), trigger=(args.epoch, 'epoch')) trainer.extend(E.LogReport()) trainer.extend( E.PrintReport([ 'epoch', 'main/loss', 'main/mae', 'main/rmse', 'validation/main/loss', 'validation/main/mae', 'validation/main/rmse', 'elapsed_time' ])) trainer.extend(E.ProgressBar()) trainer.run() # Save the regressor's parameters. model_path = os.path.join(args.out, args.model_filename) print('Saving the trained model to {}...'.format(model_path)) regressor.save_pickle(model_path, protocol=args.protocol)
def main(): # Parse the arguments. args = parse_arguments() # Set up some useful variables that will be used later on. method = args.method if args.label != 'all': labels = args.label cache_dir = os.path.join('input', '{}_{}'.format(method, labels)) class_num = len(labels) if isinstance(labels, list) else 1 else: labels = None cache_dir = os.path.join('input', '{}_all'.format(method)) class_num = len(D.get_qm9_label_names()) # Get the filename corresponding to the cached dataset, based on the amount # of data samples that need to be parsed from the original dataset. num_data = args.num_data if num_data >= 0: dataset_filename = 'data_{}.npz'.format(num_data) else: dataset_filename = 'data.npz' # Load the cached dataset. dataset_cache_path = os.path.join(cache_dir, dataset_filename) dataset = None if os.path.exists(dataset_cache_path): print('Loading cached dataset from {}.'.format(dataset_cache_path)) dataset = NumpyTupleDataset.load(dataset_cache_path) if dataset is None: print('Preprocessing dataset...') preprocessor = preprocess_method_dict[method]() if num_data >= 0: # Select the first `num_data` samples from the dataset. target_index = numpy.arange(num_data) dataset = D.get_qm9(preprocessor, labels=labels, target_index=target_index) else: # Load the entire dataset. dataset = D.get_qm9(preprocessor, labels=labels) # Cache the laded dataset. if not os.path.exists(cache_dir): os.makedirs(cache_dir) NumpyTupleDataset.save(dataset_cache_path, dataset) # Scale the label values, if necessary. if args.scale == 'standardize': print('Applying standard scaling to the labels.') scaler = StandardScaler() scaled_t = scaler.fit_transform(dataset.get_datasets()[-1]) dataset = NumpyTupleDataset(*(dataset.get_datasets()[:-1] + (scaled_t,))) else: print('No standard scaling was selected.') scaler = None # Split the dataset into training and validation. train_data_size = int(len(dataset) * args.train_data_ratio) train, valid = split_dataset_random(dataset, train_data_size, args.seed) # Set up the predictor. predictor = set_up_predictor(method, args.unit_num, args.conv_layers, class_num, scaler) # Set up the iterators. train_iter = iterators.SerialIterator(train, args.batchsize) valid_iter = iterators.SerialIterator(valid, args.batchsize, repeat=False, shuffle=False) # Set up the regressor. device = args.gpu metrics_fun = {'mae': MeanAbsError(scaler=scaler), 'rmse': RootMeanSqrError(scaler=scaler)} regressor = Regressor(predictor, lossfun=F.mean_squared_error, metrics_fun=metrics_fun, device=device) # Set up the optimizer. optimizer = optimizers.Adam() optimizer.setup(regressor) # Set up the updater. updater = training.StandardUpdater(train_iter, optimizer, device=device, converter=concat_mols) # Set up the trainer. trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend(E.Evaluator(valid_iter, regressor, device=device, converter=concat_mols)) trainer.extend(E.snapshot(), trigger=(args.epoch, 'epoch')) trainer.extend(E.LogReport()) trainer.extend(E.PrintReport([ 'epoch', 'main/loss', 'main/mae', 'main/rmse', 'validation/main/loss', 'validation/main/mae', 'validation/main/rmse', 'elapsed_time'])) trainer.extend(E.ProgressBar()) trainer.run() # Save the regressor's parameters. model_path = os.path.join(args.out, args.model_filename) print('Saving the trained model to {}...'.format(model_path)) regressor.save_pickle(model_path, protocol=args.protocol)