def __init__(self, nlp, texts, labels, max_length): self.max_length = max_length sents, labels = self._get_labelled_sentences( nlp.pipe(texts, batch_size=5000, n_threads=3), labels) TupleDataset.__init__(self, get_features(sents, max_length), labels)
def main(): parser = argparse.ArgumentParser(description='this network get red corn mask image') parser.add_argument('--batchsize', '-b', type=int, default=1) parser.add_argument('--epoch', '-e', type=int, default=200) parser.add_argument('--source_dir', default='./source') parser.add_argument('--target_dir', default='./target') parser.add_argument('--gpu', type=int, default=0) parser.add_argument('--out', default='result') parser.add_argument('--seed', type=int, default=0) parser.add_argument('--resume', default='') parser.add_argument('--snapshot_interval', type=int, default=1) parser.add_argument('--display_interval', type=int, default=100) args = parser.parse_args() # Setup a neural network to train predictor = Predictor(base=32) discriminator = Discriminator(base=8) # predictor = Predictor(in_ch=3, out_ch=1, base=16) predictor.to_gpu() # Setup an optimizer def make_optimizer(model, alpha=2e-4, beta1=0.5): optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(1e-5), 'hook_dec') return optimizer # def make_optimizer(model): # optimizer = chainer.optimizers.MomentumSGD() # optimizer.setup(model) # optimizer.add_hook(chainer.optimizer.WeightDecay(1e-5), 'hook_dec') # return optimizer opt_pre = make_optimizer(predictor) opt_dis = make_optimizer(discriminator) # source, target = make_dataset(args.source_dir, args.target_dir) with open('source.pickle', 'rb') as f: source = pickle.load(f) with open('target.pickle', 'rb') as f: target = pickle.load(f) source = cp.array(source, dtype='f') / 128 - 1 target = cp.array(target, dtype='f') / 128 - 1 dataset = TupleDataset(source, target) train_data = dataset train_iter = chainer.iterators.SerialIterator(train_data, args.batchsize) test_iter = chainer.iterators.SerialIterator(train_data, args.batchsize) # Setup a trainer updater = Updater( models=(predictor, discriminator), iterator={'main': train_iter, 'test': test_iter}, optimizer={'predictor': opt_pre, 'discriminator': opt_dis}, device=args.gpu ) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) snapshot_interval = (args.snapshot_interval, 'epoch') display_interval = (args.display_interval, 'iteration') trainer.extend(extensions.snapshot(filename='snapshot_iter_{.updater.iteration}.npz'), trigger=snapshot_interval) trainer.extend(extensions.snapshot_object(predictor, 'pre_iter_{.updater.iteration}.npz'), trigger=snapshot_interval) trainer.extend(extensions.LogReport(trigger=display_interval)) trainer.extend(extensions.PrintReport([ 'epoch', 'iteration', 'predictor/loss_mae', 'predictor/loss_adv', 'discriminator/loss' ]), trigger=display_interval) trainer.extend(extensions.ProgressBar(update_interval=10)) trainer.extend(out_image(updater, predictor, args.seed, 'result/sample'), trigger=snapshot_interval) if args.resume: chainer.serializers.load_npz(args.resume, predictor) trainer.run() # if args.gpu >= 0: # predictor.to_cpu() chainer.serializers.save_npz('predictor', predictor)
def make_tupledata_set(size): return TupleDataset(make_image_set(size), make_answer_set(size))
def train(**args): set_seed(42) args = EasyDict(args) logger.info(args) dataset_file = Path(args.dataset_file) data = json.loads(dataset_file.read_text()) ladder = data['ladder'] train_data, valid_data = data['train'], data['valid'] counter = Counter() pokes = train_data + valid_data for poke in pokes: counter.update(poke) counts = [0] * (args.topk + 1) index2poke = ['<unk>'] for i, (name, freq) in enumerate(counter.most_common()): if i < args.topk: counts[i + 1] = freq index2poke.append(name) else: counts[0] += freq vocab = {x: i for i, x in enumerate(index2poke)} n_vocab = len(vocab) logger.info('n_vocab = {}'.format(n_vocab)) train_data = vectorize(train_data, vocab) valid_data = vectorize(valid_data, vocab) X_valid, y_valid = convert(valid_data) X_train, y_train = convert(train_data) train = TupleDataset(X_train, y_train) valid = TupleDataset(X_valid, y_valid) logger.info('train size = {}'.format(len(train))) logger.info('valid size = {}'.format(len(valid))) train_iter = chainer.iterators.SerialIterator(train, 32) valid_iter = chainer.iterators.SerialIterator(valid, 32, repeat=False, shuffle=False) if args.loss_func == 'softmax': loss_func = SoftmaxCrossEntropyLoss(args.n_units, n_vocab) elif args.loss_func == 'ns': loss_func = L.NegativeSampling(args.n_units, counts, args.negative_size) loss_func.W.data[...] = 0 else: raise ValueError('invalid loss_func: {}'.format(args.loss_func)) prefix = '{}_{}_{}'.format(ladder, args.loss_func, args.n_units) model = ContinuousBoW(n_vocab, args.n_units, loss_func) optimizer = O.Adam() optimizer.setup(model) updater = training.updater.StandardUpdater(train_iter, optimizer) trainer = training.Trainer(updater, (10, 'epoch'), out='results') trainer.extend(extensions.Evaluator(valid_iter, model)) trainer.extend(extensions.LogReport(log_name='{}_log'.format(prefix))) trainer.extend( extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss'])) trainer.extend(extensions.ProgressBar()) trainer.run() # Save the word2vec model Path('results').mkdir(exist_ok=True) poke2vec_file = 'results/{}_poke2vec.model'.format(prefix) with open(poke2vec_file, 'w') as f: f.write('%d %d\n' % (n_vocab, args.n_units)) w = model.embed.W.data for i, wi in enumerate(w): v = ' '.join(map(str, wi)) f.write('%s %s\n' % (index2poke[i], v))
# csvデータをinput_dataに格納する # Input_dataというフォルダに入れたcsvから読み取る input_data = pd.read_csv('Input_data/matsuda_questionare.csv', header=0) #header=0は省略可。見出しがあるので行番号を0スタートとする # loc関数を使ってカラムのタイトル指定 # 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なので本当は書かなくてもいい # ------------------------------------------------------------------------------
def main(): parser = argparse.ArgumentParser(description='Chainer example: MNIST') parser.add_argument('--batchsize', '-b', type=int, default=100, help='Number of images in each mini-batch') parser.add_argument('--epoch', '-e', type=int, default=30, help='Number of sweeps over the dataset to train') parser.add_argument('--frequency', '-f', type=int, default=-1, help='Frequency of taking a snapshot') 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('--unit', '-u', type=int, default=50, help='Number of units') parser.add_argument('--example', '-ex', type=int, default=1, help='Example mode') 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('') # Load the iris dataset data, target = load_iris(return_X_y=True) X = data.astype(np.float32) y = target.astype(np.int32) model = SklearnWrapperClassifier(MLP(args.unit, 10), device=args.gpu) if args.example == 1: print("Example 1. fit with x, y numpy array (same with sklearn's fit)") model.fit(X, y, epoch=args.epoch) elif args.example == 2: print("Example 2. Train with Chainer's dataset") # `train` is TupleDataset in this example train = TupleDataset(X, y) model.fit(train, epoch=args.epoch) else: print("Example 3. Train with configuration") dataset = TupleDataset(X, y) train_size = int(len(dataset) * 0.7) # use 70 % of data as train data train, test = chainer.datasets.split_dataset_random( dataset, train_size) model.fit( train, test=test, batchsize=args.batchsize, #iterator_class=chainer.iterators.SerialIterator, optimizer=chainer.optimizers.Adam(), epoch=args.epoch, out=args.out, snapshot_frequency=1, #dump_graph=False #log_report=True, plot_report=False, #print_report=True, progress_report=False, resume=args.resume) # Save trained model serializers.save_npz('{}/mlp.model'.format(args.out), model)
if len(line.split(",")) != input_width + 1: continue chklen = 0 for x in line.split(",")[0:input_width + 1]: if len(x) == 0: chklen = 1 if chklen == 0: data = np.array( [np.float32(float(x)) for x in line.split(",")[0:input_width]]) label = np.array(line.split(",")[input_width], np.int32) datas.append(data) labels.append(label) csv_file.close() #ラベルごとに集計 dataset = TupleDataset(datas, labels) uniq_data = np.unique(labels, return_counts=True) kinds = len(uniq_data[0]) labelids = uniq_data[0] labeldist = uniq_data[1] header = ['Label_No', 'Count'] table = [labelids, labeldist] result = tabulate(np.array(table).transpose(), header, tablefmt="grid") log.write(result + "\n") #重複するデータセットはラベルを小さい番号優先(labelでsortしてuniqueなdataの先頭行を取得) index = np.argsort(labels, kind='quicksort', axis=0) labelsort_datas = [] labelsort_labels = [] for i in range(index.size): labelsort_datas.append(datas[index[i]]) labelsort_labels.append(labels[index[i]])
df = pd.read_csv('trainer/split_point_2.csv', index_col=0) df = df[np.random.permutation(df.columns)] word_vec = np.array([word_vectors.get_vector(word) for word in df.columns], dtype=np.float32) original_data = [word_to_index(x) for x in df.columns] original_data = [ one_hot_encoding(x).astype(np.float32) for x in original_data ] split_point = np.nan_to_num(df, 0).T trainX = original_data[:1500] testX = original_data[1500:] trainY = split_point[:1500].astype(np.float32) testY = split_point[1500:].astype(np.float32) model = LSTM(27, 200, 17) optimizer = optimizers.Adam() optimizer.setup(model) from chainer.datasets import TupleDataset train_set = TupleDataset(trainX, word_vec[:1500], trainY) train_set = iterators.SerialIterator(train_set, 1500) updater = training.updater.Updater(train_set, optimizer) trainer = training.Trainer(updater, (5, 'epoch'), out='result') trainer.run()
from chainer import iterators, optimizers, serializers, report, training from chainer.datasets import TupleDataset from chainer.training import extensions nn = MLP() #chainer.cuda.get_device(0).use() #nn.to_gpu() #print("using GPU \n") print(dataset[:9500, 0:1].shape) print(dataset[:9500, 0].shape) print(dataset[:9500].shape) train = TupleDataset(dataset[:9500, 0:1], dataset[:9500, 1:2]) val = TupleDataset(dataset[9500:, 0:1], dataset[9500:, 1:2]) max_epoch = 10 batchsize = 40 train_iter = iterators.SerialIterator(train, batchsize) val_iter = iterators.SerialIterator(val, batchsize, False, False) optimizer = optimizers.Adam() optimizer.setup(nn) updater = training.updaters.StandardUpdater(train_iter, optimizer, device=0) trainer = training.Trainer(updater, (max_epoch, 'epoch')) trainer.extend(extensions.LogReport())
t1 = time.time() elapsed_time1 = t1 - t0 print("データ読み込み時間:{}".format(elapsed_time1)) p = list(zip(x, y)) random.shuffle(p) x, y = zip(*p) from chainer import iterators, optimizers, serializers, report, training from chainer.datasets import TupleDataset from chainer.training import extensions nn = network.CNN() ##print(x[0:train_num]) train = TupleDataset(x[:train_num], y[:train_num]) val = TupleDataset(x[train_num:], y[train_num:]) train_iter = iterators.SerialIterator(train, batchsize) val_iter = iterators.SerialIterator(val, batchsize, False, False) optimizer = optimizers.Adam() optimizer.setup(nn) updater = training.updaters.StandardUpdater(train_iter, optimizer, device=gpu) trainer = training.Trainer(updater, (max_epoch, 'epoch')) trainer.extend(extensions.LogReport()) trainer.extend(extensions.Evaluator(val_iter, nn, device=gpu)) trainer.extend( extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss']))
def pair_datasets(dataset_a, dataset_b): n = min(len(dataset_a), len(dataset_b)) return TupleDataset(dataset_a[:n], dataset_b[:n])
if 'png' in fn: # 画素データを0〜1の領域にする hpix1 = np.array(img, dtype=np.float32) / 255.0 hpix1 = hpix1.transpose(2, 0, 1) listdataset1.append(hpix1) else: # 画素データを0〜1の領域にする hpix2 = np.array(img, dtype=np.float32) / 255.0 hpix2 = hpix2.transpose(2, 0, 1) listdataset2.append(hpix2) # 配列に追加 tupledataset1 = tuple(listdataset1) tupledataset2 = tuple(listdataset2) dataset = TupleDataset(tupledataset1, tupledataset2) # 繰り返し条件を作成する train_iter = iterators.SerialIterator(dataset, batch_size, shuffle=True) # 誤差逆伝播法アルゴリズムを選択する optimizer_gen = optimizers.Adam(alpha=0.0002, beta1=0.5) optimizer_gen.setup(model_gen) #model_gen.vgg16.disable_update() # デバイスを選択してTrainerを作成する updater = Updater(train_iter, {'opt_gen': optimizer_gen}, device=uses_device) trainer = training.Trainer(updater, (1000, 'epoch'), out="result") # 学習の進展を表示するようにする trainer.extend(extensions.ProgressBar()) trainer.extend(extensions.LogReport(trigger=(500, 'epoch'), log_name='log'))
def generate_dataset(self, ignore=["unlabelled"], args=None): crop_size = 128 data_dimensions = [crop_size, crop_size, 7] seed = 0 np.random.seed(seed) possible_groups = [['off', 'on'], ['nonfacing', 'facing'], ['out', 'in']] object_colors = ['red', 'blue', 'yellow', 'purple'] object_shapes = ['cube', 'cup', 'bowl'] # self.groups_rel = {0 : possible_groups[0]} # 1 : possible_groups[1], # 2 : possible_groups[2]} self.groups_rel = { i: possible_groups[i] for i in range(len(possible_groups)) } self.groups_obj = {0: object_colors, 1: object_shapes} self.cutoff_for_labels = 30 print(self.groups_rel) print(self.groups_obj) expected_labels_list = [['purple_cup', 'red_cube'], ['purple_cup', 'blue_cup'], ['purple_bowl', 'yellow_cube']] # expected_labels_list = [['purple_cup', 'blue_cup'], ['purple_bowl', 'yellow_cube']] relationships_start = [] relationships = { 'off': [[1], []], 'on': [[], []], 'nonfacing': [[], []], 'facing': [[], []], 'out': [[], []], 'in': [[], []] } relationships_start.append(relationships) relationships = { 'off': [[], []], 'on': [[], []], 'nonfacing': [[1], []], 'facing': [[], []], 'out': [[], []], 'in': [[], []] } relationships_start.append(relationships) relationships = { 'off': [[], []], 'on': [[], []], 'nonfacing': [[], []], 'facing': [[], []], 'out': [[1], []], 'in': [[], []] } relationships_start.append(relationships) relationships_end = [] relationships = { 'off': [[], []], 'on': [[1], []], 'nonfacing': [[], []], 'facing': [[], []], 'out': [[], []], 'in': [[], []] } relationships_end.append(relationships) relationships = { 'off': [[], []], 'on': [[], []], 'nonfacing': [[], []], 'facing': [[1], []], 'out': [[], []], 'in': [[], []] } relationships_end.append(relationships) relationships = { 'off': [[], []], 'on': [[], []], 'nonfacing': [[], []], 'facing': [[], []], 'out': [[], []], 'in': [[1], []] } relationships_end.append(relationships) scene_objs_all = [] scene_objs_all.append([{ 'color': 'purple', 'shape': 'cup' }, { 'color': 'red', 'shape': 'cube' }]) scene_objs_all.append([{ 'color': 'purple', 'shape': 'cup' }, { 'color': 'blue', 'shape': 'cup' }]) scene_objs_all.append([{ 'color': 'purple', 'shape': 'bowl' }, { 'color': 'yellow', 'shape': 'cube' }]) train = [] train_labels = [] train_vectors = [] train_masks = [] train_object_vectors = [] train_object_vector_masks = [] train_eefs = [] test = [] test_labels = [] test_vectors = [] test_masks = [] test_object_vectors = [] test_object_vector_masks = [] test_eefs = [] unseen = [] unseen_labels = [] unseen_vectors = [] unseen_masks = [] unseen_object_vectors = [] unseen_object_vector_masks = [] for folder_name in self.folder_names[:]: demonstrations = sorted(os.listdir(folder_name)) # if "_2" not in folder_name and "_3" not in folder_name: # demonstrations = demonstrations[:] # else: # demonstrations = demonstrations[:][:-5] for demonstration in demonstrations[:]: # for demonstration in demonstrations[:10]: # print(len(train)) # print(len(test)) files = glob.glob( osp.join(folder_name, demonstration, "kinect2_qhd_image_color*.jpg")) files = sorted([ x.split('/')[-1].replace('kinect2_qhd_image_color_rect_', '').replace('.jpg', '') for x in files ]) if osp.exists( osp.join(folder_name, demonstration, 'segmented_masks.npy')): self.mask_mode = 'loading' masks_loaded_array = np.load( osp.join(folder_name, demonstration, 'segmented_masks.npy')) else: self.mask_mode = 'segmenting' masks_output_array = {} if self.mask_rcnn == None: # import chainer_mask_rcnn as cmr self.load_model(gpu_id=0) # file_list_train = files[:10] + files[-20:] file_list_train = files[:] number_of_files = len(file_list_train) train_n = int(self.data_split * number_of_files) test_n = number_of_files - train_n train_indecies = np.random.choice(range(number_of_files), train_n, replace=False) test_indecies = np.array( filter(lambda x: x not in train_indecies, range(number_of_files))) train_files = np.take(file_list_train, train_indecies) test_files = np.take(file_list_train, test_indecies) if "train" not in ignore: for file_idx in tqdm(range(len(file_list_train))): if file_idx > self.cutoff_for_labels and len( file_list_train ) - file_idx > self.cutoff_for_labels: if file_idx % 3 != 0: continue file_name = file_list_train[file_idx] if (file_list_train.index(file_name)) == 0: print("Processing FOLDER {0}, {1}/{2}".format( folder_name, demonstrations.index(demonstration) + 1, len(demonstrations))) orig_dims = [540, 960] if "_2" not in folder_name and "_3" not in folder_name: desired_dim = 384 else: desired_dim = 512 if "_3" in folder_name and 'facing' in folder_name: desired_dim = 384 crop_window = [[], []] crop_window[0].append(orig_dims[0] / 2 - desired_dim / 2) crop_window[0].append(orig_dims[0] / 2 + desired_dim / 2) crop_window[1].append(orig_dims[1] / 2 - desired_dim / 2) crop_window[1].append(orig_dims[1] / 2 + desired_dim / 2) bgr = cv2.imread( osp.join( folder_name, demonstration, "kinect2_qhd_image_color_rect_" + file_name + ".jpg")) bgr = bgr[crop_window[0][0]:crop_window[0][1], crop_window[1][0]:crop_window[1][1], :] bgr = bgr / 255. # if file_idx < self.cutoff_for_labels or len(file_list_train) - file_idx < self.cutoff_for_labels: # cv2.imshow("bgr", (bgr * 255).astype(np.uint8)) # cv2.waitKey(50) # continue depth_orig = cv2.imread( osp.join( folder_name, demonstration, "kinect2_qhd_image_depth_rect_" + file_name + ".jpg")) depth_orig = depth_orig[ crop_window[0][0]:crop_window[0][1], crop_window[1][0]:crop_window[1][1], :] # depth_orig = depth_orig / 255. depth_orig = depth_orig / float(np.max(depth_orig)) if self.include_eef: eef_pose = [] if file_idx < self.cutoff_for_labels: eef_file_name = file_list_train[-file_idx] elif len(file_list_train ) - file_idx < self.cutoff_for_labels: eef_file_name = file_list_train[ len(file_list_train) - file_idx] else: eef_file_name = file_name f = open( osp.join( folder_name, demonstration, "r_wrist_roll_link_" + file_name + '.txt')) for line in f: eef_pose.append(float(line)) r, p, yaw = self.quaternion_to_euler(eef_pose[-4:]) x = eef_pose[0] y = eef_pose[1] + 0.5 z = eef_pose[2] if self.augment_flag: dist_range = 0 r += np.random.uniform(-dist_range, dist_range, size=1) p += np.random.uniform(-dist_range, dist_range, size=1) yaw += np.random.uniform(-dist_range, dist_range, size=1) dist_range = 0 x += np.random.uniform(-dist_range, dist_range, size=1) y += np.random.uniform(-dist_range, dist_range, size=1) z += np.random.uniform(-dist_range, dist_range, size=1) eef_pose = [ x[0], y[0], z[0], r[0], p[0], yaw[0] ] else: eef_pose = [x, y, z, r, p, yaw] # print(eef_pose) if self.mask_mode == 'loading': dict_entry = masks_loaded_array.item().get( file_name) if dict_entry == None: print("BAD") continue masks = dict_entry.values() labels = dict_entry.keys() scores = np.zeros(len(masks)) # if file_idx < self.cutoff_for_labels or len(file_list_train) - file_idx < self.cutoff_for_labels: # cv2.imshow("bgr", (bgr * 255).astype(np.uint8)) # cv2.imshow("depth", (depth_orig * 255).astype(np.uint8)) # for mask_idx, mask in enumerate(masks): # cv2.imshow("mask " + labels[mask_idx], (mask * 255).astype(np.uint8)) # cv2.waitKey(50) elif self.mask_mode == 'segmenting': expected_labels = expected_labels_list[ self.folder_names.index(folder_name)] masks, labels, scores = self.segment_mask( (bgr * 255).astype(np.uint8), expected_labels) if len(masks) != 2: continue masks_output_array[file_name] = { label: mask for label, mask in zip(labels, masks) } continue n_obj = 2 init_rel = np.array(['unlabelled' for _ in range(3)]) rel_index = { x: { y: init_rel.copy() for y in np.delete(np.arange(n_obj), x) } for x in np.arange(n_obj) } if file_idx < self.cutoff_for_labels: rels = relationships_end[self.folder_names.index( folder_name)] elif len(file_list_train ) - file_idx < self.cutoff_for_labels: rels = relationships_start[self.folder_names.index( folder_name)] else: rels = { 'off': [[], []], 'on': [[], []], 'nonfacing': [[], []], 'facing': [[], []], 'out': [[], []], 'in': [[], []] } scene_objs = scene_objs_all[self.folder_names.index( folder_name)] for rel_name, obj_list in rels.items(): for i in self.groups_rel: if rel_name in self.groups_rel[i]: group_idx = i for ref_idx, target_list in enumerate(obj_list): for target_idx in target_list: rel_index[ref_idx][target_idx][ group_idx] = rel_name for (ref_idx, target_list) in rel_index.items(): for (target_idx, rel_list) in target_list.items(): # scale = 0.125 # scale = 1 if "_2" not in folder_name and "_3" not in folder_name: scale = 0.3333333333333 else: scale = 0.25 if "_3" in folder_name and 'facing' in folder_name: scale = 0.3333333333333 color = cv2.resize(bgr.copy(), (0, 0), fx=scale, fy=scale) depth = cv2.resize(depth_orig.copy(), (0, 0), fx=scale, fy=scale) bg = np.zeros((depth.shape[0], depth.shape[1])) ref = cv2.resize(masks[ref_idx].copy().astype( np.uint8), (0, 0), fx=scale, fy=scale) ref = ref.astype(np.float32) tar = cv2.resize( masks[target_idx].copy().astype(np.uint8), (0, 0), fx=scale, fy=scale) tar = tar.astype(np.float32) # print(color.shape) # print(depth.shape) # print(ref.shape) # print(tar.shape) if np.sum(tar) == 0 or np.sum(ref) == 0 or ( ref == tar).all(): continue pixels = np.concatenate( (color, depth[..., 0, None], bg[..., None], ref[..., None], tar[..., None]), axis=2) if file_name in train_files: train += [pixels] train_labels.append(rel_list) mask = [] vector = [] for i, rel_name in enumerate(rel_list): if rel_name != "unlabelled": vector.append( self.groups_rel[i].index( rel_name)) mask.append(1) else: vector.append(0) mask.append(0) train_masks.append(mask) train_vectors.append(vector) train_object_vectors.append([]) train_object_vector_masks.append([]) for idx in [ref_idx, target_idx]: color = scene_objs[idx]['color'] shape = scene_objs[idx]['shape'] train_object_vectors[-1].append([object_colors.index(color),\ object_shapes.index(shape)]) train_object_vector_masks[-1].append( [1, 1]) if self.include_eef: train_eefs.append(eef_pose) elif file_name in test_files: test += [pixels] test_labels.append(rel_list) mask = [] vector = [] for i, rel_name in enumerate(rel_list): if rel_name != "unlabelled": vector.append( self.groups_rel[i].index( rel_name)) mask.append(1) else: vector.append(0) mask.append(0) test_masks.append(mask) test_vectors.append(vector) test_object_vectors.append([]) test_object_vector_masks.append([]) for idx in [ref_idx, target_idx]: color = scene_objs[idx]['color'] shape = scene_objs[idx]['shape'] test_object_vectors[-1].append([object_colors.index(color),\ object_shapes.index(shape)]) test_object_vector_masks[-1].append( [1, 1]) if self.include_eef: test_eefs.append(eef_pose) if self.mask_mode == 'segmenting': path = osp.join(folder_name, demonstration, 'segmented_masks.npy') np.save(path, masks_output_array) train = np.array(train, dtype=np.float32) train_labels = np.array(train_labels) train_vectors = np.array(train_vectors) train_masks = np.array(train_masks) train_object_vectors = np.array(train_object_vectors) train_object_vector_masks = np.array(train_object_vector_masks) train_eefs = np.array(train_eefs) test = np.array(test, dtype=np.float32) test_labels = np.array(test_labels) test_vectors = np.array(test_vectors) test_masks = np.array(test_masks) test_object_vectors = np.array(test_object_vectors) test_object_vector_masks = np.array(test_object_vector_masks) test_eefs = np.array(test_eefs) print(train.shape) print(test.shape) unseen = np.array(unseen, dtype=np.float32) unseen_labels = np.array(unseen_labels) unseen_vectors = np.array(unseen_vectors) unseen_masks = np.array(unseen_masks) unseen_object_vectors = np.array(unseen_object_vectors) unseen_object_vector_masks = np.array(unseen_object_vector_masks) train = train.reshape([len(train)] + data_dimensions) test = test.reshape([len(test)] + data_dimensions) # unseen = unseen.reshape([len(unseen)] + data_dimensions) train = np.swapaxes(train, 1, 3) test = np.swapaxes(test, 1, 3) if unseen != []: unseen = np.swapaxes(unseen, 2, 4) if self.include_eef: train_concat = TupleDataset(train, train_vectors, train_masks, \ train_object_vectors, train_object_vector_masks, train_eefs) else: train_concat = TupleDataset(train, train_vectors, train_masks, \ train_object_vectors, train_object_vector_masks) if self.include_eef: test_concat = TupleDataset(test, test_vectors, test_masks, \ test_object_vectors, test_object_vector_masks, test_eefs) else: test_concat = TupleDataset(test, test_vectors, test_masks, \ test_object_vectors, test_object_vector_masks) unseen_concat = TupleDataset(unseen, unseen_vectors, unseen_masks, \ unseen_object_vectors, unseen_object_vector_masks) result = [] result.append(train) result.append(train_labels) result.append(train_concat) result.append(train_vectors) result.append(test) result.append(test_labels) result.append(test_concat) result.append(test_vectors) result.append(unseen) result.append(unseen_labels) result.append(unseen_concat) result.append(unseen_vectors) result.append(self.groups_obj) result.append(self.groups_rel) # for i,x in enumerate(test_concat[:]): # image = x[0] # image = np.swapaxes(image, 0 ,2) # bgr = image[...,:3] # bg = image[...,4] # mask_obj_ref = image[...,5] # mask_obj_tar = image[...,6] # mask = x[2] # vector = x[1] # object_vectors = x[3] # object_vector_masks = x[4] # print("Labels", list(test_labels[i])) # # print("Masks", mask) # # print("Vectors", vector) # print("Object vectors", object_vectors) # # print("Object vector masks", object_vector_masks) # # cv2.imshow("bg", (bg*255).astype(np.uint8)) # cv2.imshow("ref", (mask_obj_ref*255).astype(np.uint8)) # cv2.imshow("tar", (mask_obj_tar*255).astype(np.uint8)) # cv2.imshow("bgr", (bgr*255).astype(np.uint8)) # # if (mask_obj_ref == mask_obj_tar).all(): # # cv2.imshow("diff", (mask_obj_ref != mask_obj_tar).astype(np.uint8) * 255) # cv2.waitKey() return result
score = score.reshape((-1, 1728)) test_scores.append(score) score_name = os.path.basename(npy_path) test_score_names.append(score_name) # 推論の準備 chainer.global_config.train = False model = Estimator() model.to_gpu() test_model_name = "snapshot_epoch_" + str(config["test_model_epoch"]) test_model_path = os.path.join(config["result_dir"], config["test_dir"], MODEL_DIR, test_model_name) load_npz(test_model_path, model, path="updater/model:main/") test_dataset = TupleDataset(test_scores, test_score_names) test_iterator = SerialIterator(test_dataset, int(config["batch_size"]), repeat=False, shuffle=False) test_log_name = "test_epoch_" + str(config["test_model_epoch"]) + ".txt" test_log_path = os.path.join(config["result_dir"], config["test_dir"], test_log_name) unit_list = [] est_lv_list = [] # 推論 with open(test_log_path, "w") as log_f: log_f.write("\t".join(["score_name", "lv", "likelihoods"]) + "\n") remaining = len(test_dataset)
def main(): t0 = time.time() train_num = int(n_data*0.95) test_num = n_data - train_num channel = 1 axis_x = div axis_y = div axis_z = div output_pos = 3 output_ori = 4 if orientation == "quaternion" else 3 class_num = 2 x = np.zeros((n_data, channel, axis_z, axis_y, axis_x), dtype='float32') if orientation == "quaternion": import network_1 as network y = np.zeros((n_data,7), dtype='float32') elif orientation == 'euler': import network_euler as network y = np.zeros((n_data,6), dtype='float32') elif orientation == 'rotation_matrix': import network_matrix as network y = np.zeros((n_data,12), dtype='float32') if output == 'classification': import network_matrix_class as network #y = np.append(y, np.zeros((n_data,class_num), dtype='float32'), axis=1) label = np.zeros((n_data), dtype='int32') print("load dataset") infh = h5py.File('./datasets/hv7_52000.hdf5', 'r') infh.keys() if output == 'classification': infh2 = h5py.File('./datasets/paper_hv6_58000.hdf5', 'r') infh2.keys() for n in tqdm(range(0,n_data)): ## load dataset from hdf if(output == 'regression' or n < n_data/2): voxel_data = infh["data_"+str(n+1)]['voxel'].value tf_data = infh["data_"+str(n+1)]['pose'].value if output == 'classification': label[n] = np.array(0, dtype='int32') else: voxel_data = infh2["data_"+str(n+1)]['voxel'].value tf_data = infh2["data_"+str(n+1)]['pose'].value if output == 'classification': label[n] = np.array(1, dtype='int32') ## transform or normalize orientation x[n,channel-1] = voxel_data.reshape(axis_x, axis_y, axis_z) if orientation == "euler": tf_data[3:6] = tf_data[3:6]/3.14 y[n] = tf_data[0:6] elif orientation == "rotation_matrix": y[n][0:3] = tf_data[0:3] tf_data = euler_matrix(tf_data[3], tf_data[4], tf_data[5], 'sxyz') y[n][3:12] = tf_data[0:3,0:3].reshape(9) print(x.shape) print("y.shape: {}".format(y.shape)) #### visualize voxel data ## point_x = [] ## point_y = [] ## point_z = [] ## fig = plt.figure() ## ax = fig.add_subplot(111, projection='3d') ## ax.set_xlabel("x") ## ax.set_ylabel("y") ## ax.set_zlabel("z") ## ## for m in range(channel): ## for i in range(axis_z): ## for j in range(axis_y): ## for k in range(axis_x): ## if(voxel_data[(div*div*i) + (div*j) + (k)] == 1): ## x[n, m, i, j, k] = 1 ## point_x.append(k) ## point_y.append(j) ## point_z.append(i) ## ## ax.scatter(point_x, point_y, point_z) ## plt.show() ##for a in range(4): ##p = Process(target=make_voxel, args=(infh,)) ##p.start() ##p.join() print("finish loading datasets") t1 = time.time() elapsed_time1 = t1-t0 print("データ読み込み時間:{}".format(elapsed_time1)) nn = network.CNN() if gpu >= 0: nn.to_gpu(0) ##print(x[0:train_num]) if output == 'classification': p = list(zip(x, y, label)) random.shuffle(p) x, y, label = zip(*p) train = TupleDataset(x[:train_num], y[:train_num], label[:train_num]) val = TupleDataset(x[train_num:],y[train_num:], label[train_num:]) else: p = list(zip(x, y)) random.shuffle(p) x, y = zip(*p) train = TupleDataset(x[:train_num], y[:train_num]) val = TupleDataset(x[train_num:],y[train_num:]) train_iter = iterators.SerialIterator(train, batchsize) val_iter = iterators.SerialIterator(val, batchsize, False, False) optimizer = optimizers.Adam() optimizer.setup(nn) updater = training.updaters.StandardUpdater(train_iter, optimizer, device=gpu) trainer = training.Trainer(updater, (max_epoch, 'epoch')) trainer.extend(extensions.LogReport()) trainer.extend(extensions.Evaluator(val_iter, nn, device=gpu)) trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss'])) trainer.extend(extensions.PlotReport(['main/loss', 'validation/main/loss'], x_key='epoch', file_name='loss.png')) trainer.extend(extensions.dump_graph('main/loss')) ##trigger = training.triggers.MaxValueTrigger('validation/main/loss', trigger=(1, 'epoch')) ##trainer.extend(extensions.snapshot_object(nn, filename='result/new_best.model'), trigger=trigger) trainer.run() if args.gpu >= 0: nn.to_cpu() t2 = time.time() elapsed_time2 = t2-t1 print("データ読み込み時間:{}".format(elapsed_time1)) print("学習時間:{}".format(elapsed_time2)) serializers.save_npz('result/new.model', nn)
def main(): parser = argparse.ArgumentParser(description='Chainer example: MNIST') parser.add_argument('--batchsize', '-b', type=int, default=100, 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('--frequency', '-f', type=int, default=-1, help='Frequency of taking a snapshot') parser.add_argument('--device', '-d', type=str, default='-1', help='Device specifier. Either ChainerX device ' 'specifier or an integer. If non-negative integer, ' 'CuPy arrays with specified device id are used. If ' 'negative integer, NumPy arrays are used') 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') parser.add_argument('--noplot', dest='plot', action='store_false', help='Disable PlotReport extension') parser.add_argument('--train_imgs', default='data/kmnist-train-imgs.npz', help='Path to kmnist training images') parser.add_argument('--train_label', default='data/kmnist-train-labels.npz', help='Path to kmnist training labels') parser.add_argument('--test_imgs', default='data/kmnist-test-imgs.npz', help='Path to kmnist test images') parser.add_argument('--test_label', default='data/kmnist-test-labels.npz', help='Path to kmnist test labels') group = parser.add_argument_group('deprecated arguments') group.add_argument('--gpu', '-g', type=int, nargs='?', const=0, help='GPU ID (negative value indicates CPU)') args = parser.parse_args() device = parse_device(args) print('Device: {}'.format(device)) print('# unit: {}'.format(args.unit)) 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. model = L.Classifier(MLP(args.unit, 10)) model.to_device(device) device.use() # Setup an optimizer optimizer = chainer.optimizers.Adam() optimizer.setup(model) # Load and prepare the KMNIST dataset train_data = np.load(args.train_imgs)['arr_0'].\ reshape((60000, 784)).astype(np.float32)/255. train_labels = [int(n) for n in np.load(args.train_label)['arr_0']] train = TupleDataset(train_data, train_labels) test_data = np.load(args.test_imgs)['arr_0'].\ reshape((10000, 784)).astype(np.float32)/255. test_labels = [int(n) for n in np.load(args.test_label)['arr_0']] test = TupleDataset(test_data, test_labels) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) test_iter = chainer.iterators.SerialIterator(test, args.batchsize, repeat=False, shuffle=False) # Set up a trainer updater = training.updaters.StandardUpdater( train_iter, optimizer, device=device) 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=device)) # Dump a computational graph from 'loss' variable at the first iteration # The "main" refers to the target link of the "main" optimizer. # TODO(niboshi): Temporarily disabled for chainerx. Fix it. if device.xp is not chainerx: trainer.extend(extensions.dump_graph('main/loss')) # Take a snapshot for each specified epoch frequency = args.epoch if args.frequency == -1 else max(1, args.frequency) trainer.extend(extensions.snapshot(), trigger=(frequency, 'epoch')) # Write a log of evaluation statistics for each epoch trainer.extend(extensions.LogReport()) # Save two plot images to the result dir if args.plot and extensions.PlotReport.available(): trainer.extend( extensions.PlotReport(['main/loss', 'validation/main/loss'], 'epoch', file_name='loss.png')) trainer.extend( extensions.PlotReport( ['main/accuracy', 'validation/main/accuracy'], 'epoch', file_name='accuracy.png')) # 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', 'elapsed_time'])) # 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()
is_predict = None if '--train' in sys.argv: df = pd.read_csv('vars/one_hot_all.csv') df = df.set_index('id') df = df.drop(['target'], axis=1) EPOCHS = 2 DECAY = 0.995 BATCH_SIZE = 128 INIT_LR = 3 #0.003 model = L.Classifier(MLP(), lossfun=F.mean_squared_error) OPTIMIZER = chainer.optimizers.SGD(lr=INIT_LR) OPTIMIZER.setup(model) for cycle in range(300): noise = swap_noise.noise(df.values).astype(np.float32) train = TupleDataset(noise, df.values.astype(np.float32)) test = TupleDataset(noise[-10000:].astype(np.float32), df[-10000:].values.astype(np.float32)) # iteration, which will be used by the PrintReport extension below. model.compute_accuracy = False chainer.backends.cuda.get_device_from_id(1).use() model.to_gpu() # Copy the model to the GPU print(f'cycle {cycle-1:09d}') train_iter = chainer.iterators.SerialIterator(train , BATCH_SIZE, repeat=True) test_iter = chainer.iterators.SerialIterator(test, BATCH_SIZE, repeat=False, shuffle=False) updater = training.updaters.StandardUpdater(train_iter, OPTIMIZER, device=1) trainer = training.Trainer(updater, (EPOCHS, 'epoch'), out='outputs') trainer.extend(extensions.Evaluator(test_iter, model, device=1)) trainer.extend(extensions.dump_graph('main/loss')) frequency = EPOCHS trainer.extend(extensions.snapshot(), trigger=(frequency, 'epoch')) trainer.extend(extensions.LogReport())
rating = data[:, 2].astype('float32') n_features = user.max() + 1 + movie.max() + 1 # Formatting dataset loc = np.zeros((len(data), 2), dtype='int32') loc[:, 0] = user loc[:, 1] = movie + user.max() val = np.ones((len(data), 2), dtype='float32') # Train test split tloc, vloc, tval, vval, ty, vy = train_test_split(loc, val, rating, random_state=42) total_nobs = len(tloc) train = TupleDataset(tloc, tval, ty) valid = TupleDataset(vloc, vval, vy) # Setup model print "Running model:" + model_type if model_type == 'FM': model = FM(n_features, n_dim, lambda0=lambda0, lambda1=lambda1, lambda2=lambda2, init_bias=ty.mean(), intx_term=intx_term, total_nobs=total_nobs) elif model_type == 'VFM': mu = ty.mean()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--resume', '-m', type=str, default=None) parser.add_argument('--dataset', type=str, default='cora', choices=['cora', 'pubmed', 'citeseer']) parser.add_argument('--lr', type=float, default=0.01, help='Learning rate') parser.add_argument('--epoch', '-e', type=int, default=5000, help='Number of sweeps over the dataset to train') parser.add_argument('--batchsize', '-b', type=int, default=256) 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=32, help='Number of units') parser.add_argument('--dropout', '-d', type=float, default=0.5, help='Dropout rate') parser.add_argument('--weight-decay', type=float, default=5e-4) parser.add_argument('--validation-interval', type=int, default=1, help='Number of updates before running validation') parser.add_argument('--sampling-method', default='cv', choices=['cv', 'ns'], help='Variant of sampling method to use') parser.add_argument('--normalization', default='gcn', choices=['pygcn', 'gcn'], help='Variant of adjacency matrix normalization method to use') args = parser.parse_args() print("Loading data") adj, features, labels, idx_train, idx_val, idx_test = load_data( args.dataset, normalization=args.normalization) train_iter = chainer.iterators.SerialIterator( TupleDataset(idx_train), batch_size=args.batchsize, shuffle=False) dev_iter = chainer.iterators.SerialIterator( TupleDataset(idx_val), batch_size=args.batchsize, repeat=False, shuffle=False) # Set up a neural network to train. model_func = CVGCN if args.sampling_method == 'cv' else NSGCN model = model_func(adj, features, labels, args.unit, dropout=args.dropout) if args.gpu >= 0: # Make a specified GPU current chainer.backends.cuda.get_device_from_id(args.gpu).use() model.to_gpu() # Copy the model to the GPU optimizer = chainer.optimizers.Adam(alpha=args.lr) optimizer.setup(model) if args.weight_decay > 0.: optimizer.add_hook( chainer.optimizer_hooks.WeightDecay(args.weight_decay)) if args.resume != None: print("Loading model from " + args.resume) chainer.serializers.load_npz(args.resume, model) converter = create_convert_func(model, adj, 2) updater = training.StandardUpdater( train_iter, optimizer, converter=converter, device=args.gpu) trigger = training.triggers.EarlyStoppingTrigger( monitor='validation/main/loss', patients=100, check_trigger=(args.validation_interval, 'epoch'), max_trigger=(args.epoch, 'epoch')) trainer = training.Trainer(updater, trigger, out=args.out) trainer.extend( extensions.Evaluator(dev_iter, model, converter=converter, device=args.gpu), trigger=(args.validation_interval, 'epoch')) trainer.extend(extensions.LogReport()) trainer.extend(extensions.PrintReport( ['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time'])) # Take a best snapshot record_trigger = training.triggers.MinValueTrigger( 'validation/main/loss', (args.validation_interval, 'epoch')) trainer.extend( extensions.snapshot_object(model, 'best_model.npz'), trigger=record_trigger) trainer.run() chainer.serializers.load_npz( os.path.join(args.out, 'best_model.npz'), model) print('Updating history for the test nodes...') model.make_exact(converter, 10, args.batchsize, device=args.gpu) chainer.serializers.save_npz( os.path.join(args.out, 'best_model.npz'), model) print('Running test...') _, accuracy = model.evaluate( idx_test, converter, args.batchsize, device=args.gpu) print('Test accuracy = %f' % accuracy)
def main(): # This script is almost identical to train_mnist.py. The only difference is # that this script uses data-parallel computation on two GPUs. # See train_mnist.py for more details. parser = argparse.ArgumentParser(description='Chainer example: MNIST') parser.add_argument('--batchsize', '-b', type=int, default=400, 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('--gpu0', '-g', type=int, default=0, help='First GPU ID') parser.add_argument('--gpu1', '-G', type=int, default=1, help='Second GPU ID') parser.add_argument('--out', '-o', default='result_parallel', 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') parser.add_argument('--train_imgs', default='data/kmnist-train-imgs.npz', help='Path to kmnist training images') parser.add_argument('--train_label', default='data/kmnist-train-labels.npz', help='Path to kmnist training labels') parser.add_argument('--test_imgs', default='data/kmnist-test-imgs.npz', help='Path to kmnist test images') parser.add_argument('--test_label', default='data/kmnist-test-labels.npz', help='Path to kmnist test labels') args = parser.parse_args() print('GPU: {}, {}'.format(args.gpu0, args.gpu1)) print('# unit: {}'.format(args.unit)) print('# Minibatch-size: {}'.format(args.batchsize)) print('# epoch: {}'.format(args.epoch)) print('') chainer.backends.cuda.get_device_from_id(args.gpu0).use() model = L.Classifier(train_kmnist.MLP(args.unit, 10)) optimizer = chainer.optimizers.Adam() optimizer.setup(model) # Load and prepare the KMNIST dataset train_data = np.load(args.train_imgs)['arr_0'].\ reshape((60000, 784)).astype(np.float32)/255. train_labels = [int(n) for n in np.load(args.train_label)['arr_0']] train = TupleDataset(train_data, train_labels) test_data = np.load(args.test_imgs)['arr_0'].\ reshape((10000, 784)).astype(np.float32)/255. test_labels = [int(n) for n in np.load(args.test_label)['arr_0']] test = TupleDataset(test_data, test_labels) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) test_iter = chainer.iterators.SerialIterator(test, args.batchsize, repeat=False, shuffle=False) # ParallelUpdater implements the data-parallel gradient computation on # multiple GPUs. It accepts "devices" argument that specifies which GPU to # use. updater = training.updaters.ParallelUpdater( train_iter, optimizer, # The device of the name 'main' is used as a "master", while others are # used as slaves. Names other than 'main' are arbitrary. devices={ 'main': args.gpu0, 'second': args.gpu1 }, ) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu0)) trainer.extend(extensions.dump_graph('main/loss')) trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch')) trainer.extend(extensions.LogReport()) trainer.extend( extensions.PrintReport([ 'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time' ])) trainer.extend(extensions.ProgressBar()) if args.resume: chainer.serializers.load_npz(args.resume, trainer) trainer.run()
def get_mvmc_flatten_eval(cam): url = 'https://www.dropbox.com/s/rofaov8tgqhh6jv/MVMC.npz' base_dir = get_dataset_directory('mvmc/') path = os.path.join(base_dir, 'mvmc.npz') if not os.path.isfile(path): download(url, path) data = np.load(path) X = data['X'] y = data['y'] # Turn 3 to negative -1 for empty view y = y.astype(np.int32) y[y == 3] = -1 # Get the max and last = np.max(y, 1) last = last[:, np.newaxis] y = np.hstack([y, last]) ridx = [ 770, 723, 240, 21, 548, 440, 378, 192, 435, 792, 248, 784, 608, 676, 406, 353, 515, 709, 692, 303, 58, 565, 549, 82, 418, 825, 108, 562, 333, 226, 427, 431, 483, 165, 72, 386, 290, 186, 714, 740, 682, 218, 701, 417, 652, 352, 775, 60, 150, 404, 554, 823, 755, 232, 831, 221, 839, 167, 198, 567, 337, 238, 420, 400, 79, 242, 53, 474, 383, 684, 747, 537, 590, 389, 700, 423, 665, 377, 185, 301, 791, 434, 468, 231, 486, 820, 822, 798, 4, 403, 455, 233, 320, 817, 5, 407, 91, 56, 104, 151, 125, 415, 574, 316, 659, 387, 512, 661, 669, 155, 824, 518, 126, 587, 499, 205, 842, 725, 522, 342, 645, 612, 365, 65, 813, 399, 818, 38, 762, 644, 563, 463, 462, 350, 131, 343, 767, 370, 366, 630, 154, 675, 172, 270, 410, 175, 541, 478, 696, 295, 598, 766, 95, 306, 275, 286, 788, 105, 112, 210, 761, 207, 40, 48, 703, 450, 330, 493, 837, 245, 349, 732, 236, 182, 92, 201, 419, 90, 552, 19, 519, 672, 650, 662, 806, 272, 787, 73, 582, 132, 146, 100, 695, 603, 632, 76, 359, 251, 721, 102, 41, 239, 10, 393, 197, 89, 814, 664, 170, 558, 358, 163, 14, 843, 800, 797, 174, 346, 128, 203, 573, 259, 157, 261, 628, 6, 739, 241, 327, 553, 319, 835, 707, 188, 671, 534, 533, 602, 311, 785, 422, 712, 305, 528, 3, 466, 372, 827, 274, 318, 380, 145, 467, 647, 768, 144, 497, 196, 169, 481, 453, 447, 655, 635, 556, 249, 627, 752, 706, 193, 42, 836, 17, 140, 2, 413, 611, 428, 69, 288, 439, 815, 369, 348, 505, 677, 509, 718, 408, 591, 149, 200, 228, 795, 593, 566, 599, 116, 506, 215, 491, 502, 61, 500, 847, 651, 779, 620, 88, 622, 624, 414, 495, 34, 848, 487, 432, 595, 807, 78, 680, 545, 28, 759, 490, 294, 148, 62, 617, 656, 379, 489, 122, 597, 529, 778, 601, 688, 179, 543, 234, 322, 536, 171, 362, 840, 658, 763, 213, 583, 781, 260, 120, 492, 250, 516, 633, 336, 520, 32, 302, 660, 195, 30, 280, 194, 623, 217, 613, 621, 829, 314, 526, 335, 219, 461, 216, 638, 298, 782, 720, 646, 341, 152, 679, 9, 804, 25, 16, 609, 351, 331, 285, 284, 572, 446, 64, 310, 223, 173, 356, 426, 776, 367, 212, 224, 535, 398, 97, 396, 501, 81, 777, 717, 482, 594, 743, 550, 730, 523, 634, 110, 225, 266, 513, 291, 525, 130, 252, 328, 496, 542, 262, 115, 657, 87, 510, 846, 124, 111, 734, 774, 514, 488, 164, 540, 67, 683, 276, 312, 264, 12, 790, 809, 687, 576, 460, 208, 227, 786, 214, 689, 530, 394, 547, 237, 575, 158, 793, 589, 304, 765, 103, 637, 799, 833, 267, 796, 329, 22, 674, 570, 202, 607, 273, 719, 726, 639, 850, 409, 555, 246, 812, 849, 143, 18, 209, 39, 698, 577, 475, 255, 636, 15, 364, 485, 448, 473, 412, 697, 20, 728, 438, 578, 52, 129, 405, 610, 760, 470, 600, 268, 702, 35, 371, 421, 769, 168, 55, 653, 773, 7, 161, 810, 693, 166, 744, 385, 181, 464, 334, 616, 605, 24, 517, 841, 147, 59, 504, 524, 465, 243, 751, 457, 156, 71, 816, 74, 564, 772, 83, 265, 789, 724, 731, 384, 134, 640, 1, 584, 568, 592, 569, 381, 68, 844, 561, 794, 220, 402, 629, 33, 136, 299, 783, 98, 139, 47, 430, 325, 309, 199, 614, 27, 293, 531, 451, 459, 749, 507, 44, 388, 764, 802, 46, 176, 416, 93, 673, 382, 70, 729, 424, 803, 77, 159, 663, 292, 711, 780, 588, 355, 436, 753, 94, 184, 141, 667, 375, 705, 832, 49, 626, 138, 756, 750, 737, 449, 425, 50, 80, 229, 123, 397, 106, 75, 376, 162, 137, 472, 296, 654, 694, 585, 354, 8, 811, 178, 643, 307, 317, 571, 315, 494, 269, 666, 187, 37, 704, 230, 452, 107, 222, 191, 579, 411, 287, 819, 648, 36, 771, 357, 443, 433, 521, 0, 681, 742, 401, 118, 360, 503, 13, 339, 189, 297, 722, 374, 31, 715, 135, 277, 758, 469, 757, 685, 395, 326, 670, 532, 690, 508, 109, 801, 99, 631, 142, 281, 43, 256, 838, 258, 373, 544, 313, 347, 713, 476, 527, 604, 283, 686, 480, 539, 429, 845, 581, 538, 153, 121, 253, 63, 748, 727, 235, 160, 247, 23, 477, 278, 641, 668, 66, 586, 323, 279, 805, 363, 437, 86, 391, 444, 180, 117, 557, 691, 625, 615, 289, 190, 821, 254, 546, 808, 11, 442, 204, 738, 211, 699, 282, 826, 456, 471, 26, 551, 361, 96, 710, 735, 271, 57, 458, 29, 332, 324, 338, 716, 114, 177, 619, 741, 308, 119, 618, 642, 830, 834, 445, 345, 733, 580, 560, 479, 828, 484, 606, 441, 708, 511, 113, 498, 51, 101, 45, 340, 85, 454, 390, 649, 754, 745, 392, 133, 596, 559, 244, 746, 321, 127, 678, 206, 263, 300, 257, 368, 84, 344, 54, 183, 736 ] tr_percent = 0.8 sidx = int(len(X) * tr_percent) Xtrain = X[ridx[:sidx]][:, cam] ytrain = y[ridx[:sidx]][:, cam + [6]] Xtest = X[ridx[sidx:]][:, cam] ytest = y[ridx[sidx:]][:, cam + [6]] train_xs = Xtrain.transpose((1, 0, 2, 3, 4)).tolist() train_xs = [np.array(train_x).astype(np.float32) for train_x in train_xs] train_ys = ytrain.transpose((1, 0)).tolist() train_ys = [np.array(train_y).astype(np.int32) for train_y in train_ys] test_xs = Xtest.transpose((1, 0, 2, 3, 4)).tolist() test_xs = [np.array(test_x).astype(np.float32) for test_x in test_xs] test_ys = ytest.transpose((1, 0)).tolist() test_ys = [np.array(test_y).astype(np.int32) for test_y in test_ys] train = TupleDataset(*(train_xs + train_ys)) test = TupleDataset(*(test_xs + test_ys)) #train = permute(train) #test = permute(test) return train, test
def generate_dataset(self, ignore=["unlabelled"], args=None): crop_size = 128 data_dimensions = [crop_size, crop_size, 7] seed = 0 np.random.seed(seed) possible_groups = [['front', 'behind'], ['left', 'right'], ['above', 'below'], ["close", "far"], ["on", "off"], ['in', 'out']] object_colors = ['red', 'blue', 'yellow', 'green', 'gray'] object_sizes = ['large', 'small'] object_shapes = ['sphere', 'cube', 'cylinder', 'tray'] self.groups_rel = { i: possible_groups[i] for i in range(len(possible_groups)) } self.groups_obj = {0: object_colors, 1: object_shapes, 2: object_sizes} train = [] train_labels = [] train_vectors = [] train_masks = [] train_object_vectors = [] train_object_vector_masks = [] test = [] test_labels = [] test_vectors = [] test_masks = [] test_object_vectors = [] test_object_vector_masks = [] unseen = [] unseen_labels = [] unseen_vectors = [] unseen_masks = [] unseen_object_vectors = [] unseen_object_vector_masks = [] for folder_name in self.folder_names: folder_name_train_arr = osp.join(folder_name, "train", "arr") folder_name_train_scenes = osp.join(folder_name, "train", "scenes") array_list_train = sorted(os.listdir(folder_name_train_arr))[:] number_of_pcs = len(array_list_train) train_n = int(self.data_split * number_of_pcs) test_n = number_of_pcs - train_n train_indecies = np.random.choice(range(number_of_pcs), train_n, replace=False) test_indecies = np.array( filter(lambda x: x not in train_indecies, range(number_of_pcs))) train_files = np.take(array_list_train, train_indecies) test_files = np.take(array_list_train, test_indecies) unseen.append([]) unseen_labels.append([]) unseen_vectors.append([]) unseen_masks.append([]) unseen_object_vectors.append([]) unseen_object_vector_masks.append([]) if "train" not in ignore: for array_name in array_list_train: data = np.load(osp.join(folder_name_train_arr, array_name))['arr_0'] scene_file = open( osp.join(folder_name_train_scenes, array_name.replace('.npz', '.json')), "r") json_data = json.load(scene_file) scene_objs = json_data['objects'] rels = json_data['relationships'] if (array_list_train.index(array_name)) == 0: print("Processing FOLDER {0}".format(folder_name)) bgr = (data[..., :3] * 255).astype(np.uint8) bgr = cv2.cvtColor(bgr, cv2.COLOR_RGB2BGR) bgr = bgr / 255. depth_orig = data[..., 3] depth_orig = depth_orig / np.max(depth_orig) mask = data[..., 4:] mask = (mask * 255).astype(np.uint8) object_masks = {} obj_pixel_vals = [] big_mask_flag = False overlapping_objects = [] for i, obj in enumerate(scene_objs): mask_tmp = mask.copy() if 'mask_color' in obj: obj_pixel_val = (np.array(obj['mask_color']) * 255).astype(np.uint8) else: pixel_coords = obj['pixel_coords'][:2] pixel_coords = [ 127 if x > 127 else x for x in pixel_coords ] pixel_coords = [ 0 if x < 0 else x for x in pixel_coords ] obj_pixel_val = mask_tmp[pixel_coords[1], pixel_coords[0]] obj_pixel_vals.append(list(obj_pixel_val)) object_masks[i] = (mask_tmp == obj_pixel_val).all( axis=2).astype(np.uint8) if (np.sum(object_masks[i]) > 8000): big_mask_flag = True # x, y, width, height box = obj['bbox'] box_exp = [] offset = 2 new_x = box[0] - offset if box[0] >= offset else 0 box_exp.append(new_x) new_y = box[1] - offset if box[1] >= offset else 0 box_exp.append(new_y) new_w = box[2] + 2 * offset if new_x + box[ 2] <= 127 else 127 - new_x box_exp.append(new_w) new_h = box[3] + 2 * offset if new_y + box[ 3] <= 127 else 127 - new_y box_exp.append(new_h) obj_box = mask_tmp[box_exp[1]:box_exp[1] + box_exp[3], box_exp[0]:box_exp[0] + box_exp[2], :] bg_pixel_coords = [0, 0] bg_pixel_val = list(mask_tmp[bg_pixel_coords[1], bg_pixel_coords[0]]) tmp = np.logical_and( (obj_box != obj_pixel_val).any(axis=2), (obj_box != bg_pixel_val).any(axis=2)).astype( np.int32) if big_mask_flag: print("TOO BIG MASK; SKIP") continue mask_tmp = mask.copy() bg_pixel_coords = [0, 0] bg_pixel_val = list(mask_tmp[bg_pixel_coords[1], bg_pixel_coords[0]]) while (bg_pixel_val in obj_pixel_vals): bg_pixel_coords[0] += 1 bg_pixel_val = list(mask_tmp[bg_pixel_coords[1], bg_pixel_coords[0]]) object_masks['bg'] = (mask_tmp == bg_pixel_val).all( axis=2).astype(np.uint8) n_obj = len(scene_objs) init_rel = np.array( ['unlabelled' for _ in range(len(self.groups_rel))]) rel_index = { x: { y: init_rel.copy() for y in np.delete(np.arange(n_obj), x) } for x in np.arange(n_obj) } for rel_name, obj_list in rels.items(): for i in self.groups_rel: if rel_name in self.groups_rel[i]: group_idx = i for ref_idx, target_list in enumerate(obj_list): for target_idx in target_list: rel_index[ref_idx][target_idx][ group_idx] = rel_name for (ref_idx, target_list) in rel_index.items(): for (target_idx, rel_list) in target_list.items(): scale = 1 color = cv2.resize(bgr.copy(), (0, 0), fx=scale, fy=scale) depth = cv2.resize(depth_orig.copy(), (0, 0), fx=scale, fy=scale) bg = cv2.resize(object_masks['bg'].copy(), (0, 0), fx=scale, fy=scale) ref = cv2.resize(object_masks[ref_idx].copy(), (0, 0), fx=scale, fy=scale) ref = ref.astype(np.float32) tar = cv2.resize(object_masks[target_idx].copy(), (0, 0), fx=scale, fy=scale) tar = tar.astype(np.float32) if np.sum(tar) == 0 or np.sum(ref) == 0 or ( ref == tar).all(): continue pixels = np.concatenate( (color, depth[..., None], bg[..., None], ref[..., None], tar[..., None]), axis=2) if array_name in train_files: train += [pixels] train_labels.append(rel_list) mask = [] vector = [] for i, rel_name in enumerate(rel_list): if rel_name != "unlabelled": vector.append( self.groups_rel[i].index(rel_name)) mask.append(1) else: vector.append(0) mask.append(0) train_masks.append(mask) train_vectors.append(vector) train_object_vectors.append([]) train_object_vector_masks.append([]) for idx in [ref_idx, target_idx]: coords = scene_objs[idx]['3d_coords'] if idx not in overlapping_objects: color = scene_objs[idx]['color'] size = scene_objs[idx]['size'] shape = scene_objs[idx]['shape'] train_object_vectors[-1].append([object_colors.index(color),\ object_shapes.index(shape),\ object_sizes.index(size),\ coords[0],\ coords[1],\ coords[2]]) train_object_vector_masks[-1].append( [1, 1, 1]) else: color, size, shape = [ 'unlabelled', 'unlabelled', 'unlabelled' ] train_object_vectors[-1].append([0,\ 0,\ 0,\ coords[0],\ coords[1],\ coords[2]]) train_object_vector_masks[-1].append( [0, 0, 0]) elif array_name in test_files: test += [pixels] test_labels.append(rel_list) mask = [] vector = [] for i, rel_name in enumerate(rel_list): if rel_name != "unlabelled": vector.append( self.groups_rel[i].index(rel_name)) mask.append(1) else: vector.append(0) mask.append(0) test_masks.append(mask) test_vectors.append(vector) test_object_vectors.append([]) test_object_vector_masks.append([]) for idx in [ref_idx, target_idx]: coords = scene_objs[idx]['3d_coords'] if idx not in overlapping_objects: color = scene_objs[idx]['color'] size = scene_objs[idx]['size'] shape = scene_objs[idx]['shape'] test_object_vectors[-1].append([object_colors.index(color),\ object_shapes.index(shape),\ object_sizes.index(size),\ coords[0],\ coords[1],\ coords[2]]) test_object_vector_masks[-1].append( [1, 1, 1]) else: color, size, shape = [ 'unlabelled', 'unlabelled', 'unlabelled' ] test_object_vectors[-1].append([0,\ 0,\ 0,\ coords[0],\ coords[1],\ coords[2]]) test_object_vector_masks[-1].append( [0, 0, 0]) if "unlabelled" not in ignore: array_list = sorted(os.listdir(folder_name_train_arr))[:] for array_name in array_list: data = np.load(osp.join(folder_name_train_arr, array_name))['arr_0'] scene_file = open( osp.join(folder_name_train_scenes, array_name.replace('.npz', '.json')), "r") json_data = json.load(scene_file) scene_objs = json_data['objects'] rels = json_data['relationships'] bgr = (data[..., :3] * 255).astype(np.uint8) bgr = cv2.cvtColor(bgr, cv2.COLOR_RGB2BGR) bgr = bgr / 255. depth_orig = data[..., 3] depth_orig = depth_orig / np.max(depth_orig) mask = data[..., 4:] mask = (mask * 255).astype(np.uint8) object_masks = {} obj_pixel_vals = [] bad_mask_flag = False for i, obj in enumerate(scene_objs): if 'mask_color' in obj: obj_pixel_val = obj['mask_color'] else: mask_tmp = mask.copy() pixel_coords = obj['pixel_coords'][:2] pixel_coords = [ 127 if x > 127 else x for x in pixel_coords ] pixel_coords = [ 0 if x < 0 else x for x in pixel_coords ] obj_pixel_val = mask_tmp[pixel_coords[1], pixel_coords[0]] obj_pixel_vals.append(list(obj_pixel_val)) object_masks[i] = (mask_tmp == obj_pixel_val).all( axis=2).astype(np.uint8) if (np.sum(object_masks[i]) > 8000): bad_mask_flag = True if bad_mask_flag: print("BAD MASKING; SKIP") continue mask_tmp = mask.copy() bg_pixel_coords = [0, 0] bg_pixel_val = list(mask_tmp[bg_pixel_coords[1], bg_pixel_coords[0]]) while (bg_pixel_val in obj_pixel_vals): bg_pixel_coords[0] += 1 bg_pixel_val = list(mask_tmp[bg_pixel_coords[1], bg_pixel_coords[0]]) object_masks['bg'] = (mask_tmp == bg_pixel_val).all( axis=2).astype(np.uint8) n_obj = len(scene_objs) init_rel = np.array( ['unlabelled' for _ in range(len(self.groups_rel))]) rel_index = { x: { y: init_rel.copy() for y in np.delete(np.arange(n_obj), x) } for x in np.arange(n_obj) } for rel_name, obj_list in rels.items(): for i in self.groups_rel: if rel_name in self.groups_rel[i]: group_idx = i for ref_idx, target_list in enumerate(obj_list): for target_idx in target_list: rel_index[ref_idx][target_idx][ group_idx] = rel_name for (ref_idx, target_list) in rel_index.items(): for (target_idx, rel_list) in target_list.items(): scale = 1 color = cv2.resize(bgr.copy(), (0, 0), fx=scale, fy=scale) depth = cv2.resize(depth_orig.copy(), (0, 0), fx=scale, fy=scale) bg = cv2.resize(object_masks['bg'].copy(), (0, 0), fx=scale, fy=scale) ref = cv2.resize(object_masks[ref_idx].copy(), (0, 0), fx=scale, fy=scale) ref = ref.astype(np.float32) tar = cv2.resize(object_masks[target_idx].copy(), (0, 0), fx=scale, fy=scale) tar = tar.astype(np.float32) pixels = np.concatenate( (color, depth[..., None], bg[..., None], ref[..., None], tar[..., None]), axis=2) unseen[-1] += [pixels] unseen_labels[-1].append(rel_list) mask = [] vector = [] for i, rel_name in enumerate(rel_list): if rel_name != "unlabelled": vector.append( self.groups_rel[i].index(rel_name)) mask.append(1) else: vector.append(0) mask.append(0) unseen_masks[-1].append(mask) unseen_vectors[-1].append(vector) unseen_object_vectors[-1].append([]) unseen_object_vector_masks[-1].append([]) for idx in [ref_idx, target_idx]: color = scene_objs[idx]['color'] size = scene_objs[idx]['size'] shape = scene_objs[idx]['shape'] coords = scene_objs[idx]['3d_coords'] unseen_object_vectors[-1][-1].append([object_colors.index(color),\ object_shapes.index(shape),\ object_sizes.index(size),\ coords[0],\ coords[1],\ coords[2]]) unseen_object_vector_masks[-1][-1].append( [1, 1, 1]) train = np.array(train, dtype=np.float32) train_labels = np.array(train_labels) train_vectors = np.array(train_vectors) train_masks = np.array(train_masks) train_object_vectors = np.array(train_object_vectors) train_object_vector_masks = np.array(train_object_vector_masks) test = np.array(test, dtype=np.float32) test_labels = np.array(test_labels) test_vectors = np.array(test_vectors) test_masks = np.array(test_masks) test_object_vectors = np.array(test_object_vectors) test_object_vector_masks = np.array(test_object_vector_masks) unseen = np.array(unseen, dtype=np.float32) unseen_labels = np.array(unseen_labels) unseen_vectors = np.array(unseen_vectors) unseen_masks = np.array(unseen_masks) unseen_object_vectors = np.array(unseen_object_vectors) unseen_object_vector_masks = np.array(unseen_object_vector_masks) train = train.reshape([len(train)] + data_dimensions) test = test.reshape([len(test)] + data_dimensions) train = np.swapaxes(train, 1, 3) test = np.swapaxes(test, 1, 3) if unseen != []: unseen = np.swapaxes(unseen, 2, 4) train_concat = TupleDataset(train, train_vectors, train_masks, \ train_object_vectors, train_object_vector_masks) test_concat = TupleDataset(test, test_vectors, test_masks, \ test_object_vectors, test_object_vector_masks) unseen_concat = TupleDataset(unseen, unseen_vectors, unseen_masks, \ unseen_object_vectors, unseen_object_vector_masks) result = [] result.append(train) result.append(train_labels) result.append(train_concat) result.append(train_vectors) result.append(test) result.append(test_labels) result.append(test_concat) result.append(test_vectors) result.append(unseen) result.append(unseen_labels) result.append(unseen_concat) result.append(unseen_vectors) result.append(self.groups_obj) result.append(self.groups_rel) return result
count = len(index_iterator.index_list) rate = count / len(self.dataset) status = 'ignored' if label in self.ignore_labels else 'included' print('{:>8} {:>8} {:>8.4f} {:>10}'.format(label, count, rate, status)) if __name__ == '__main__': x = numpy.arange(100) + 1 # x = numpy.arange(10) + 1 t = numpy.log10(x).astype(numpy.int32) print('x', x, 't', t) # print(numpy.tile(x, 0)) # print(numpy.tile(x, 1)) # print(numpy.tile(x, 2)) import chainerex from chainer.datasets import TupleDataset # iterator = BalancedSerialIterator(TupleDataset(x, t), 16, labels=t) iterator = BalancedSerialIterator(TupleDataset(x, t), 16, labels=t, ignore_labels=1) print(iterator.N_augmented) a = iterator.next() print(a) a = iterator.next() print(a) iterator.show_label_stats()
def main(): gpu, out = -1, "result" stepsize = 0.001 batchsize, epoch = 10000, 10 beta, gamma = 0., 1. data_id, prior = 0, .5 n_p, n_n, n_u, n_t, n_vp, n_vn, n_vu = 100, 0, 10000, 100, 20, 20, 100 data_name, x_p, x_n, x_u, y_u, x_t, y_t, x_vp, x_vn, x_vu, y_vu \ = load_dataset(data_id, n_p, n_n, n_u, prior, n_t, n_vp=n_vp, n_vn=n_vn, n_vu=n_vu) x_p, x_n, x_u, x_t, x_vp, x_vn, x_vu = x_p.astype(np.float32), x_n.astype(np.float32), \ x_u.astype(np.float32), x_t.astype(np.float32), x_vp.astype(np.float32), \ x_vn.astype(np.float32), x_vu.astype(np.float32), XYtrain = TupleDataset( np.r_[x_p, x_u], np.r_[np.ones(100), np.zeros(10000)].astype(np.int32)) XYtest = TupleDataset(np.r_[x_vp, x_vu], np.r_[np.ones(20), np.zeros(100)].astype(np.int32)) train_iter = chainer.iterators.SerialIterator(XYtrain, batchsize) test_iter = chainer.iterators.SerialIterator(XYtest, batchsize, repeat=False, shuffle=False) loss_type = lambda x: F.sigmoid(-x) nnpu_risk = PU_Risk(prior, loss=loss_type, nnPU=True, gamma=gamma, beta=beta) pu_acc = PU_Accuracy(prior) model = L.Classifier(MLP(), lossfun=nnpu_risk, accfun=pu_acc) if gpu >= 0: chainer.backends.cuda.get_device_from_id(gpu).use() model.to_gpu(gpu) optimizer = chainer.optimizers.Adam(alpha=stepsize) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(0.005)) updater = chainer.training.StandardUpdater(train_iter, optimizer, device=gpu) trainer = chainer.training.Trainer(updater, (epoch, 'epoch'), out=out) trainer.extend(extensions.LogReport(trigger=(1, 'epoch'))) trainer.extend(extensions.Evaluator(test_iter, model, device=gpu)) trainer.extend(extensions.ProgressBar()) trainer.extend( extensions.PrintReport([ 'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time' ])) key = 'validation/main/accuracy' model_name = 'model' trainer.extend(extensions.snapshot_object(model, model_name), trigger=chainer.training.triggers.MaxValueTrigger(key)) if extensions.PlotReport.available(): trainer.extend( extensions.PlotReport(['main/loss', 'validation/main/loss'], 'epoch', file_name=f'loss_curve.png')) trainer.extend( extensions.PlotReport( ['main/accuracy', 'validation/main/accuracy'], 'epoch', file_name=f'accuracy_curve.png')) trainer.run() yh = pred(model, x_t, batchsize, gpu) mr = prior * np.mean(yh[y_t == +1] <= 0) + (1 - prior) * np.mean( yh[y_t == -1] >= 0) print("mr: {}".format(mr))
def get_mnist(n_train=100, n_test=100, n_dim=1, with_label=True, classes=None): """ :param n_train: nr of training examples per class :param n_test: nr of test examples per class :param n_dim: 1 or 3 (for convolutional input) :param with_label: whether or not to also provide labels :param classes: if not None, then it selects only those classes, e.g. [0, 1] :return: """ train_data, test_data = chainer.datasets.get_mnist(ndim=n_dim, withlabel=with_label) if not classes: classes = np.arange(10) n_classes = len(classes) if with_label: for d in range(2): if d == 0: data = train_data._datasets[0] labels = train_data._datasets[1] n = n_train else: data = test_data._datasets[0] labels = test_data._datasets[1] n = n_test for i in range(n_classes): lidx = np.where(labels == classes[i])[0][:n] if i == 0: idx = lidx else: idx = np.hstack([idx, lidx]) L = np.concatenate([i * np.ones(n) for i in np.arange(n_classes)]).astype('int32') if d == 0: train_data = TupleDataset(data[idx], L) else: test_data = TupleDataset(data[idx], L) else: tmp1, tmp2 = chainer.datasets.get_mnist(ndim=n_dim, withlabel=True) for d in range(2): if d == 0: data = train_data labels = tmp1._datasets[1] n = n_train else: data = test_data labels = tmp2._datasets[1] n = n_test for i in range(n_classes): lidx = np.where(labels == classes[i])[0][:n] if i == 0: idx = lidx else: idx = np.hstack([idx, lidx]) if d == 0: train_data = data[idx] else: test_data = data[idx] return train_data, test_data, n_dim
def setup(): # 設定ファイルの読み込み with open(CONFIG_FILE, "r") as f: config = yaml.load(f) xp = np if not config["use_gpu"] else cuda.cupy # 学習結果出力先の設定 restart = config["restart_dir"] is not None if restart: result_children_dir = config["restart_dir"] else: result_children_dir = "result_" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") result_dir = os.path.join(config["result_dir"], result_children_dir) result_dir_train = os.path.join(result_dir, MODEL_DIR) result_dir_val = os.path.join(result_dir, VALIDATE_DIR) # 学習データの読み込み train_scores = [] with open(os.path.join(config["score_dir"], config["train_list"]), "r") as tr_f: train_info = list(map(lambda x: x.split("\n")[0], tr_f.readlines())) train_paths = list(map(lambda x: os.path.join(config["score_dir"], x.split("\t")[0]), train_info)) train_score_lvs = list(map(lambda x: int(x.split("\t")[1])-1, train_info)) for idx, npy_path in enumerate(train_paths): score = xp.load(npy_path) score[:, 8] /= 100.0 # 譜面を小節ごとに区切る score = score.reshape((-1, 1728)) train_scores.append(score) sys.stdout.write("\rtrain score loaded: {0:4d}/{1}".format(idx+1, len(train_paths))) sys.stdout.write("\n") # 検証データの読み込み val_scores = [] val_score_names = [] with open(os.path.join(config["score_dir"], config["validate_list"]), "r") as val_f: val_info = list(map(lambda x: x.split("\n")[0], val_f.readlines())) val_paths = list(map(lambda x: os.path.join(config["score_dir"], x.split("\t")[0]), val_info)) val_score_lvs = list(map(lambda x: int(x.split("\t")[1])-1, val_info)) for idx, npy_path in enumerate(val_paths): score = xp.load(npy_path) score[:, 8] /= 100.0 # 譜面を小節ごとに区切る score = score.reshape((-1, 1728)) val_scores.append(score) score_name = os.path.basename(npy_path) val_score_names.append(score_name) sys.stdout.write("\rvalidate score loaded: {0:4d}/{1}".format(idx+1, len(val_paths))) sys.stdout.write("\n") # model and optimizer model = Estimator() if xp is not np: model.to_device("@cupy:0") optimizer = Adam(float(config["lr"])) optimizer.setup(model) # iterator, updater, trainer, extension train_dataset = TupleDataset(train_scores, train_score_lvs) train_iterator = SerialIterator(train_dataset, int(config["batch_size"])) val_dataset = TupleDataset(val_scores, val_score_lvs, val_score_names) val_iterator = SerialIterator(val_dataset, int(config["batch_size"]), repeat=False, shuffle=False) updater = EstimatorUpdater(iterator=train_iterator, optimizer=optimizer) trainer = Trainer(updater, stop_trigger=(config["epochs"], "epoch"), out=result_dir_train) trainer.extend(Validator(val_iterator, result_dir_val), trigger=(1, "epoch")) trainer.extend(extensions.snapshot(filename="snapshot_epoch_{.updater.epoch}")) trainer.extend(extensions.LogReport(trigger=(1, "epoch")), trigger=(1, "epoch")) trainer.extend(extensions.PrintReport(["epoch", "train/loss", "train/acc", "val/loss", "val/acc", "val/rough_acc"])) trainer.extend(extensions.ProgressBar(update_interval=5)) if restart: # 学習を再開するモデルを特定 snapshot_path_format = os.path.join(result_dir_train, "snapshot_epoch_*") snapshots = [os.path.basename(fname) for fname in glob.glob(snapshot_path_format)] if len(snapshots) == 0: print("There does not exist a model to restart training.") exit() else: pattern = re.compile("snapshot_epoch_([0-9]+)") snapshot_epochs = list(map(lambda x: int(pattern.search(x).group(1)), snapshots)) prev_snapshot_idx = snapshot_epochs.index(max(snapshot_epochs)) prev_snapshot = snapshots[prev_snapshot_idx] load_npz(os.path.join(result_dir_train, prev_snapshot), trainer) shutil.copy2(CONFIG_FILE, result_dir) return trainer