def __init__(self, pretrained_model, n_layers): super(ResNetLayers, self).__init__() if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. kwargs = {'initialW': constant.Zero()} else: # employ default initializers used in the original paper kwargs = {'initialW': normal.HeNormal(scale=1.0)} if n_layers == 50: block = [3, 4, 6, 3] elif n_layers == 101: block = [3, 4, 23, 3] elif n_layers == 152: block = [3, 8, 36, 3] else: raise ValueError('The n_layers argument should be either 50, 101,' ' or 152, but {} was given.'.format(n_layers)) with self.init_scope(): self.conv1 = Convolution2D(3, 64, 7, 2, 3, **kwargs) self.bn1 = BatchNormalization(64) self.res2 = BuildingBlock(block[0], 64, 64, 256, 1, **kwargs) self.res3 = BuildingBlock(block[1], 256, 128, 512, 2, **kwargs) self.res4 = BuildingBlock(block[2], 512, 256, 1024, 2, **kwargs) self.res5 = BuildingBlock(block[3], 1024, 512, 2048, 2, **kwargs) self.fc6 = Linear(2048, 1000) if pretrained_model and pretrained_model.endswith('.caffemodel'): _retrieve(n_layers, 'ResNet-{}-model.npz'.format(n_layers), pretrained_model, self) elif pretrained_model: npz.load_npz(pretrained_model, self)
def __init__(self, pretrained_model='auto'): if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. kwargs = {'initialW': constant.Zero()} else: # employ default initializers used in the original paper kwargs = {'initialW': normal.HeNormal(scale=1.0)} super(ResNet50Layers, self).__init__( conv1=Convolution2D(3, 64, 7, 2, 3, **kwargs), bn1=BatchNormalization(64), res2=BuildingBlock(3, 64, 64, 256, 1, **kwargs), res3=BuildingBlock(4, 256, 128, 512, 2, **kwargs), res4=BuildingBlock(6, 512, 256, 1024, 2, **kwargs), res5=BuildingBlock(3, 1024, 512, 2048, 2, **kwargs), fc6=Linear(2048, 1000), ) if pretrained_model == 'auto': _retrieve( 'ResNet-50-model.npz', 'ResNet-50-model.caffemodel', self) elif pretrained_model: npz.load_npz(pretrained_model, self) self.functions = OrderedDict([ ('conv1', [self.conv1, self.bn1, relu]), ('pool1', [lambda x: max_pooling_2d(x, ksize=3, stride=2)]), ('res2', [self.res2]), ('res3', [self.res3]), ('res4', [self.res4]), ('res5', [self.res5]), ('pool5', [_global_average_pooling_2d]), ('fc6', [self.fc6]), ('prob', [softmax]), ])
def test_load(self): obj = mock.MagicMock() npz.load_npz(self.temp_file_path, obj) self.assertEqual(obj.serialize.call_count, 1) (serializer,), _ = obj.serialize.call_args self.assertIsInstance(serializer, npz.NpzDeserializer)
def test_load_with_path(self): target = link.Chain() with target.init_scope(): target.child_linear = links.Linear(2, 3) npz.load_npz(self.file, target, 'child/') numpy.testing.assert_array_equal( self.source_child.child_linear.W.data, target.child_linear.W.data)
def test_load_without_path(self): target = link.Chain() with target.init_scope(): target.parent_linear = links.Linear(3, 2) npz.load_npz(self.file, target, path='') numpy.testing.assert_array_equal( self.source_parent.parent_linear.W.data, target.parent_linear.W.data)
def _make_npz(path_npz, url, model): path_caffemodel = download.cached_download(url) sys.stderr.write( 'Now loading caffemodel (usually it may take few minutes)\n') sys.stderr.flush() GoogLeNet.convert_caffemodel_to_npz(path_caffemodel, path_npz) npz.load_npz(path_npz, model) return model
def test_load_without_strict(self): obj = mock.MagicMock() npz.load_npz(self.file, obj, strict=False) self.assertEqual(obj.serialize.call_count, 1) (serializer,), _ = obj.serialize.call_args self.assertFalse(serializer.strict) self.assertIsInstance(serializer, npz.NpzDeserializer)
def __init__(self, pretrained_model='auto', n_layers=16): super(VGGLayers, self).__init__() if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. init = constant.Zero() kwargs = {'initialW': init, 'initial_bias': init} else: # employ default initializers used in the original paper kwargs = { 'initialW': normal.Normal(0.01), 'initial_bias': constant.Zero(), } if n_layers not in [16, 19]: raise ValueError( 'The n_layers argument should be either 16 or 19,' 'but {} was given.'.format(n_layers) ) with self.init_scope(): self.conv1_1 = Convolution2D(3, 64, 3, 1, 1, **kwargs) self.conv1_2 = Convolution2D(64, 64, 3, 1, 1, **kwargs) self.conv2_1 = Convolution2D(64, 128, 3, 1, 1, **kwargs) self.conv2_2 = Convolution2D(128, 128, 3, 1, 1, **kwargs) self.conv3_1 = Convolution2D(128, 256, 3, 1, 1, **kwargs) self.conv3_2 = Convolution2D(256, 256, 3, 1, 1, **kwargs) self.conv3_3 = Convolution2D(256, 256, 3, 1, 1, **kwargs) self.conv4_1 = Convolution2D(256, 512, 3, 1, 1, **kwargs) self.conv4_2 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.conv4_3 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.conv5_1 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.conv5_2 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.conv5_3 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.fc6 = Linear(512 * 7 * 7, 4096, **kwargs) self.fc7 = Linear(4096, 4096, **kwargs) self.fc8 = Linear(4096, 1000, **kwargs) if n_layers == 19: self.conv3_4 = Convolution2D(256, 256, 3, 1, 1, **kwargs) self.conv4_4 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.conv5_4 = Convolution2D(512, 512, 3, 1, 1, **kwargs) if pretrained_model == 'auto': if n_layers == 16: _retrieve( 'VGG_ILSVRC_16_layers.npz', 'https://www.robots.ox.ac.uk/%7Evgg/software/very_deep/' 'caffe/VGG_ILSVRC_16_layers.caffemodel', self) else: _retrieve( 'VGG_ILSVRC_19_layers.npz', 'http://www.robots.ox.ac.uk/%7Evgg/software/very_deep/' 'caffe/VGG_ILSVRC_19_layers.caffemodel', self) elif pretrained_model: npz.load_npz(pretrained_model, self)
def test_load_npz_ignore_names(self): chain = link.Chain() with chain.init_scope(): chain.x = chainer.variable.Parameter(shape=()) chain.yy = chainer.variable.Parameter(shape=(2, 3)) npz.load_npz( self.temp_file_path, chain, ignore_names=self.ignore_names) self.assertEqual(chain.x.data, self.x) self.assertFalse(numpy.all(chain.yy.data == self.yy))
def test_load_optimizer(self): for param in self.parent.params(): param.data.fill(1) npz.save_npz(self.temp_file_path, self.parent, self.compress) for param in self.parent.params(): param.data.fill(0) npz.load_npz(self.temp_file_path, self.parent) for param in self.parent.params(): self.assertTrue((param.data == 1).all())
def test_load_optimizer_with_strict(self): for param in self.parent.params(): param.data.fill(1) self._save_npz(self.file, self.parent, self.compress) for param in self.parent.params(): param.data.fill(0) npz.load_npz(self.file, self.parent) for param in self.parent.params(): self.assertTrue((param.data == 1).all())
def _make_npz(path_npz, path_caffemodel, model): print('Now loading caffemodel (usually it may take few minutes)') if not os.path.exists(path_caffemodel): raise IOError( 'The pre-trained caffemodel does not exist. Please download it ' 'from \'https://github.com/KaimingHe/deep-residual-networks\', ' 'and place it on {}'.format(path_caffemodel)) ResNet50Layers.convert_caffemodel_to_npz(path_caffemodel, path_npz) npz.load_npz(path_npz, model) return model
def test_load_optimizer_without_strict(self): for param in self.parent.params(): param.data.fill(1) self._save_npz(self.file, self.parent, self.compress) # Remove a param del self.parent.child.linear.b for param in self.parent.params(): param.data.fill(0) npz.load_npz(self.file, self.parent, strict=False) for param in self.parent.params(): self.assertTrue((param.data == 1).all()) self.assertFalse(hasattr(self.parent.child.linear, 'b'))
def test_serialization(self): lin1 = links.SimplifiedDropconnect(None, self.out_size) x = chainer.Variable(self.x) # Must call the link to initialize weights. lin1(x) w1 = lin1.W.data fd, temp_file_path = tempfile.mkstemp() os.close(fd) npz.save_npz(temp_file_path, lin1) lin2 = links.SimplifiedDropconnect(None, self.out_size) npz.load_npz(temp_file_path, lin2) w2 = lin2.W.data self.assertEqual((w1 == w2).all(), True)
def _retrieve(name_npz, name_caffemodel, model): root = download.get_dataset_directory('pfnet/chainer/models/') path = os.path.join(root, name_npz) path_caffemodel = os.path.join(root, name_caffemodel) return download.cache_or_load_file( path, lambda path: _make_npz(path, path_caffemodel, model), lambda path: npz.load_npz(path, model))
def __init__(self, pretrained_model, n_layers): if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. kwargs = {'initialW': constant.Zero()} else: # employ default initializers used in the original paper kwargs = {'initialW': normal.HeNormal(scale=1.0)} if n_layers == 50: block = [3, 4, 6, 3] elif n_layers == 101: block = [3, 4, 23, 3] elif n_layers == 152: block = [3, 8, 36, 3] else: raise ValueError('The n_layers argument should be either 50, 101,' ' or 152, but {} was given.'.format(n_layers)) super(ResNetLayers, self).__init__( conv1=Convolution2D(3, 64, 7, 2, 3, **kwargs), bn1=BatchNormalization(64), res2=BuildingBlock(block[0], 64, 64, 256, 1, **kwargs), res3=BuildingBlock(block[1], 256, 128, 512, 2, **kwargs), res4=BuildingBlock(block[2], 512, 256, 1024, 2, **kwargs), res5=BuildingBlock(block[3], 1024, 512, 2048, 2, **kwargs), fc6=Linear(2048, 1000), ) if pretrained_model and pretrained_model.endswith('.caffemodel'): _retrieve(n_layers, 'ResNet-{}-model.npz'.format(n_layers), pretrained_model, self) elif pretrained_model: npz.load_npz(pretrained_model, self) self.functions = collections.OrderedDict([ ('conv1', [self.conv1, self.bn1, relu]), ('pool1', [lambda x: max_pooling_2d(x, ksize=3, stride=2)]), ('res2', [self.res2]), ('res3', [self.res3]), ('res4', [self.res4]), ('res5', [self.res5]), ('pool5', [_global_average_pooling_2d]), ('fc6', [self.fc6]), ('prob', [softmax]), ])
def __init__(self, pretrained_model='auto'): super(GoogLeNet, self).__init__() if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. kwargs = {'initialW': constant.Zero()} else: # employ default initializers used in BVLC. For more detail, see # https://github.com/chainer/chainer/pull/2424#discussion_r109642209 kwargs = {'initialW': uniform.LeCunUniform(scale=1.0)} with self.init_scope(): self.conv1 = Convolution2D(3, 64, 7, stride=2, pad=3, **kwargs) self.conv2_reduce = Convolution2D(64, 64, 1, **kwargs) self.conv2 = Convolution2D(64, 192, 3, stride=1, pad=1, **kwargs) self.inc3a = Inception(192, 64, 96, 128, 16, 32, 32) self.inc3b = Inception(256, 128, 128, 192, 32, 96, 64) self.inc4a = Inception(480, 192, 96, 208, 16, 48, 64) self.inc4b = Inception(512, 160, 112, 224, 24, 64, 64) self.inc4c = Inception(512, 128, 128, 256, 24, 64, 64) self.inc4d = Inception(512, 112, 144, 288, 32, 64, 64) self.inc4e = Inception(528, 256, 160, 320, 32, 128, 128) self.inc5a = Inception(832, 256, 160, 320, 32, 128, 128) self.inc5b = Inception(832, 384, 192, 384, 48, 128, 128) self.loss3_fc = Linear(1024, 1000, **kwargs) self.loss1_conv = Convolution2D(512, 128, 1, **kwargs) self.loss1_fc1 = Linear(2048, 1024, **kwargs) self.loss1_fc2 = Linear(1024, 1000, **kwargs) self.loss2_conv = Convolution2D(528, 128, 1, **kwargs) self.loss2_fc1 = Linear(2048, 1024, **kwargs) self.loss2_fc2 = Linear(1024, 1000, **kwargs) if pretrained_model == 'auto': _retrieve( 'bvlc_googlenet.npz', 'http://dl.caffe.berkeleyvision.org/bvlc_googlenet.caffemodel', self) elif pretrained_model: npz.load_npz(pretrained_model, self)
def __init__(self, pretrained_model='auto'): if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. init = constant.Zero() kwargs = {'initialW': init, 'initial_bias': init} else: # employ default initializers used in the original paper kwargs = { 'initialW': normal.Normal(0.01), 'initial_bias': constant.Zero(), } super(VGG16Layers, self).__init__() with self.init_scope(): self.conv1_1 = Convolution2D(3, 64, 3, 1, 1, **kwargs) self.conv1_2 = Convolution2D(64, 64, 3, 1, 1, **kwargs) self.conv2_1 = Convolution2D(64, 128, 3, 1, 1, **kwargs) self.conv2_2 = Convolution2D(128, 128, 3, 1, 1, **kwargs) self.conv3_1 = Convolution2D(128, 256, 3, 1, 1, **kwargs) self.conv3_2 = Convolution2D(256, 256, 3, 1, 1, **kwargs) self.conv3_3 = Convolution2D(256, 256, 3, 1, 1, **kwargs) self.conv4_1 = Convolution2D(256, 512, 3, 1, 1, **kwargs) self.conv4_2 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.conv4_3 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.conv5_1 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.conv5_2 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.conv5_3 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.fc6 = Linear(512 * 7 * 7, 4096, **kwargs) self.fc7 = Linear(4096, 4096, **kwargs) self.fc8 = Linear(4096, 1000, **kwargs) if pretrained_model == 'auto': _retrieve( 'VGG_ILSVRC_16_layers.npz', 'http://www.robots.ox.ac.uk/%7Evgg/software/very_deep/' 'caffe/VGG_ILSVRC_16_layers.caffemodel', self) elif pretrained_model: npz.load_npz(pretrained_model, self)
def __init__(self, pretrained_model, n_layers, downsample_fb=False): super(ResNetLayers, self).__init__() if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. conv_kwargs = {'initialW': constant.Zero()} else: # employ default initializers used in the original paper conv_kwargs = {'initialW': normal.HeNormal(scale=1.0)} kwargs = conv_kwargs.copy() kwargs['downsample_fb'] = downsample_fb if n_layers == 50: block = [3, 4, 6, 3] elif n_layers == 101: block = [3, 4, 23, 3] elif n_layers == 152: block = [3, 8, 36, 3] else: raise ValueError('The n_layers argument should be either 50, 101,' ' or 152, but {} was given.'.format(n_layers)) with self.init_scope(): self.conv1 = Convolution2D(3, 64, 7, 2, 3, **conv_kwargs) self.bn1 = BatchNormalization(64) self.res2 = BuildingBlock(block[0], 64, 64, 256, 1, **kwargs) self.res3 = BuildingBlock(block[1], 256, 128, 512, 2, **kwargs) self.res4 = BuildingBlock(block[2], 512, 256, 1024, 2, **kwargs) self.res5 = BuildingBlock(block[3], 1024, 512, 2048, 2, **kwargs) self.fc6 = Linear(2048, 1000) if pretrained_model and pretrained_model.endswith('.caffemodel'): _retrieve(n_layers, 'ResNet-{}-model.npz'.format(n_layers), pretrained_model, self) elif pretrained_model: npz.load_npz(pretrained_model, self)
def __init__(self, pretrained_model="auto"): if pretrained_model: kwargs = {'initialW': constant.Zero()} else: kwargs = {'initialW': normal.HeNormal(scale=1.0)} super(ResNet, self).__init__( conv1=L.Convolution2D(3, 64, 7, 2, 3, **kwargs), bn1=L.BatchNormalization(64), res2=Block(3, 64, 64, 256, 1, **kwargs), res3=Block(4, 256, 128, 512, 2, **kwargs), res4=Block(6, 512, 256, 1024, 2, **kwargs), res5=Block(3, 1024, 512, 2048, 2, **kwargs), fc6=L.Linear(None, 1000), ) if pretrained_model == 'auto': print("[ PREPROCESS ] Use caffe model of ResNet.") _retrieve('ResNet-50-model.npz', 'ResNet-50-model.caffemodel', self) self.fc6 = L.Linear(None, 25) elif pretrained_model: npz.load_npz(pretrained_model, self) self.train = True
def main(id): with chainer.using_config("train", False): with chainer.using_config("enable_backprop", False): model_path = "/efs/fMRI_AE/SimpleFCAE_E32D32/model/model_iter_108858" gpu = 0 get_device_from_id(gpu).use() """NibDataset def __init__(self, directory: str, crop: list): """ crop = [[9, 81], [11, 99], [0, 80]] test_dataset = NibDataset("/data/test", crop=crop) """ def __init__(self, dataset, batch_size, repeat=True, shuffle=True): """ mask = load_mask_nib("/data/mask/average_optthr.nii", crop) model = Model(mask, 2, "mask", "mask") load_npz(model_path, model) model.to_gpu() for i in range(len(test_dataset)): if i % 8 != id: continue inp = to_gpu(test_dataset.get_example(i)) inp = xp.expand_dims(inp, 0) subject = test_dataset.get_subject(i) frame = test_dataset.get_frame(i) sys.stdout.write("\rsubject{:03d} frame{:03d}".format( subject, frame)) sys.stdout.flush() out = model.reconstruct(inp).array out = xp.squeeze(out) xp.save( "/efs/fMRI_AE/SimpleFCAE_E32D32/reconstruct/reconstruction_subject{:03d}_frame{:03d}.npy" .format(subject, frame), out)
def _make_npz(path_npz, url, model): path_caffemodel = download.cached_download(url) print('Now loading caffemodel (usually it may take few minutes)') VGG16Layers.convert_caffemodel_to_npz(path_caffemodel, path_npz) npz.load_npz(path_npz, model) return model
def __init__(self, pretrained_model='auto'): if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. kwargs = {'initialW': constant.Zero()} else: # employ default initializers used in the original paper kwargs = {'initialW': uniform.GlorotUniform(scale=1.0)} super(GoogLeNet, self).__init__(conv1=Convolution2D(3, 64, 7, stride=2, pad=3, **kwargs), conv2_reduce=Convolution2D(64, 64, 1, **kwargs), conv2=Convolution2D(64, 192, 3, stride=1, pad=1, **kwargs), inc3a=Inception(192, 64, 96, 128, 16, 32, 32), inc3b=Inception(256, 128, 128, 192, 32, 96, 64), inc4a=Inception(480, 192, 96, 208, 16, 48, 64), inc4b=Inception(512, 160, 112, 224, 24, 64, 64), inc4c=Inception(512, 128, 128, 256, 24, 64, 64), inc4d=Inception(512, 112, 144, 288, 32, 64, 64), inc4e=Inception(528, 256, 160, 320, 32, 128, 128), inc5a=Inception(832, 256, 160, 320, 32, 128, 128), inc5b=Inception(832, 384, 192, 384, 48, 128, 128), loss3_fc=Linear(1024, 1000, **kwargs), loss1_conv=Convolution2D(512, 128, 1, **kwargs), loss1_fc1=Linear(2048, 1024, **kwargs), loss1_fc2=Linear(1024, 1000, **kwargs), loss2_conv=Convolution2D(528, 128, 1, **kwargs), loss2_fc1=Linear(2048, 1024, **kwargs), loss2_fc2=Linear(1024, 1000, **kwargs)) if pretrained_model == 'auto': _retrieve( 'bvlc_googlenet.npz', 'http://dl.caffe.berkeleyvision.org/bvlc_googlenet.caffemodel', self) elif pretrained_model: npz.load_npz(pretrained_model, self) self.functions = OrderedDict([ ('conv1', [self.conv1, relu]), ('pool1', [_max_pooling_2d, _local_response_normalization]), ('conv2_reduce', [self.conv2_reduce, relu]), ('conv2', [self.conv2, relu, _local_response_normalization]), ('pool2', [_max_pooling_2d]), ('inception_3a', [self.inc3a]), ('inception_3b', [self.inc3b]), ('pool3', [_max_pooling_2d]), ('inception_4a', [self.inc4a]), ('inception_4b', [self.inc4b]), ('inception_4c', [self.inc4c]), ('inception_4d', [self.inc4d]), ('inception_4e', [self.inc4e]), ('pool4', [_max_pooling_2d]), ('inception_5a', [self.inc5a]), ('inception_5b', [self.inc5b]), ('pool5', [_average_pooling_2d_k7]), ('loss3_fc', [_dropout, self.loss3_fc]), ('prob', [softmax]), # Since usually the following outputs are not used, they are put # after 'prob' to be skipped for efficiency. ('loss1_fc2', [ _average_pooling_2d_k5, self.loss1_conv, relu, self.loss1_fc1, relu, self.loss1_fc2 ]), ('loss2_fc2', [ _average_pooling_2d_k5, self.loss2_conv, relu, self.loss2_fc1, relu, self.loss2_fc2 ]) ])
def test_load_without_path(self): target = link.Chain(parent_linear=links.Linear(3, 2)) npz.load_npz(self.temp_file_path, target, path='') numpy.testing.assert_array_equal( self.source_parent.parent_linear.W.data, target.parent_linear.W.data)
def _make_npz( caffe_path="./all_data/train_gaze_det/model/model/binary_w.caffemodel", npz_path="./all_data/train_gaze_det/model/model/GazeFollow.npz"): GazeFollow.convert_caffemodel_to_npz(caffe_path, npz_path) npz.load_npz(npz_path, self) return self
def __init__(self, pretrained_model='auto'): if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. init = constant.Zero() kwargs = {'initialW': init, 'initial_bias': init} else: # employ default initializers used in the original paper kwargs = { 'initialW': normal.Normal(0.01), 'initial_bias': constant.Zero(), } super(VGG16Layers, self).__init__( conv1_1=Convolution2D(3, 64, 3, 1, 1, **kwargs), conv1_2=Convolution2D(64, 64, 3, 1, 1, **kwargs), conv2_1=Convolution2D(64, 128, 3, 1, 1, **kwargs), conv2_2=Convolution2D(128, 128, 3, 1, 1, **kwargs), conv3_1=Convolution2D(128, 256, 3, 1, 1, **kwargs), conv3_2=Convolution2D(256, 256, 3, 1, 1, **kwargs), conv3_3=Convolution2D(256, 256, 3, 1, 1, **kwargs), conv4_1=Convolution2D(256, 512, 3, 1, 1, **kwargs), conv4_2=Convolution2D(512, 512, 3, 1, 1, **kwargs), conv4_3=Convolution2D(512, 512, 3, 1, 1, **kwargs), conv5_1=Convolution2D(512, 512, 3, 1, 1, **kwargs), conv5_2=Convolution2D(512, 512, 3, 1, 1, **kwargs), conv5_3=Convolution2D(512, 512, 3, 1, 1, **kwargs), fc6=Linear(512 * 7 * 7, 4096, **kwargs), fc7=Linear(4096, 4096, **kwargs), fc8=Linear(4096, 1000, **kwargs), ) if pretrained_model == 'auto': _retrieve( 'VGG_ILSVRC_16_layers.npz', 'http://www.robots.ox.ac.uk/%7Evgg/software/very_deep/' 'caffe/VGG_ILSVRC_16_layers.caffemodel', self) elif pretrained_model: npz.load_npz(pretrained_model, self) self.functions = collections.OrderedDict([ ('conv1_1', [self.conv1_1, relu]), ('conv1_2', [self.conv1_2, relu]), ('pool1', [_max_pooling_2d]), ('conv2_1', [self.conv2_1, relu]), ('conv2_2', [self.conv2_2, relu]), ('pool2', [_max_pooling_2d]), ('conv3_1', [self.conv3_1, relu]), ('conv3_2', [self.conv3_2, relu]), ('conv3_3', [self.conv3_3, relu]), ('pool3', [_max_pooling_2d]), ('conv4_1', [self.conv4_1, relu]), ('conv4_2', [self.conv4_2, relu]), ('conv4_3', [self.conv4_3, relu]), ('pool4', [_max_pooling_2d]), ('conv5_1', [self.conv5_1, relu]), ('conv5_2', [self.conv5_2, relu]), ('conv5_3', [self.conv5_3, relu]), ('pool5', [_max_pooling_2d]), ('fc6', [self.fc6, relu, dropout]), ('fc7', [self.fc7, relu, dropout]), ('fc8', [self.fc8]), ('prob', [softmax]), ])
def _make_npz(path_npz, url, model): path_caffemodel = download.cached_download(url) print('Now loading caffemodel (usually it may take few minutes)') GoogLeNet.convert_caffemodel_to_npz(path_caffemodel, path_npz) npz.load_npz(path_npz, model) return model
def main(): parser = argparse.ArgumentParser(description='Train Encoder') parser.add_argument('--batchsize', '-b', type=int, default=64, help='Number of images in each mini-batch') parser.add_argument('--epoch', '-e', type=int, default=100, help='Number of sweeps over the dataset to train') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') parser.add_argument('--dataset', '-i', default='data/celebA/', help='Directory of image files.') 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('--snapshot_interval', type=int, default=10000, help='Interval of snapshot') parser.add_argument('--display_interval', type=int, default=1000, help='Interval of displaying log to console') parser.add_argument('--gen', default='gen.npz') parser.add_argument('--enc', default=None) args = parser.parse_args() print('GPU: {}'.format(args.gpu)) print('# batchsize: {}'.format(args.batchsize)) print('# epoch: {}'.format(args.epoch)) print('') # Set up a neural network to train gen = Generator() npz.load_npz(args.gen, gen) enc = Encoder() if args.enc is not None: npz.load_npz(args.enc, enc) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() gen.to_gpu() enc.to_gpu() # Setup an optimizer def make_optimizer(model, alpha=0.0005, beta1=0.9): optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001), 'hook_dec') return optimizer opt_gen = make_optimizer(gen) gen.disable_update() opt_enc = make_optimizer(enc) # Setup a dataset all_files = os.listdir(args.dataset) image_files = [f for f in all_files if ('png' in f or 'jpg' in f)] print('{} contains {} image files'.format(args.dataset, len(image_files))) train = CelebADataset(paths=image_files, root=args.dataset) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) # Set up a trainer updater = EncUpdater( models=(gen, enc), iterator=train_iter, optimizer={'gen': opt_gen, 'enc': opt_enc}, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) snapshot_interval = (args.snapshot_interval, 'iteration') display_interval = (args.display_interval, 'iteration') trainer.extend( extensions.snapshot(filename='snapshot_enc_iter_{.updater.iteration}.npz'), trigger=snapshot_interval) trainer.extend(extensions.ExponentialShift( 'alpha', 0.5, optimizer=opt_enc), trigger=(10, 'epoch')) trainer.extend(extensions.snapshot_object( enc, 'enc_iter_{.updater.iteration}.npz'), trigger=snapshot_interval) trainer.extend(extensions.LogReport(trigger=display_interval, log_name='train_enc.log')) trainer.extend(extensions.PrintReport([ 'epoch', 'iteration', 'enc/loss', ]), trigger=display_interval) trainer.extend(extensions.PlotReport( ['enc/loss'], trigger=display_interval, file_name='enc-loss.png')) trainer.extend(extensions.ProgressBar(update_interval=10)) if args.resume: chainer.serializers.load_npz(args.resume, trainer) # Run the training trainer.run()
def main(): config = get_config() # print("configured as follows:") # print(yaml_dump(config)) while True: s = input("ok? (y/n):") if s == 'y' or s == 'Y': log_config(config, "training start") break elif s == 'n' or s == 'N': destroy_config(config) exit(1) try: try: print("mask loading...") load_mask_module = import_module( config["additional information"]["mask"]["loader"]["module"], config["additional information"]["mask"]["loader"]["package"]) load_mask = getattr( load_mask_module, config["additional information"]["mask"]["loader"]["function"]) mask = load_mask( **config["additional information"]["mask"]["loader"]["params"]) print("done.") print("mask.shape: {}".format(mask.shape)) except FileNotFoundError as e: raise e model_module = import_module(config["model"]["module"], config["model"]["package"]) Model = getattr(model_module, config["model"]["class"]) model = Model(mask=mask, **config["model"]["params"]) finetune_config = config["additional information"][ "finetune"] if "finetune" in config[ "additional information"] else None if finetune_config is not None: load_npz(path.join(finetune_config["directory"], finetune_config["file"]), model, strict=False) try: chainer.cuda.get_device_from_id(0).use() gpu = 0 print("transferring model to GPU...") model.to_gpu(gpu) print("GPU enabled") except RuntimeError: gpu = -1 print("GPU disabled") dataset_module = import_module(config["dataset"]["module"], config["dataset"]["package"]) Dataset = getattr(dataset_module, config["dataset"]["class"]) train_dataset = Dataset(**config["dataset"]["train"]["params"]) valid_dataset = Dataset(**config["dataset"]["valid"]["params"]) train_iterator = Iterator(train_dataset, config["batch"]["train"], True, True) valid_iterator = Iterator(valid_dataset, config["batch"]["valid"], False, False) Optimizer = getattr(chainer.optimizers, config["optimizer"]["class"]) optimizer = Optimizer(**config["optimizer"]["params"]) optimizer.setup(model) for hook_config in config["optimizer"]["hook"]: hook_module = import_module(hook_config["module"], hook_config["package"]) Hook = getattr(hook_module, hook_config["class"]) hook = Hook(**hook_config["params"]) optimizer.add_hook(hook) updater = Updater(train_iterator, optimizer, device=gpu) trainer = Trainer(updater, **config["trainer"]["params"]) trainer.extend(snapshot(), trigger=config["trainer"]["snapshot_interval"]) trainer.extend(snapshot_object(model, "model_iter_{.updater.iteration}"), trigger=config["trainer"]["model_interval"]) trainer.extend(observe_lr(), trigger=config["trainer"]["log_interval"]) trainer.extend( LogReport( ["epoch", "iteration", "main/loss", "validation/main/loss"], trigger=config["trainer"]["log_interval"])) trainer.extend(Evaluator(valid_iterator, model, device=gpu), trigger=config["trainer"]["eval_interval"]) trainer.extend(PrintReport( ["epoch", "iteration", "main/loss", "validation/main/loss"]), trigger=config["trainer"]["log_interval"]) trainer.extend(ProgressBar(update_interval=1)) if "schedule" in config["additional information"].keys(): for i, interval_funcs in enumerate( config["additional information"]["schedule"].items()): interval, funcs = interval_funcs f = lambda trainer, funcs=funcs: [ trainer.updater.get_optimizer('main').target. __getattribute__(func["function"])(*func["params"]) for func in funcs ] trainer.extend(f, name="schedule_{}".format(i), trigger=ManualScheduleTrigger(*interval)) trainer.run() log_config(config, "succeeded") except Exception as e: log_config(config, "unintentional termination") raise e
def __init__(self, pretrained_model='auto'): if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. kwargs = {'initialW': constant.Zero()} else: # employ default initializers used in BVLC. For more detail, see # https://github.com/pfnet/chainer/pull/2424#discussion_r109642209 kwargs = {'initialW': uniform.LeCunUniform(scale=1.0)} super(GoogLeNet, self).__init__( conv1=Convolution2D(3, 64, 7, stride=2, pad=3, **kwargs), conv2_reduce=Convolution2D(64, 64, 1, **kwargs), conv2=Convolution2D(64, 192, 3, stride=1, pad=1, **kwargs), inc3a=Inception(192, 64, 96, 128, 16, 32, 32), inc3b=Inception(256, 128, 128, 192, 32, 96, 64), inc4a=Inception(480, 192, 96, 208, 16, 48, 64), inc4b=Inception(512, 160, 112, 224, 24, 64, 64), inc4c=Inception(512, 128, 128, 256, 24, 64, 64), inc4d=Inception(512, 112, 144, 288, 32, 64, 64), inc4e=Inception(528, 256, 160, 320, 32, 128, 128), inc5a=Inception(832, 256, 160, 320, 32, 128, 128), inc5b=Inception(832, 384, 192, 384, 48, 128, 128), loss3_fc=Linear(1024, 1000, **kwargs), loss1_conv=Convolution2D(512, 128, 1, **kwargs), loss1_fc1=Linear(2048, 1024, **kwargs), loss1_fc2=Linear(1024, 1000, **kwargs), loss2_conv=Convolution2D(528, 128, 1, **kwargs), loss2_fc1=Linear(2048, 1024, **kwargs), loss2_fc2=Linear(1024, 1000, **kwargs) ) if pretrained_model == 'auto': _retrieve( 'bvlc_googlenet.npz', 'http://dl.caffe.berkeleyvision.org/bvlc_googlenet.caffemodel', self) elif pretrained_model: npz.load_npz(pretrained_model, self) self.functions = collections.OrderedDict([ ('conv1', [self.conv1, relu]), ('pool1', [_max_pooling_2d, _local_response_normalization]), ('conv2_reduce', [self.conv2_reduce, relu]), ('conv2', [self.conv2, relu, _local_response_normalization]), ('pool2', [_max_pooling_2d]), ('inception_3a', [self.inc3a]), ('inception_3b', [self.inc3b]), ('pool3', [_max_pooling_2d]), ('inception_4a', [self.inc4a]), ('inception_4b', [self.inc4b]), ('inception_4c', [self.inc4c]), ('inception_4d', [self.inc4d]), ('inception_4e', [self.inc4e]), ('pool4', [_max_pooling_2d]), ('inception_5a', [self.inc5a]), ('inception_5b', [self.inc5b]), ('pool5', [_average_pooling_2d_k7]), ('loss3_fc', [_dropout, self.loss3_fc]), ('prob', [softmax]), # Since usually the following outputs are not used, they are put # after 'prob' to be skipped for efficiency. ('loss1_fc2', [_average_pooling_2d_k5, self.loss1_conv, relu, self.loss1_fc1, relu, self.loss1_fc2]), ('loss2_fc2', [_average_pooling_2d_k5, self.loss2_conv, relu, self.loss2_fc1, relu, self.loss2_fc2]) ])
self.conv3 = L.Convolution2D(None, 384, 3, pad=1) self.conv4 = L.Convolution2D(None, 384, 3, pad=1) self.conv5 = L.Convolution2D(None, 256, 3, pad=1) self.fc6 = L.Linear(None, 4096) self.fc7 = L.Linear(None, 4096) self.fc8 = L.Linear(None, nb_class) def __call__(self, x, t): h = F.max_pooling_2d(F.local_response_normalization( F.relu(self.conv1(x))), 3, stride=2) h = F.max_pooling_2d(F.local_response_normalization( F.relu(self.conv2(h))), 3, stride=2) h = F.relu(self.conv3(h)) h = F.relu(self.conv4(h)) h = F.max_pooling_2d(F.relu(self.conv5(h)), 3, stride=2) h = F.dropout(F.relu(self.fc6(h))) h = F.dropout(F.relu(self.fc7(h))) h = self.fc8(h) return h if __name__ == "__main__": caffemodel = CaffeFunction("bvlc_alexnet.caffemodel") npz.save_npz("alexnet.npz", caffemodel, compression=False) alexnet = Alex() npz.load_npz("alexnet.npz", alexnet)
def main(): attr_columns = [ '5_o_Clock_Shadow', 'Arched_Eyebrows', 'Attractive', 'Bags_Under_Eyes', 'Bald', 'Bangs', 'Big_Lips', 'Big_Nose', 'Black_Hair', 'Blond_Hair', 'Blurry', 'Brown_Hair', 'Bushy_Eyebrows', 'Chubby', 'Double_Chin', 'Eyeglasses', 'Goatee', 'Gray_Hair', 'Heavy_Makeup', 'High_Cheekbones', 'Male', 'Mouth_Slightly_Open', 'Mustache', 'Narrow_Eyes', 'No_Beard', 'Oval_Face', 'Pale_Skin', 'Pointy_Nose', 'Receding_Hairline', 'Rosy_Cheeks', 'Sideburns', 'Smiling', 'Straight_Hair', 'Wavy_Hair', 'Wearing_Earrings', 'Wearing_Hat', 'Wearing_Lipstick', 'Wearing_Necklace', 'Wearing_Necktie', 'Young' ] parser = argparse.ArgumentParser(description='Get Attribute Vector') parser.add_argument('--batchsize', '-b', type=int, default=512, help='Number of images in each mini-batch') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') parser.add_argument('--dataset', '-i', default='data/celebA/', help='Directory of image files.') parser.add_argument('--attr_list', '-a', default='data/list_attr_celeba.txt') parser.add_argument('--get_attr', default='all', nargs='+', choices=attr_columns + ['all']) parser.add_argument('--outfile', '-o', default='attr_vec.json') parser.add_argument('--enc', default='pre-trained/enc_iter_310000.npz') args = parser.parse_args() enc = Encoder() npz.load_npz(args.enc, enc) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() enc.to_gpu() all_files = os.listdir(args.dataset) image_files = [f for f in all_files if ('png' in f or 'jpg' in f)] vectors = {} attr_df = pd.read_csv(args.attr_list, delim_whitespace=True, header=1) if args.get_attr == 'all': args.get_attr = attr_columns for attr_name in tqdm(list(set(args.get_attr) & set(attr_df.columns))): with_attr_files = attr_df[attr_df[attr_name] == 1].index.tolist() with_attr_files = list(set(with_attr_files) & set(image_files)) with_attr_vec = get_vector(enc, with_attr_files, args) without_attr_files = attr_df[attr_df[attr_name] != 1].index.tolist() without_attr_files = list(set(without_attr_files) & set(image_files)) without_attr_vec = get_vector(enc, without_attr_files, args) vectors[attr_name] = (with_attr_vec - without_attr_vec).tolist() with open(args.outfile, 'w') as f: f.write( json.dumps(vectors, indent=4, sort_keys=True, separators=(',', ': ')))
def main(id): model_path = "/efs/fMRI_AE/SimpleFCAE_E32D32/model/model_iter_108858" gpu = 0 get_device_from_id(gpu).use() """NibDataset def __init__(self, directory: str, crop: list): """ crop = [[9, 81], [11, 99], [0, 80]] test_dataset = NibDataset("/data/test", crop=crop) mask = load_mask_nib("/data/mask/average_optthr.nii", crop) """SimpleFCAE_E32D32 def __init__(self, mask, r: int, in_mask: str, out_mask: str): """ model = Model(mask, 2, "mask", "mask") load_npz(model_path, model) model.to_gpu() # feature_idx = 0 # feature_idx = (0, 4, 5, 5) # == [0, 9/2, 11/2, 10/2] # feature_idx = (0, 1, 1, 1) feature_idx = (0, 2, 7, 4) resample_size = 100 batch_size = 10 noise_level = 0.2 for i in range(len(test_dataset)): if i % 8 != id: continue print("{:4}/{:4}".format(i, len(test_dataset))) subject = test_dataset.get_subject(i) frame = test_dataset.get_frame(i) test_img = xp.asarray(test_dataset[i]) resample_remain = resample_size resample_processed = 0 ret = xp.zeros(test_img.shape) while resample_remain > 0: batch_size_this_loop = min(batch_size, resample_remain) resample_remain -= batch_size_this_loop batch = xp.broadcast_to( test_img, chain((batch_size_this_loop, ), test_img.shape)) sigma = noise_level / (xp.max(test_img) - xp.min(test_img)) batch += sigma * xp.random.randn(*batch.shape) x = Variable(batch) feature = model.extract(x) assert feature.shape == (batch_size, 1, 9, 11, 10) feature = F.sum(feature, axis=0) assert feature.shape == (1, 9, 11, 10) feature = F.get_item(feature, feature_idx) feature.backward() grad = xp.mean(x.grad, axis=0) ret = (ret * resample_processed + grad * batch_size_this_loop) / ( resample_processed + batch_size_this_loop) model.cleargrads() xp.save( "/efs/fMRI_AE/SimpleFCAE_E32D32/grad/sensitivity_map_feature_{}_{}_{}_subject{:03d}_frame{:03d}" .format(feature_idx[1], feature_idx[2], feature_idx[3], subject, frame), ret)
def __init__(self, pretrained_model='auto'): if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. init = constant.Zero() kwargs = {'initialW': init, 'initial_bias': init} else: # employ default initializers used in the original paper kwargs = { 'initialW': normal.Normal(0.01), 'initial_bias': constant.Zero(), } super(VGG16Layers, self).__init__() with self.init_scope(): self.conv1_1 = Convolution2D(3, 64, 3, 1, 1, **kwargs) self.conv1_2 = Convolution2D(64, 64, 3, 1, 1, **kwargs) self.conv2_1 = Convolution2D(64, 128, 3, 1, 1, **kwargs) self.conv2_2 = Convolution2D(128, 128, 3, 1, 1, **kwargs) self.conv3_1 = Convolution2D(128, 256, 3, 1, 1, **kwargs) self.conv3_2 = Convolution2D(256, 256, 3, 1, 1, **kwargs) self.conv3_3 = Convolution2D(256, 256, 3, 1, 1, **kwargs) self.conv4_1 = Convolution2D(256, 512, 3, 1, 1, **kwargs) self.conv4_2 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.conv4_3 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.conv5_1 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.conv5_2 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.conv5_3 = Convolution2D(512, 512, 3, 1, 1, **kwargs) self.fc6 = Linear(512 * 7 * 7, 4096, **kwargs) self.fc7 = Linear(4096, 4096, **kwargs) self.fc8 = Linear(4096, 1000, **kwargs) if pretrained_model == 'auto': _retrieve( 'VGG_ILSVRC_16_layers.npz', 'http://www.robots.ox.ac.uk/%7Evgg/software/very_deep/' 'caffe/VGG_ILSVRC_16_layers.caffemodel', self) elif pretrained_model: npz.load_npz(pretrained_model, self) self.functions = collections.OrderedDict([ ('conv1_1', [self.conv1_1, relu]), ('conv1_2', [self.conv1_2, relu]), ('pool1', [_max_pooling_2d]), ('conv2_1', [self.conv2_1, relu]), ('conv2_2', [self.conv2_2, relu]), ('pool2', [_max_pooling_2d]), ('conv3_1', [self.conv3_1, relu]), ('conv3_2', [self.conv3_2, relu]), ('conv3_3', [self.conv3_3, relu]), ('pool3', [_max_pooling_2d]), ('conv4_1', [self.conv4_1, relu]), ('conv4_2', [self.conv4_2, relu]), ('conv4_3', [self.conv4_3, relu]), ('pool4', [_max_pooling_2d]), ('conv5_1', [self.conv5_1, relu]), ('conv5_2', [self.conv5_2, relu]), ('conv5_3', [self.conv5_3, relu]), ('pool5', [_max_pooling_2d]), ('fc6', [self.fc6, relu, dropout]), ('fc7', [self.fc7, relu, dropout]), ('fc8', [self.fc8]), ('prob', [softmax]), ])
def test_load_with_path(self): target = link.Chain(child_linear=links.Linear(2, 3)) npz.load_npz(self.temp_file_path, target, 'child/') numpy.testing.assert_array_equal( self.source_child.child_linear.W.data, target.child_linear.W.data)
def __init__(self, pretrained_model='auto', n_channels=3, n_outputs=101, mean_path='datasets/models/mean2.npz'): super(C3DVersion1UCF101, self).__init__() if pretrained_model: # As a sampling process is time-consuming, # we employ a zero initializer for faster computation. init = constant.Zero() conv_kwargs = {'initialW': init, 'initial_bias': init} fc_kwargs = conv_kwargs else: # employ default initializers used in the original paper conv_kwargs = { 'initialW': normal.Normal(0.01), 'initial_bias': constant.Zero(), } fc_kwargs = { 'initialW': normal.Normal(0.005), 'initial_bias': constant.One(), } with self.init_scope(): self.conv1a = ConvolutionND(3, n_channels, 64, 3, 1, 1, **conv_kwargs) self.conv2a = ConvolutionND(3, 64, 128, 3, 1, 1, **conv_kwargs) self.conv3a = ConvolutionND(3, 128, 256, 3, 1, 1, **conv_kwargs) self.conv3b = ConvolutionND(3, 256, 256, 3, 1, 1, **conv_kwargs) self.conv4a = ConvolutionND(3, 256, 512, 3, 1, 1, **conv_kwargs) self.conv4b = ConvolutionND(3, 512, 512, 3, 1, 1, **conv_kwargs) self.conv5a = ConvolutionND(3, 512, 512, 3, 1, 1, **conv_kwargs) self.conv5b = ConvolutionND(3, 512, 512, 3, 1, 1, **conv_kwargs) self.fc6 = Linear(512 * 4 * 4, 4096, **fc_kwargs) self.fc7 = Linear(4096, 4096, **fc_kwargs) self.fc8 = Linear(4096, n_outputs, **fc_kwargs) if pretrained_model == 'auto': _retrieve( 'conv3d_deepnetA_ucf.npz', 'http://vlg.cs.dartmouth.edu/c3d/' 'c3d_ucf101_finetune_whole_iter_20000', self) elif pretrained_model: npz.load_npz(pretrained_model, self) self.pre = ConvolutionND(3, n_channels, n_channels, 1, 1, 0, nobias=True, **conv_kwargs) self.pre.W.data[:] = 0 self.pre.W.data[[0, 1, 2], [2, 1, 0]] = 128 # self.pre.b.data[:] = 128 - numpy.array([90.25164795, 97.65701294, 101.4083252]) self.mean = Bias(shape=(3, 16, 112, 112)) mean = numpy.load(mean_path)['mean'] self.mean.b.data[:] = 128 - mean[:, :, 8:8 + 112, 8:8 + 112] self.functions = collections.OrderedDict([ ('pre', [self.pre, _resize, self.mean]), ('conv1a', [self.conv1a, relu]), ('pool1', [_max_pooling_2d]), ('conv2a', [self.conv2a, relu]), ('pool2', [_max_pooling_3d]), ('conv3a', [self.conv3a, relu]), ('conv3b', [self.conv3b, relu]), ('pool3', [_max_pooling_3d]), ('conv4a', [self.conv4a, relu]), ('conv4b', [self.conv4b, relu]), ('pool4', [_max_pooling_3d]), ('conv5a', [self.conv5a, relu]), ('conv5b', [self.conv5b, relu]), ('pool5', [_max_pooling_3d, dropout]), ('fc6', [self.fc6, relu, dropout]), ('fc7', [self.fc7, relu, dropout]), ('fc8', [self.fc8]), ('prob', [softmax]), ])
def _retrieve(name, url, model): root = download.get_dataset_directory('pfnet/chainer/models/') path = os.path.join(root, name) return download.cache_or_load_file( path, lambda path: _make_npz(path, url, model), lambda path: npz.load_npz(path, model))
def main(): experiment_name = "Stacked_16_16_16_16" snapshot_name = "snapshot_iter_27215" config_path = "/efs/fMRI_AE/{}/log/config.yml".format(experiment_name) config = load_config(config_path) config["additional information"]["mask"]["loader"]["params"][ "mask_path"] = path.join( config["additional information"]["mask"]["directory"], config["additional information"]["mask"]["file"]) config["additional information"]["mask"]["loader"]["params"][ "crop"] = config["additional information"]["crop"] snapshot_path = "/efs/fMRI_AE/{}/model/{}".format(experiment_name, snapshot_name) # print("configured as follows:") # print(yaml_dump(config)) while True: s = input("ok? (y/n):") if s == 'y' or s == 'Y': log_config(config, "training start") break elif s == 'n' or s == 'N': destroy_config(config) exit(1) try: try: print("mask loading...") load_mask_module = import_module( config["additional information"]["mask"]["loader"]["module"], config["additional information"]["mask"]["loader"]["package"]) load_mask = getattr( load_mask_module, config["additional information"]["mask"]["loader"]["function"]) mask = load_mask( **config["additional information"]["mask"]["loader"]["params"]) print("done.") print("mask.shape: {}".format(mask.shape)) except FileNotFoundError as e: raise e model_module = import_module(config["model"]["module"], config["model"]["package"]) Model = getattr(model_module, config["model"]["class"]) model = Model(mask=mask, **config["model"]["params"]) finetune_config = config["additional information"]["finetune"] if finetune_config is not None: load_npz(path.join(finetune_config["directory"], finetune_config["file"]), model, strict=False) try: chainer.cuda.get_device_from_id(0).use() gpu = 0 print("transferring model to GPU...") model.to_gpu(gpu) print("GPU enabled") except RuntimeError: gpu = -1 print("GPU disabled") dataset_module = import_module(config["dataset"]["module"], config["dataset"]["package"]) Dataset = getattr(dataset_module, config["dataset"]["class"]) train_dataset = Dataset(**config["dataset"]["train"]["params"]) valid_dataset = Dataset(**config["dataset"]["valid"]["params"]) train_iterator = Iterator(train_dataset, config["batch"]["train"], True, True) valid_iterator = Iterator(valid_dataset, config["batch"]["valid"], False, False) Optimizer = getattr(chainer.optimizers, config["optimizer"]["class"]) optimizer = Optimizer(**config["optimizer"]["params"]) optimizer.setup(model) for hook_config in config["optimizer"]["hook"]: hook_module = import_module(hook_config["module"], hook_config["package"]) Hook = getattr(hook_module, hook_config["class"]) hook = Hook(**hook_config["params"]) optimizer.add_hook(hook) updater = Updater(train_iterator, optimizer, device=gpu) trainer = Trainer(updater, **config["trainer"]["params"]) trainer.extend(snapshot(), trigger=config["trainer"]["snapshot_interval"]) trainer.extend(snapshot_object(model, "model_iter_{.updater.iteration}"), trigger=config["trainer"]["model_interval"]) trainer.extend(observe_lr(), trigger=config["trainer"]["log_interval"]) trainer.extend( LogReport([ "epoch", "iteration", "main/loss", "main/pca_loss", "main/reconstruction_loss", "validation/main/loss" ], trigger=config["trainer"]["log_interval"])) trainer.extend(Evaluator(valid_iterator, model, device=gpu), trigger=config["trainer"]["eval_interval"]) trainer.extend(PrintReport([ "epoch", "iteration", "main/loss", "main/pca_loss", "main/reconstruction_loss", "validation/main/loss" ]), trigger=config["trainer"]["log_interval"]) trainer.extend(ProgressBar(update_interval=1)) if "schedule" in config["additional information"].keys(): for i, interval_funcs in enumerate( config["additional information"]["schedule"].items()): interval, funcs = interval_funcs f = lambda trainer, funcs=funcs: [ trainer.updater.get_optimizer('main').target. __getattribute__(func["function"])(*func["params"]) for func in funcs ] trainer.extend(f, name="schedule_{}".format(i), trigger=ManualScheduleTrigger(*interval)) load_npz(snapshot_path, trainer) target = trainer.updater.get_optimizer("main").target target.reset_pca() target.attach_pca() ipca_param = np.load( "/efs/fMRI_AE/Stacked_8_8_8_8_feature/ipca_mean_7920_components_990_7920.npz" ) target.pca.W = chainer.Parameter(ipca_param["components"]) target.pca.bias = chainer.Parameter(ipca_param["mean"]) target.pca.disable_update() target.pca.to_gpu(gpu) target.detach_pca_loss() target.attach_reconstruction_loss() target.release_decoder() target.freeze_encoder() trainer.run() log_config(config, "succeeded") except Exception as e: log_config(config, "unintentional termination") raise e