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
