def prepare_data(args):
print("Begin loading source domain")
source = datasets.Domain(args.source)
print("Finish loading source domain")
print("Begin loading target domain")
target = datasets.Domain(args.target)
print("Finish loading target domain")
s_train = TransformDataset(source.train, utils.train_transform_office)
t_train = TransformDataset(target.train, utils.train_transform_office)
s_test = TransformDataset(source.test, utils.test_transform_office)
t_test = TransformDataset(target.test, utils.test_transform_office)
s_train = utils.data2iterator(s_train,
args.batchsize,
is_train=True,
multiprocess=args.multiprocess)
t_train = utils.data2iterator(t_train,
args.batchsize,
is_train=True,
multiprocess=args.multiprocess)
s_test = utils.data2iterator(s_test,
args.batchsize,
is_train=False,
multiprocess=args.multiprocess)
t_test = utils.data2iterator(t_test,
args.batchsize,
is_train=False,
multiprocess=args.multiprocess)
return s_train, t_train, s_test, t_test
def split_dataset(fnamesp, fnamesn, index_labelsp, index_labelsn):
permp = np.random.permutation(len(fnamesp))
permn = np.random.permutation(len(fnamesn))
split_p = np.split(np.array(fnamesp)[permp], 2)
t_indexp = np.split(np.array(index_labelsp)[permp], 2)
split_n = np.split(np.array(fnamesn)[permn], [int(len(fnamesn) / 2)])
t_indexn = np.split(
np.array(index_labelsn)[permn], [int(len(fnamesn) / 2)])
permt = np.random.permutation(
len(split_p[0][:9500]) + len(split_n[0][:15000]))
permv = np.random.permutation(len(split_p[1]) + len(split_n[1]))
d1 = LabeledImageDataset(
list(
zip(list(np.r_[split_p[0][:9500], split_n[0][:15000]][permt]),
list(np.r_[t_indexp[0][:9500], t_indexn[0][:15000]][permt]))))
d2 = LabeledImageDataset(
list(
zip(list(np.r_[split_p[1], split_n[1]][permv]),
list(np.r_[t_indexp[1], t_indexn[1]][permv]))))
train = TransformDataset(d1, transform)
valid = TransformDataset(d2, transform)
return train, valid
def create_iterator(train, valid, mean, std, pca_sigma, random_angle,
x_random_flip, y_random_flip, expand_ratio,
random_crop_size, random_erase, output_size, batchsize,
transform_fun):
transform_train = partial(transform_fun,
mean=mean,
std=std,
pca_sigma=pca_sigma,
random_angle=random_angle,
x_random_flip=x_random_flip,
y_random_flip=y_random_flip,
expand_ratio=expand_ratio,
random_crop_size=random_crop_size,
random_erase=random_erase,
output_size=output_size,
train=True)
transform_valid = partial(transform_fun,
mean=mean,
std=std,
output_size=output_size,
random_crop_size=random_crop_size)
processed_train = TransformDataset(train, transform_train)
processed_valid = TransformDataset(valid, transform_valid)
train_iter = iterators.SerialIterator(processed_train, batchsize)
valid_iter = iterators.SerialIterator(processed_valid,
batchsize,
repeat=False,
shuffle=False)
return train_iter, valid_iter
def train(network_object, dataset, batchsize=128, gpu_id=0, max_epoch=20, postfix='', base_lr=0.01, lr_decay=None):
# prepare dataset
train_size = int(len(dataset) * 0.9)
train_val, test = chainer.datasets.split_dataset_random(Honkan_dataset, train_size, seed=0)
train_size = int(len(train_val) * 0.9)
train, valid = chainer.datasets.split_dataset_random(train_val, train_size, seed=0)
# data augement
train_dataset = TransformDataset(train, partial(transform, train=True))
valid_dataset = TransformDataset(valid, partial(transform, train=False))
test_dataset = TransformDataset(test, partial(transform, train=False))
# 2. Iterator
train_iter = iterators.SerialIterator(train, batchsize)
#train_iter = iterators.MultiprocessIterator(train, batchsize)
valid_iter = iterators.SerialIterator(valid, batchsize, False, False)
#valid_iter = iterators.MultiprocessIterator(valid, batchsize, False, False)
# 3. Model
net = L.Classifier(network_object)
# 4. Optimizer
optimizer = optimizers.MomentumSGD(lr=base_lr).setup(net)
#optimizer = optimizers.Adam().setup(net)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0005))
# 5. Updater
updater = training.StandardUpdater(train_iter, optimizer, device=gpu_id)
# 6. Trainer
trainer = training.Trainer(updater, (max_epoch, 'epoch'), out='{}_HonkanEntrance3_NewSize_{}result'.format(network_object.__class__.__name__, postfix))
# 7. Trainer extensions
trainer.extend(extensions.LogReport())
trainer.extend(extensions.snapshot(filename='snapshot_epoch-{.updater.epoch}'))
trainer.extend(extensions.Evaluator(valid_iter, net, device=gpu_id), name='val')
trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'main/accuracy', 'val/main/loss', 'val/main/accuracy', 'l1/W/data/std', 'elapsed_time']))
trainer.extend(extensions.PlotReport(['l1/W/data/std'], x_key='epoch', file_name='std.png'))
trainer.extend(extensions.PlotReport(['main/loss', 'val/main/loss'], x_key='epoch', file_name='loss.png'))
trainer.extend(extensions.PlotReport(['main/accuracy', 'val/main/accuracy'], x_key='epoch', file_name='accuracy.png'))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.ProgressBar())
if lr_decay is not None:
trainer.extend(extensions.ExponentialShift('lr', 0.1), trigger=lr_decay)
trainer.run()
del trainer
# 8. Evaluation
test_iter = iterators.SerialIterator(test, batchsize, False, False)
#test_iter = iterators.MultiprocessIterator(test, batchsize, False, False)
test_evaluator = extensions.Evaluator(test_iter, net, device=gpu_id)
results = test_evaluator()
print('Test accuracy:', results['main/accuracy'])
return net
def get_mnist_vae():
train, test = mnist.get_mnist(withlabel=False)
val = train[50000:60000]
train = train[0:50000]
train = TransformDataset(train, mnist_transform)
val = TransformDataset(val, mnist_transform)
test = TransformDataset(test, mnist_transform)
return train, val, test
def evaluate(model, dataset, hand_param, debug):
transformed_dataset = TransformDataset(dataset, model.encode)
avg_distances = []
max_distances = []
length = len(transformed_dataset) if not debug else 10
for idx in tqdm.tqdm(range(length)):
image, gt_2dj, gt_3dj = transformed_dataset.get_example(idx)
example = dataset.get_example(idx)
pred_j = model.predict(np.array([image], dtype=np.float32))
with chainer.using_config('train', False):
loss = model.forward(
np.expand_dims(image, axis=0),
np.expand_dims(gt_3dj, axis=0),
np.expand_dims(gt_2dj, axis=0),
)
pred_j = pred_j.array.reshape(hand_param["n_joints"], -1)
dim = pred_j.shape[-1]
if dim == 5:
pred_3d = pred_j[:, :3]
pred_2d = pred_j[:, 3:]
else:
pred_3d = pred_j
logger.debug("> {}".format(pred_j))
logger.debug("> loss {}".format(loss))
logger.debug("> visualize pred_joint")
z_half = hand_param["cube"][0] / 2
pred_3d = z_half * pred_3d
gt_3dj = example["rgb_joint"] if hand_param["use_rgb"] else example[
"depth_joint"]
gt_3dj = gt_3dj - calc_com(gt_3dj)
dist = np.sqrt(np.sum(np.square(pred_3d - gt_3dj), axis=1))
avg_dist = np.mean(dist)
max_dist = np.max(dist)
avg_distances.append(avg_dist)
max_distances.append(max_dist)
print(np.array(avg_distances).mean())
max_distances = np.array(max_distances)
ps = []
max_threshold = 80
for threshold in range(3, max_threshold):
oks = np.sum(max_distances <= threshold)
percent = 100 * (oks / len(max_distances))
ps.append(percent)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_xlabel("Distance threshold / mm")
ax.set_ylabel("Fraction of frames iwth mean below distance / %")
ax.set_ylim(0, 100)
ax.set_xlim(0, max_threshold)
ax.plot(ps)
ax.grid(True, linestyle="--")
plt.savefig("plot.png")
def load_dataset(name, dtype='train'):
if name == 'mnist':
train, _ = chainer.datasets.get_mnist(withlabel=True, ndim=3)
dataset = TransformDataset(train, transform=gray2rgb)
return TransformDataset(dataset, transform=scale)
elif name == 'mnist_m':
dataset = get_mnist_m(dtype, withlabel=True)
return TransformDataset(dataset, transform=scale)
else:
raise NotImplementedError
def setup_iterator(self):
train_dataset_transformed = TransformDataset(
self.train_dataset, self.transform_dataset)
val_dataset_transformed = TransformDataset(
self.val_dataset, self.transform_dataset)
self.train_iterator = chainer.iterators.MultiprocessIterator(
train_dataset_transformed, batch_size=self.batch_size,
shared_mem=10 ** 7)
self.val_iterator = chainer.iterators.MultiprocessIterator(
val_dataset_transformed, batch_size=self.batch_size,
shared_mem=10 ** 7, repeat=False, shuffle=False)
def mnist():
target_train, target_test = chainer.datasets.get_mnist(ndim=3,
rgb_format=True)
def transform(in_data):
img, label = in_data
img = resize(img, (32, 32))
return img, label
source_ = TransformDataset(target_train, transform)
source_train = TransformDataset(target_test, transform)
labels = []
images = []
for i in range(10000):
print(i)
image = source_train[i][0]
label = source_train[i][1]
if label >= 5:
image = np.transpose(image, [1, 2, 0])
images.append(image.astype(np.float32))
labels.append(label - 5)
images = np.array(images).astype(np.float32)
labels = np.squeeze(np.array(labels)).astype(np.int32)
print(labels[4])
print(images[4])
print(labels.shape)
print(images.shape)
print(labels[330])
PIL.Image.fromarray((images[330] * 256).astype(np.int8), 'RGB').show()
np.save('mnist_rgb_images_test', images)
np.save('mnist_rgb_labels_test', labels)
lb = sklearn.preprocessing.LabelBinarizer().fit([0, 1, 2, 3, 4])
labels = lb.transform(labels).astype(np.float32)
np.save('mnist_rgb_labels_onehot_test', labels)
def setup_iterator(self):
train_dataset_transformed = TransformDataset(
self.train_dataset, cmr.datasets.MaskRCNNTransform(self.mask_rcnn))
val_dataset_transformed = TransformDataset(
self.val_dataset,
cmr.datasets.MaskRCNNTransform(self.mask_rcnn, train=False))
# FIXME: MultiProcessIterator sometimes hangs
self.train_iterator = chainer.iterators.SerialIterator(
train_dataset_transformed, batch_size=self.batch_size)
self.val_iterator = chainer.iterators.SerialIterator(
val_dataset_transformed, batch_size=self.batch_size,
repeat=False, shuffle=False)
def prepare_dataset(full_data=False):
train_split = 'trainval' if full_data else 'train'
train = TransformDataset(KuzushijiRecognitionDataset(split=train_split),
Preprocessor(augmentation=True))
val_raw = split_dataset_random(KuzushijiRecognitionDataset('val'),
first_size=16 * 10,
seed=0)[0]
val = TransformDataset(val_raw, Preprocessor(augmentation=False))
return train, val, val_raw
def run(batch_size, n_process, prefetch,
model_name, exits_bn, activation_function, number_filter_list,
gpu_id, lossfun, learning_rate, max_epoch, out_dir, epoch):
train, test = get_image()
train = TransformDataset(train, trans)
test = TransformDataset(test, trans)
train_iter = iterators.MultiprocessIterator(train, batch_size, True, True, n_process, prefetch)
test_iter = iterators.MultiprocessIterator(test, batch_size, False, False, n_process, prefetch)
model = model_name(exits_bn, activation_function, number_filter_list)
if gpu_id >= 0:
model.to_gpu(gpu_id)
# Wrap your model by Classifier and include the process of loss calculation within your model.
# Since we do not specify a loss function here, the default 'softmax_cross_entropy' is used.
model = links.Loss_Classifier(model, lossfun)
# selection of your optimizing method
optimizer = optimizers.MomentumSGD(lr=learning_rate, momentum=0.9)
# Give the optimizer a reference to the model
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0005))
# Get an updater that uses the Iterator and Optimizer
updater = training.updaters.StandardUpdater(train_iter, optimizer, device=gpu_id)
# Setup a Trainer
trainer = training.Trainer(updater, (max_epoch, 'epoch'), out='{}'.format(out_dir))
from chainer.training import extensions
trainer.extend(extensions.LogReport()) # generate report
trainer.extend(extensions.snapshot(filename='snapshot_epoch-{.updater.epoch}')) # save updater
trainer.extend(extensions.snapshot_object(model.predictor, filename='model_epoch-{.updater.epoch}')) # save model
trainer.extend(extensions.Evaluator(test_iter, model, device=gpu_id)) # validation
trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'main/accuracy', 'validation/main/loss', 'validation/main/accuracy', 'elapsed_time'])) # show loss and accuracy
trainer.extend(extensions.ProgressBar()) # show trainning progress
trainer.extend(extensions.PlotReport(['main/loss', 'validation/main/loss'], x_key='epoch', file_name='loss.png')) # loss curve
trainer.extend(extensions.PlotReport(['main/accuracy', 'validation/main/accuracy'], x_key='epoch', file_name='accuracy.png')) # accuracy curve
trainer.extend(extensions.dump_graph('main/loss'))
if epoch > 0:
serializers.load_npz('./{}/snapshot_epoch-{}'.format(out_dir, epoch), trainer)
trainer.updater.get_optimizer('main').lr = learning_rate
trainer.run()
def prepare_dataset(image_size=(64, 64), full_data=False):
train_split = 'trainval' if full_data else 'train'
train = TransformDataset(
RandomSampler(KuzushijiCharCropDataset(split=train_split),
virtual_size=20000),
Preprocess(image_size=image_size, augmentation=True))
val = TransformDataset(
split_dataset_random(KuzushijiCharCropDataset(split='val'),
first_size=5000,
seed=0)[0],
Preprocess(image_size=image_size, augmentation=False))
return train, val
def train_yolov2():
"""Training yolov2."""
config = parse_args()
model = get_model(config["model"])
devices = parse_devices(config['gpus'], config['updater']['name'])
train_data, test_data = load_dataset(config["dataset"])
Transform = Transform_v2 if parse_dict(config, 'version',
'2') == '2' else Transform_v3
train_data = TransformDataset(
train_data,
Transform(0.5,
dim=model.dim,
max_target=30,
anchors=model.anchors,
batchsize=config['iterator']['train_batchsize']))
train_iter, test_iter = create_iterator(train_data, test_data,
config['iterator'], devices,
config['updater']['name'])
optimizer = create_optimizer(config['optimizer'], model)
updater = create_updater(train_iter, optimizer, config['updater'], devices)
trainer = training.Trainer(updater,
config['end_trigger'],
out=config['results'])
trainer = create_extension(trainer,
test_iter,
model,
config['extension'],
devices=devices)
trainer.run()
chainer.serializers.save_npz(os.path.join(config['results'], 'model.npz'),
model)
def transform_dataset(dataset, model, train):
if train:
transform = Compose(
RGBAugmentation(["rgb"]),
Affine(
rgb_indices=["rgb"],
mask_indices=["masks"],
bbox_indices=["bboxes"],
),
ClassIds2FGClassIds(["labels"]),
AsType(["rgb", "labels", "bboxes"],
[np.float32, np.int32, np.float32]),
HWC2CHW(["rgb"]),
Dict2Tuple(["rgb", "masks", "labels", "bboxes"]),
MaskRCNNTransform(800, 1333, model.extractor.mean),
)
else:
transform = Compose(
ClassIds2FGClassIds(["labels"]),
AsType(["rgb", "labels", "bboxes"],
[np.float32, np.int32, np.float32]),
HWC2CHW(["rgb"]),
Dict2Tuple(["rgb", "masks", "labels"]),
)
return TransformDataset(dataset, transform)
def load_mnist():
"""Load MNSIT handwritten digit images in 32x32.
Return:
train dataset, test dataset
in [n, c, h, w] format.
"""
train, test = chainer.datasets.get_mnist(ndim=3, rgb_format=False)
def transform(data):
img, label = data
img = resize(img, [32, 32])
return img, label
train = TransformDataset(train, transform)
test = TransformDataset(test, transform)
return train, test
def visualize_dataset(config):
from matplotlib import pyplot as plt
dataset = select_dataset(config, return_data=["train_set"])
hand_class = config.get('model_param', 'hand_class').split(",")
hand_class = [k.strip() for k in hand_class]
class_converter, flip_converter = create_converter(hand_class)
logger.info("hand_class = {}".format(hand_class))
logger.info("done get dataset")
idx = random.randint(0, len(dataset) - 1)
logger.info("get example")
rgb, rgb_bbox, rgb_class = dataset.get_example(idx)
logger.info("Done get example")
fig = plt.figure(figsize=(5, 10))
ax1 = fig.add_subplot(211)
ax2 = fig.add_subplot(212)
label = rgb_class
class_converter = {v: k for k, v in class_converter.items()}
color = [COLOR_MAP[class_converter[c]] for c in label]
print(label)
vis_bbox(
rgb,
rgb_bbox,
instance_colors=color,
label=label,
label_names=hand_class,
ax=ax1,
)
model = create_ssd_model()
transform_dataset = TransformDataset(
dataset, Transform(model.coder, model.insize, model.mean, train=True))
img, mb_loc, mb_label = transform_dataset.get_example(idx)
mb_color = [COLOR_MAP[class_converter[c]] for c in mb_label]
vis_bbox(
img,
mb_loc,
instance_colors=mb_color,
label=mb_label,
label_names=hand_class,
ax=ax2,
)
plt.savefig("vis.png")
plt.show()
def transform(self, x):
dataset = LabeledImageDataset(x)
def normarize(in_data):
img, label = in_data
img = img / .255
return img, label
return TransformDataset(dataset, normarize)
def transform(self, x):
dataset = LabeledImageDataset(x)
def augumentaion(in_data):
img, label = in_data
img = self._image_process(img)
return img, label
return TransformDataset(dataset, augumentaion)
def load_svhn():
"""Load grayscaled SVHN digit images.
Return:
train dataset, test dataset
in [n, c, h, w] format.
"""
train, test = chainer.datasets.get_svhn()
def transform(data):
img, label = data
img = img[0] * 0.2989 + img[1] * 0.5870 + img[2] * 0.1140
img = img.reshape(1, 32, 32)
return img, label
train = TransformDataset(train, transform)
test = TransformDataset(test, transform)
return train, test
def transform(self, x):
dataset = LabeledImageDataset(x)
def normarize(in_data):
img, label = in_data
img = chainer.links.model.vision.vgg.prepare(img)
return img, label
return TransformDataset(dataset, normarize)
def transform(self, x):
dataset = LabeledImageDataset(x)
def normarize(in_data):
img, label = in_data
img = img / 255
img = resize(img, (224, 224))
return img, label
return TransformDataset(dataset, normarize)
def main():
root_dir = 'dataset directory'
train, val = dataset.get_mscoco(root_dir)
vocab_size = len(train.vocab)
batch_size = 10
vggenc = model.VGGEncoder()
vggenc.to_gpu()
def transform(x):
image, caption = x
image = L.model.vision.vgg.prepare(image)
return image, caption
train = TransformDataset(train, transform=transform)
val = TransformDataset(val, transform=transform)
encode(val, 'val.npy', batch_size, vggenc)
encode(train, 'train.npy', batch_size, vggenc)
def train(self, epoch_num=40, batch_size=128, gpu=-1):
train = chainer.datasets.LabeledImageDataset(
"../dataset/train/info.txt", "../dataset/train")
test = chainer.datasets.LabeledImageDataset(
"../dataset/validation/info.txt", "../dataset/validation")
model = L.Classifier(
Model(out_size=25)) # loss function, default softmax_cross_entropy
alpha = 1e-4
optimizer = optimizers.Adam(alpha=alpha)
optimizer.setup(model)
model.predictor.vgg.disable_update() # not update weight of VGG16
train = TransformDataset(train, self.transform)
test = TransformDataset(test, self.transform)
train_iter = chainer.iterators.SerialIterator(train, batch_size)
test_iter = chainer.iterators.SerialIterator(test,
batch_size,
repeat=False,
shuffle=False)
#updater = training.StandardUpdater(train_iter, optimizer, device=gpu)
updater = training.ParallelUpdater(train_iter,
optimizer,
devices=self.gpu_devices)
trainer = training.Trainer(updater, (epoch_num, 'epoch'), out='result')
trainer.extend(
extensions.Evaluator(test_iter,
model,
device=self.gpu_devices['main']))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]))
#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'))
trainer.run()
model.to_cpu()
serializers.save_npz("mymodel.npz", model)
def transform(self, x):
dataset = LabeledImageDataset(x)
def _transform(in_data):
img, label = in_data
img = random_sized_crop(img, scale_ratio_range=(0.3, 1))
img = random_flip(img, x_random=True)
img = chainer.links.model.vision.vgg.prepare(img)
return img, label
return TransformDataset(dataset, _transform)
def make_dataset(source_bpe_filename,
target_bpe_filename,
source_vocab,
target_vocab,
chunk_length=1000):
d = TextDataset(
(source_bpe_filename, target_bpe_filename),
filter_func=lambda x, y: filter_example(x, y, chunk_length - 2))
return TransformDataset(
d, TokenTransformer(source_vocab, target_vocab, chunk_length))
def load_dataset():
train = h5py.File(path.join(ROOT_PATH, 'dataset/General100_train.hdf5'))
test = h5py.File(path.join(ROOT_PATH, 'dataset/Set14_test.hdf5'))
train_x, train_y = np.array(train['x_data']) / 255, np.array(train['y_data']) /255
test_x, test_y = np.array(test['x_data']) / 255, np.array(test['y_data']) / 255
train = TupleDataset(train_x, train_y)
test = TupleDataset(test_x, test_y)
train = TransformDataset(train, transform)
return train, test
def create_iterator(train, valid, crop_size, rotate, horizontal_flip,
scale_range, batchsize):
mean = np.array((123.68, 116.779, 103.939), dtype=np.float32)[:, None,
None]
processed_train = TransformDataset(
train, Transform(mean, crop_size, rotate, horizontal_flip,
scale_range))
train_iter = iterators.SerialIterator(processed_train, batchsize)
valid_iter = iterators.SerialIterator(valid,
batchsize,
repeat=False,
shuffle=False)
return train_iter, valid_iter
def main(args):
logging.basicConfig(level=logging.INFO)
config = configparser.ConfigParser()
config_path = os.path.join(args.trained, "pose", "config.ini")
if not os.path.exists(config_path):
raise Exception("config_path {} does not found".format(config_path))
logger.info("read {}".format(config_path))
config.read(config_path, 'UTF-8')
logger.info("setup devices")
chainer.global_config.autotune = True
chainer.config.cudnn_fast_batch_normalization = True
logger.info("> get dataset {}".format(args.mode))
mode_dict = {
"train": "train_set",
"val": "val_set",
"test": "test_set",
}
return_type = mode_dict[args.mode]
dataset, hand_param = select_dataset(config, [return_type, "hand_param"])
logger.info("> hand_param = {}".format(hand_param))
model = select_model(config, hand_param)
transformed_dataset = TransformDataset(dataset, model.encode)
logger.info("> size of dataset is {}".format(len(dataset)))
model_path = os.path.expanduser(
os.path.join(args.trained, "pose", "bestmodel.npz"))
logger.info("> restore model")
logger.info("> model.device = {}".format(model.device))
chainer.serializers.load_npz(model_path, model)
if config["model"]["name"] in ["ppn", "ppn_edge"]:
if args.evaluate:
evaluate_ppn(model, dataset, hand_param)
else:
predict_ppn(model, dataset, hand_param)
elif config["model"]["name"] in ["rhd", "hm", "orinet"]:
predict_heatmap(model, dataset, hand_param)
elif config["model"]["name"] == "ganerated":
predict_ganerated(model, dataset, hand_param)
else:
predict_sample(model, dataset, hand_param)
## read data
data_orig = mydata.read()
win_total = 0
draw_total = 0
lose_total = 0
for year in xrange(1996, 2019):
## network setup
net = mymodel.create()
chainer.serializers.load_npz("models/{0}.npz".format(year), net)
# 前年までのデータで学習したモデルで、1年分のデータを予測
data = data_orig[data_orig[:, 0] == year]
inputs = TransformDataset(data, mymodel.transform)
win = 0
draw = 0
lose = 0
for testcase in inputs:
detected = net.predictor(testcase[0].reshape((1,-1))).data.argmax(axis=1)[0]
# 相手が最も出す確率の高い手に勝つように出す
mychoice = (detected + 2) % 3 # 0: G, 1: C, 2: P
schoice = testcase[1]
if (mychoice + 3 - schoice) % 3 == 0:
draw += 1
elif (mychoice + 3 - schoice) % 3 == 1:
lose += 1
else:
win += 1
