def __init__(self, train_conf, dict_file, model_dir, label_file, predicate_dict_file): """ train_conf: trainer configure. dict_file: word dictionary file name. model_dir: directory of model. """ self.dict = {} self.labels = {} self.predicate_dict = {} self.labels_reverse = {} self.load_dict_label(dict_file, label_file, predicate_dict_file) len_dict = len(self.dict) len_label = len(self.labels) len_pred = len(self.predicate_dict) conf = parse_config( train_conf, 'dict_len=' + str(len_dict) + ',label_len=' + str(len_label) + ',pred_len=' + str(len_pred) + ',is_predict=True') self.network = swig_paddle.GradientMachine.createFromConfigProto( conf.model_config) self.network.loadParameters(model_dir) slots = [ integer_value_sequence(len_dict), integer_value_sequence(len_dict), integer_value_sequence(len_dict), integer_value_sequence(len_dict), integer_value_sequence(len_dict), integer_value_sequence(len_dict), integer_value_sequence(len_pred), integer_value_sequence(2) ] self.converter = DataProviderConverter(slots)
def __init__(self, train_conf, dict_file, model_dir, label_file): """ train_conf: trainer configure. dict_file: word dictionary file name. model_dir: directory of model. """ self.dict = {} self.labels = {} self.labels_reverse = {} self.load_dict_label(dict_file, label_file) len_dict = len(self.dict) len_label = len(self.labels) conf = parse_config( train_conf, 'dict_len=' + str(len_dict) + ',label_len=' + str(len_label) + ',is_predict=True') self.network = swig_paddle.GradientMachine.createFromConfigProto( conf.model_config) self.network.loadParameters(model_dir) slots = [ integer_value_sequence(len_dict), integer_value_sequence(len_dict), integer_value_sequence(len_dict), integer_value_sequence(len_dict), integer_value_sequence(len_dict), integer_value_sequence(2) ] self.converter = DataProviderConverter(slots)
def main(): conf = parse_config("./mnist_model/trainer_config.conf.norm", "") print conf.data_config.load_data_args network = swig_paddle.GradientMachine.createFromConfigProto(conf.model_config) assert isinstance(network, swig_paddle.GradientMachine) # For code hint. network.loadParameters("./mnist_model/") converter = DataProviderWrapperConverter(False, [DenseSlot(784)]) inArg = converter(TEST_DATA) print network.forwardTest(inArg)
def __init__(self, train_conf, model_dir=None, resize_dim=256, crop_dim=224, mean_file=None, output_layer=None, oversample=False, is_color=True): """ train_conf: network configure. model_dir: string, directory of model. resize_dim: int, resized image size. crop_dim: int, crop size. mean_file: string, image mean file. oversample: bool, oversample means multiple crops, namely five patches (the four corner patches and the center patch) as well as their horizontal reflections, ten crops in all. """ self.train_conf = train_conf self.model_dir = model_dir if model_dir is None: self.model_dir = os.path.dirname(train_conf) self.resize_dim = resize_dim self.crop_dims = [crop_dim, crop_dim] self.oversample = oversample self.is_color = is_color self.output_layer = output_layer if self.output_layer: assert isinstance(self.output_layer, basestring) self.output_layer = self.output_layer.split(",") self.transformer = image_util.ImageTransformer(is_color = is_color) self.transformer.set_transpose((2,0,1)) self.transformer.set_channel_swap((2,1,0)) self.mean_file = mean_file if self.mean_file is not None: mean = np.load(self.mean_file)['data_mean'] mean = mean.reshape(3, self.crop_dims[0], self.crop_dims[1]) self.transformer.set_mean(mean) # mean pixel else: # if you use three mean value, set like: # this three mean value is calculated from ImageNet. self.transformer.set_mean(np.array([103.939,116.779,123.68])) conf_args = "is_test=1,use_gpu=1,is_predict=1" conf = parse_config(train_conf, conf_args) swig_paddle.initPaddle("--use_gpu=1") self.network = swig_paddle.GradientMachine.createFromConfigProto(conf.model_config) assert isinstance(self.network, swig_paddle.GradientMachine) self.network.loadParameters(self.model_dir) data_size = 3 * self.crop_dims[0] * self.crop_dims[1] slots = [DenseSlot(data_size)] is_sequence = False self.converter = util.DataProviderWrapperConverter(is_sequence, slots)
def main(): conf = parse_config("./mnist_model/trainer_config.py", "") print conf.data_config.load_data_args network = swig_paddle.GradientMachine.createFromConfigProto( conf.model_config) assert isinstance(network, swig_paddle.GradientMachine) # For code hint. network.loadParameters("./mnist_model/") converter = DataProviderConverter([dense_vector(784)]) inArg = converter(TEST_DATA) print network.forwardTest(inArg)
def __init__(self, train_conf, use_gpu=True, model_dir=None, resize_dim=None, crop_dim=None, mean_file=None, oversample=False, is_color=False): """ train_conf: 网络配置文件 model_dir: 模型路径 resize_dim: 设为原图大小 crop_dim: 图像裁剪大小,一般设为原图大小 oversample: bool, oversample表示多次裁剪,这里禁用 """ self.train_conf = train_conf self.model_dir = model_dir if model_dir is None: self.model_dir = os.path.dirname(train_conf) self.resize_dim = resize_dim self.crop_dims = [crop_dim, crop_dim] self.oversample = oversample self.is_color = is_color self.transformer = image_util.ImageTransformer(is_color = is_color) self.transformer.set_transpose((2,0,1)) self.mean_file = mean_file mean = np.load(self.mean_file)['data_mean'] mean = mean.reshape(1, self.crop_dims[0], self.crop_dims[1]) self.transformer.set_mean(mean) # mean pixel gpu = 1 if use_gpu else 0 conf_args = "is_test=1,use_gpu=%d,is_predict=1" % (gpu) #使用 parse_config() 解析训练时的配置文件 conf = parse_config(train_conf, conf_args) #PaddlePaddle目前使用Swig对其常用的预测接口进行了封装,使在Python环境下的预测接口更加简单 #使用 swig_paddle.initPaddle() 传入命令行参数初始化 PaddlePaddle swig_paddle.initPaddle("--use_gpu=%d" % (int(use_gpu))) #使用 swig_paddle.GradientMachine.createFromConfigproto() 根据上一步解析好的配置创建神经网络 self.network = swig_paddle.GradientMachine.createFromConfigProto(conf.model_config) assert isinstance(self.network, swig_paddle.GradientMachine) #从模型文件加载参数 self.network.loadParameters(self.model_dir) data_size = 1 * self.crop_dims[0] * self.crop_dims[1] slots = [dense_vector(data_size)] ''' 创建一个 DataProviderConverter 对象converter。 swig_paddle接受的原始数据是C++的Matrix,也就是直接写内存的float数组。 这个接口并不用户友好。所以,我们提供了一个工具类DataProviderConverter。 这个工具类接收和PyDataProvider2一样的输入数据 ''' self.converter = DataProviderConverter(slots)
def main(): options = parse_arguments() api.initPaddle("--use_gpu=%s" % options.use_gpu, "--trainer_count=%s" % options.trainer_count) word_dict = load_dict(options.dict_file) train_dataset = list(load_data(options.train_data, word_dict)) if options.test_data: test_dataset = list(load_data(options.test_data, word_dict)) else: test_dataset = None trainer_config = parse_config(options.config, "dict_file=%s" % options.dict_file) # No need to have data provider for trainer trainer_config.ClearField('data_config') trainer_config.ClearField('test_data_config') # create a GradientMachine from the model configuratin model = api.GradientMachine.createFromConfigProto( trainer_config.model_config) # create a trainer for the gradient machine trainer = api.Trainer.create(trainer_config, model) # create a data converter which converts data to PaddlePaddle # internal format input_types = [ integer_value_sequence(len(word_dict)) if options.seq else sparse_binary_vector(len(word_dict)), integer_value(2) ] converter = DataProviderConverter(input_types) batch_size = trainer_config.opt_config.batch_size trainer.startTrain() for train_pass in xrange(options.num_passes): trainer.startTrainPass() random.shuffle(train_dataset) for pos in xrange(0, len(train_dataset), batch_size): batch = itertools.islice(train_dataset, pos, pos + batch_size) size = min(batch_size, len(train_dataset) - pos) trainer.trainOneDataBatch(size, converter(batch)) trainer.finishTrainPass() if test_dataset: trainer.startTestPeriod() for pos in xrange(0, len(test_dataset), batch_size): batch = itertools.islice(test_dataset, pos, pos + batch_size) size = min(batch_size, len(test_dataset) - pos) trainer.testOneDataBatch(size, converter(batch)) trainer.finishTestPeriod() trainer.finishTrain()
def __init__(self, train_conf, use_gpu=True, model_dir=None, resize_dim=None, crop_dim=None, mean_file=None, oversample=False, is_color=True): """ train_conf: network configure. model_dir: string, directory of model. resize_dim: int, resized image size. crop_dim: int, crop size. mean_file: string, image mean file. oversample: bool, oversample means multiple crops, namely five patches (the four corner patches and the center patch) as well as their horizontal reflections, ten crops in all. """ self.train_conf = train_conf self.model_dir = model_dir if model_dir is None: self.model_dir = os.path.dirname(train_conf) self.resize_dim = resize_dim self.crop_dims = [crop_dim, crop_dim] self.oversample = oversample self.is_color = is_color self.transformer = image_util.ImageTransformer(is_color=is_color) self.transformer.set_transpose((2, 0, 1)) self.mean_file = mean_file mean = np.load(self.mean_file)['data_mean'] mean = mean.reshape(3, self.crop_dims[0], self.crop_dims[1]) self.transformer.set_mean(mean) # mean pixel gpu = 1 if use_gpu else 0 conf_args = "is_test=1,use_gpu=%d,is_predict=1" % (gpu) conf = parse_config(train_conf, conf_args) swig_paddle.initPaddle("--use_gpu=%d" % (gpu)) self.network = swig_paddle.GradientMachine.createFromConfigProto( conf.model_config) assert isinstance(self.network, swig_paddle.GradientMachine) self.network.loadParameters(self.model_dir) data_size = 3 * self.crop_dims[0] * self.crop_dims[1] slots = [DenseSlot(data_size)] self.converter = util.DataProviderWrapperConverter(False, slots)
def __init__(self, train_conf, use_gpu=True, model_dir=None, resize_dim=None, crop_dim=None, mean_file=None, oversample=False, is_color=True): """ train_conf: network configure. model_dir: string, directory of model. resize_dim: int, resized image size. crop_dim: int, crop size. mean_file: string, image mean file. oversample: bool, oversample means multiple crops, namely five patches (the four corner patches and the center patch) as well as their horizontal reflections, ten crops in all. """ self.train_conf = train_conf self.model_dir = model_dir if model_dir is None: self.model_dir = os.path.dirname(train_conf) self.resize_dim = resize_dim self.crop_dims = [crop_dim, crop_dim] self.oversample = oversample self.is_color = is_color self.transformer = image_util.ImageTransformer(is_color=is_color) self.transformer.set_transpose((2, 0, 1)) self.mean_file = mean_file mean = np.load(self.mean_file)['data_mean'] mean = mean.reshape(3, self.crop_dims[0], self.crop_dims[1]) self.transformer.set_mean(mean) # mean pixel gpu = 1 if use_gpu else 0 conf_args = "is_test=1,use_gpu=%d,is_predict=1" % (gpu) conf = parse_config(train_conf, conf_args) swig_paddle.initPaddle("--use_gpu=%d" % (gpu)) self.network = swig_paddle.GradientMachine.createFromConfigProto( conf.model_config) assert isinstance(self.network, swig_paddle.GradientMachine) self.network.loadParameters(self.model_dir) data_size = 3 * self.crop_dims[0] * self.crop_dims[1] slots = [dense_vector(data_size)] self.converter = DataProviderConverter(slots)
def predict(data): path = os.path.split(os.path.realpath(__file__))[0] conf = parse_config(path + "/trainer_config_age.py", "is_predict=1") print conf.data_config.load_data_args network = swig_paddle.GradientMachine.createFromConfigProto( conf.model_config) network.loadParameters(path + "/output_age/pass-00099") converter = DataProviderConverter([dense_vector(26)]) inArg = converter(data) network.forwardTest(inArg) output = network.getLayerOutputs("__fc_layer_0__") #print output prob = output["__fc_layer_0__"][0] #print prob lab = np.argsort(-prob) #print lab return lab[0]
def main(): trainer_config = parse_config("./testTrainConfig.py", "") model = swig_paddle.GradientMachine.createFromConfigProto( trainer_config.model_config) trainer = swig_paddle.Trainer.create(trainer_config, model) trainer.startTrain() for train_pass in xrange(2): trainer.startTrainPass() num = 0 cost = 0 while True: # Train one batch batch_size = 1000 data, atEnd = util.loadMNISTTrainData(batch_size) if atEnd: break trainer.trainOneDataBatch(batch_size, data) outs = trainer.getForwardOutput() cost += sum(outs[0]['value']) num += batch_size trainer.finishTrainPass() logger.info('train cost=%f' % (cost / num)) trainer.startTestPeriod() num = 0 cost = 0 while True: # Test one batch batch_size = 1000 data, atEnd = util.loadMNISTTrainData(batch_size) if atEnd: break trainer.testOneDataBatch(batch_size, data) outs = trainer.getForwardOutput() cost += sum(outs[0]['value']) num += batch_size trainer.finishTestPeriod() logger.info('test cost=%f' % (cost / num)) trainer.finishTrain()
def __init__(self, train_conf, dict_file, model_dir=None, label_file = None): """ train_conf: trainer configure. dict_file: word dictionary file name. model_dir: directory of model. """ self.train_conf = train_conf self.dict_file = dict_file self.word_dict = {} self.dict_dim = self.load_dict() self.model_dir = model_dir if model_dir is None: self.model_dir = os.path.dirname(train_conf) self.label = None if label_file is not None: self.load_label(label_file) conf = parse_config(train_conf, "is_predict=1") self.network = swig_paddle.GradientMachine.createFromConfigProto(conf.model_config) self.network.loadParameters(self.model_dir) input_types = [integer_value_sequence(self.dict_dim)] self.converter = DataProviderConverter(input_types)
def __init__(self, train_conf, dict_file, model_dir=None, label_file=None): """ train_conf: trainer configure. dict_file: word dictionary file name. model_dir: directory of model. """ self.train_conf = train_conf self.dict_file = dict_file self.word_dict = {} self.dict_dim = self.load_dict() self.model_dir = model_dir if model_dir is None: self.model_dir = os.path.dirname(train_conf) self.label = None if label_file is not None: self.load_label(label_file) conf = parse_config(train_conf, "is_predict=1") self.network = swig_paddle.GradientMachine.createFromConfigProto( conf.model_config) self.network.loadParameters(self.model_dir) input_types = [integer_value_sequence(self.dict_dim)] self.converter = DataProviderConverter(input_types)
def parse_network_config(network_conf, config_arg_str=''): config = config_parser.parse_config(network_conf, config_arg_str) return config.model_config
def parse_trainer_config(trainer_conf, config_arg_str): return config_parser.parse_config(trainer_conf, config_arg_str)
def test_parse(self): a = parse_config('trainer_config_helpers/tests/layers_test_config.py', '') b = parse_config('trainer_config_helpers/tests/layers_test_config.py', '') self.assertEqual(a, b)
def make_diagram(config_file, dot_file, config_arg_str): config = parse_config(config_file, config_arg_str) make_diagram_from_proto(config.model_config, dot_file)
def parse_optimizer_config(optimizer_conf, config_arg_str=''): config = config_parser.parse_config(optimizer_conf, config_arg_str) return config.opt_config
from py_paddle import swig_paddle, DataProviderConverter from common_utils import * from paddle.trainer.config_parser import parse_config try: import cPickle as pickle except ImportError: import pickle import sys if __name__ == '__main__': model_path = sys.argv[1] swig_paddle.initPaddle('--use_gpu=0') conf = parse_config("trainer_config.py", "is_predict=1") network = swig_paddle.GradientMachine.createFromConfigProto( conf.model_config) assert isinstance(network, swig_paddle.GradientMachine) network.loadParameters(model_path) with open('./data/meta.bin', 'rb') as f: meta = pickle.load(f) headers = [h[1] for h in meta_to_header(meta, 'movie')] headers.extend([h[1] for h in meta_to_header(meta, 'user')]) cvt = DataProviderConverter(headers) while True: movie_id = int(raw_input("Input movie_id: ")) user_id = int(raw_input("Input user_id: ")) movie_meta = meta['movie'][movie_id] # Query Data From Meta. user_meta = meta['user'][user_id] data = [movie_id - 1]
# Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from paddle.trainer.config_parser import parse_config from paddle.proto import TrainerConfig_pb2 import sys __all__ = [] if __name__ == '__main__': whole_conf = False if len(sys.argv) == 2: conf = parse_config(sys.argv[1], '') elif len(sys.argv) == 3: conf = parse_config(sys.argv[1], sys.argv[2]) elif len(sys.argv) == 4: conf = parse_config(sys.argv[1], sys.argv[2]) if sys.argv[3] == '--whole': whole_conf = True else: raise RuntimeError() assert isinstance(conf, TrainerConfig_pb2.TrainerConfig) if whole_conf: print conf else: print conf.model_config
def main(): parser = argparse.ArgumentParser() parser.add_argument( "--use_gpu", default="1", help="1 means use gpu for training") parser.add_argument("--gpu_id", default="0", help="the gpu_id parameter") args = parser.parse_args() use_gpu = args.use_gpu assert use_gpu in ["0", "1"] if not os.path.exists("./samples/"): os.makedirs("./samples/") if not os.path.exists("./params/"): os.makedirs("./params/") api.initPaddle('--use_gpu=' + use_gpu, '--dot_period=10', '--log_period=1000', '--gpu_id=' + args.gpu_id, '--save_dir=' + "./params/") conf = "vae_conf.py" trainer_conf = parse_config(conf, "is_generating=False") gener_conf = parse_config(conf, "is_generating=True") batch_size = trainer_conf.opt_config.batch_size noise_dim = get_layer_size(gener_conf.model_config, "noise") mnist = dataloader.MNISTloader(batch_size=batch_size) mnist.load_data() training_machine = api.GradientMachine.createFromConfigProto( trainer_conf.model_config) generator_machine = api.GradientMachine.createFromConfigProto( gener_conf.model_config) trainer = api.Trainer.create(trainer_conf, training_machine) trainer.startTrain() for train_pass in xrange(100): trainer.startTrainPass() mnist.reset_pointer() i = 0 it = 0 while mnist.pointer != 0 or i == 0: X = mnist.next_batch().astype('float32') inputs = api.Arguments.createArguments(1) inputs.setSlotValue(0, api.Matrix.createDenseFromNumpy(X)) trainer.trainOneDataBatch(batch_size, inputs) if it % 1000 == 0: outputs = api.Arguments.createArguments(0) training_machine.forward(inputs, outputs, api.PASS_TEST) loss = np.mean(outputs.getSlotValue(0).copyToNumpyMat()) print "\niter: {}".format(str(it).zfill(3)) print "VAE loss: {}".format(str(loss).zfill(3)) #Sync parameters between networks (GradientMachine) at the beginning copy_shared_parameters(training_machine, generator_machine) z_samples = np.random.randn(batch_size, noise_dim).astype('float32') samples = get_fake_samples(generator_machine, batch_size, z_samples) #Generating the first 16 images for a picture. figure = plot_samples(samples[:16]) plt.savefig( "./samples/{}_{}.png".format( str(train_pass).zfill(3), str(i).zfill(3)), bbox_inches='tight') plt.close(figure) i += 1 it += 1 trainer.finishTrainPass() trainer.finishTrain()
def make_diagram(config_file, dot_file, config_arg_str): config = parse_config(config_file, config_arg_str) # print >> sys.stderr, config name2id = {} f = open(dot_file, 'w') submodel_layers = set() def make_link(link): return 'l%s -> l%s;' % (name2id[link.layer_name], name2id[link.link_name]) def make_mem(mem): s = '' if mem.boot_layer_name: s += 'l%s -> l%s;\n' % (name2id[mem.boot_layer_name], name2id[mem.layer_name]) s += 'l%s -> l%s [style=dashed];' % (name2id[mem.layer_name], name2id[mem.link_name]) return s print >> f, 'digraph graphname {' print >> f, 'node [width=0.375,height=0.25];' for i in xrange(len(config.model_config.layers)): l = config.model_config.layers[i] name2id[l.name] = i i = 0 for sub_model in config.model_config.sub_models: if sub_model.name == 'root': continue print >> f, 'subgraph cluster_%s {' % i print >> f, 'style=dashed;' label = '%s ' % sub_model.name if sub_model.reversed: label += '<==' print >> f, 'label = "%s";' % label i += 1 submodel_layers.add(sub_model.name) for layer_name in sub_model.layer_names: submodel_layers.add(layer_name) lid = name2id[layer_name] layer_config = config.model_config.layers[lid] label = make_layer_label(layer_config) print >> f, 'l%s [label="%s", shape=box];' % (lid, label) print >> f, '}' for i in xrange(len(config.model_config.layers)): l = config.model_config.layers[i] if l.name not in submodel_layers: label = make_layer_label(l) print >> f, 'l%s [label="%s", shape=box];' % (i, label) for sub_model in config.model_config.sub_models: if sub_model.name == 'root': continue for link in sub_model.in_links: print >> f, make_link(link) for link in sub_model.out_links: print >> f, make_link(link) for mem in sub_model.memories: print >> f, make_mem(mem) for i in xrange(len(config.model_config.layers)): for l in config.model_config.layers[i].inputs: print >> f, 'l%s -> l%s [label="%s"];' % ( name2id[l.input_layer_name], i, l.input_parameter_name) print >> f, '}' f.close()
def make_diagram(config_file, dot_file, config_arg_str): config = parse_config(config_file, config_arg_str) # print >> sys.stderr, config name2id = {} f = open(dot_file, 'w') submodel_layers = set() def make_link(link): return 'l%s -> l%s;' % ( name2id[link.layer_name], name2id[link.link_name]) def make_mem(mem): s = '' if mem.boot_layer_name: s += 'l%s -> l%s;\n' % ( name2id[mem.boot_layer_name], name2id[mem.layer_name]) s += 'l%s -> l%s [style=dashed];' % ( name2id[mem.layer_name], name2id[mem.link_name]) return s print >> f, 'digraph graphname {' print >> f, 'node [width=0.375,height=0.25];' for i in xrange(len(config.model_config.layers)): l = config.model_config.layers[i] name2id[l.name] = i i = 0 for sub_model in config.model_config.sub_models: if sub_model.name == 'root': continue print >> f, 'subgraph cluster_%s {' % i print >> f, 'style=dashed;' label = '%s ' % sub_model.name if sub_model.reversed: label += '<==' print >> f, 'label = "%s";' % label i += 1 submodel_layers.add(sub_model.name) for layer_name in sub_model.layer_names: submodel_layers.add(layer_name) lid = name2id[layer_name] layer_config = config.model_config.layers[lid] label = make_layer_label(layer_config) print >> f, 'l%s [label="%s", shape=box];' % (lid, label) print >> f, '}' for i in xrange(len(config.model_config.layers)): l = config.model_config.layers[i] if l.name not in submodel_layers: label = make_layer_label(l) print >> f, 'l%s [label="%s", shape=box];' % (i, label) for sub_model in config.model_config.sub_models: if sub_model.name == 'root': continue for link in sub_model.in_links: print >> f, make_link(link) for link in sub_model.out_links: print >> f, make_link(link) for mem in sub_model.memories: print >> f, make_mem(mem) for i in xrange(len(config.model_config.layers)): for l in config.model_config.layers[i].inputs: print >> f, 'l%s -> l%s [label="%s"];' % ( name2id[l.input_layer_name], i, l.input_parameter_name) print >> f, '}' f.close()
def __init__(self, train_conf, model_dir=None, resize_dim=256, crop_dim=224, use_gpu=True, mean_file=None, output_layer=None, oversample=False, is_color=True): """ train_conf: network configure. model_dir: string, directory of model. resize_dim: int, resized image size. crop_dim: int, crop size. mean_file: string, image mean file. oversample: bool, oversample means multiple crops, namely five patches (the four corner patches and the center patch) as well as their horizontal reflections, ten crops in all. """ self.train_conf = train_conf self.model_dir = model_dir if model_dir is None: self.model_dir = os.path.dirname(train_conf) self.resize_dim = resize_dim self.crop_dims = [crop_dim, crop_dim] self.oversample = oversample self.is_color = is_color self.output_layer = output_layer if self.output_layer: assert isinstance(self.output_layer, basestring) self.output_layer = self.output_layer.split(",") self.transformer = image_util.ImageTransformer(is_color=is_color) self.transformer.set_transpose((2, 0, 1)) self.transformer.set_channel_swap((2, 1, 0)) self.mean_file = mean_file if self.mean_file is not None: mean = np.load(self.mean_file)['data_mean'] mean = mean.reshape(3, self.crop_dims[0], self.crop_dims[1]) self.transformer.set_mean(mean) # mean pixel else: # if you use three mean value, set like: # this three mean value is calculated from ImageNet. self.transformer.set_mean(np.array([103.939, 116.779, 123.68])) conf_args = "is_test=1,use_gpu=%d,is_predict=1" % (int(use_gpu)) conf = parse_config(train_conf, conf_args) swig_paddle.initPaddle("--use_gpu=%d" % (int(use_gpu))) self.network = swig_paddle.GradientMachine.createFromConfigProto( conf.model_config) assert isinstance(self.network, swig_paddle.GradientMachine) self.network.loadParameters(self.model_dir) data_size = 3 * self.crop_dims[0] * self.crop_dims[1] slots = [dense_vector(data_size)] self.converter = DataProviderConverter(slots)
def parse_network_config(network_conf): config = config_parser.parse_config(network_conf, '') return config.model_config
def main(): parser = argparse.ArgumentParser() parser.add_argument("-d", "--data_source", help="mnist or cifar or uniform") parser.add_argument( "--use_gpu", default="1", help="1 means use gpu for training") parser.add_argument("--gpu_id", default="0", help="the gpu_id parameter") args = parser.parse_args() data_source = args.data_source use_gpu = args.use_gpu assert data_source in ["mnist", "cifar", "uniform"] assert use_gpu in ["0", "1"] if not os.path.exists("./%s_samples/" % data_source): os.makedirs("./%s_samples/" % data_source) if not os.path.exists("./%s_params/" % data_source): os.makedirs("./%s_params/" % data_source) api.initPaddle('--use_gpu=' + use_gpu, '--dot_period=10', '--log_period=100', '--gpu_id=' + args.gpu_id, '--save_dir=' + "./%s_params/" % data_source) if data_source == "uniform": conf = "gan_conf.py" num_iter = 10000 else: conf = "gan_conf_image.py" num_iter = 1000 gen_conf = parse_config(conf, "mode=generator_training,data=" + data_source) dis_conf = parse_config(conf, "mode=discriminator_training,data=" + data_source) generator_conf = parse_config(conf, "mode=generator,data=" + data_source) batch_size = dis_conf.opt_config.batch_size noise_dim = get_layer_size(gen_conf.model_config, "noise") if data_source == "mnist": data_np = load_mnist_data("./data/mnist_data/train-images-idx3-ubyte") elif data_source == "cifar": data_np = load_cifar_data("./data/cifar-10-batches-py/") else: data_np = load_uniform_data() # this creates a gradient machine for discriminator dis_training_machine = api.GradientMachine.createFromConfigProto( dis_conf.model_config) # this create a gradient machine for generator gen_training_machine = api.GradientMachine.createFromConfigProto( gen_conf.model_config) # generator_machine is used to generate data only, which is used for # training discriminator logger.info(str(generator_conf.model_config)) generator_machine = api.GradientMachine.createFromConfigProto( generator_conf.model_config) dis_trainer = api.Trainer.create(dis_conf, dis_training_machine) gen_trainer = api.Trainer.create(gen_conf, gen_training_machine) dis_trainer.startTrain() gen_trainer.startTrain() # Sync parameters between networks (GradientMachine) at the beginning copy_shared_parameters(gen_training_machine, dis_training_machine) copy_shared_parameters(gen_training_machine, generator_machine) # constrain that either discriminator or generator can not be trained # consecutively more than MAX_strike times curr_train = "dis" curr_strike = 0 MAX_strike = 5 for train_pass in xrange(100): dis_trainer.startTrainPass() gen_trainer.startTrainPass() for i in xrange(num_iter): # Do forward pass in discriminator to get the dis_loss noise = get_noise(batch_size, noise_dim) data_batch_dis_pos = prepare_discriminator_data_batch_pos( batch_size, data_np) dis_loss_pos = get_training_loss(dis_training_machine, data_batch_dis_pos) data_batch_dis_neg = prepare_discriminator_data_batch_neg( generator_machine, batch_size, noise) dis_loss_neg = get_training_loss(dis_training_machine, data_batch_dis_neg) dis_loss = (dis_loss_pos + dis_loss_neg) / 2.0 # Do forward pass in generator to get the gen_loss data_batch_gen = prepare_generator_data_batch(batch_size, noise) gen_loss = get_training_loss(gen_training_machine, data_batch_gen) if i % 100 == 0: print "d_pos_loss is %s d_neg_loss is %s" % (dis_loss_pos, dis_loss_neg) print "d_loss is %s g_loss is %s" % (dis_loss, gen_loss) # Decide which network to train based on the training history # And the relative size of the loss if (not (curr_train == "dis" and curr_strike == MAX_strike)) and \ ((curr_train == "gen" and curr_strike == MAX_strike) or dis_loss > gen_loss): if curr_train == "dis": curr_strike += 1 else: curr_train = "dis" curr_strike = 1 dis_trainer.trainOneDataBatch(batch_size, data_batch_dis_neg) dis_trainer.trainOneDataBatch(batch_size, data_batch_dis_pos) copy_shared_parameters(dis_training_machine, gen_training_machine) else: if curr_train == "gen": curr_strike += 1 else: curr_train = "gen" curr_strike = 1 gen_trainer.trainOneDataBatch(batch_size, data_batch_gen) # TODO: add API for paddle to allow true parameter sharing between different GradientMachines # so that we do not need to copy shared parameters. copy_shared_parameters(gen_training_machine, dis_training_machine) copy_shared_parameters(gen_training_machine, generator_machine) dis_trainer.finishTrainPass() gen_trainer.finishTrainPass() # At the end of each pass, save the generated samples/images fake_samples = get_fake_samples(generator_machine, batch_size, noise) if data_source == "uniform": plot2DScatter(fake_samples, "./%s_samples/train_pass%s.png" % (data_source, train_pass)) else: save_images(fake_samples, "./%s_samples/train_pass%s.png" % (data_source, train_pass)) dis_trainer.finishTrain() gen_trainer.finishTrain()
def parse_optimizer_config(optimizer_conf): config = config_parser.parse_config(optimizer_conf, '') return config.opt_config
from py_paddle import swig_paddle, DataProviderConverter from common_utils import * from paddle.trainer.config_parser import parse_config try: import cPickle as pickle except ImportError: import pickle import sys if __name__ == '__main__': model_path = sys.argv[1] swig_paddle.initPaddle('--use_gpu=0') conf = parse_config("trainer_config.py", "is_predict=1") network = swig_paddle.GradientMachine.createFromConfigProto( conf.model_config) assert isinstance(network, swig_paddle.GradientMachine) network.loadParameters(model_path) with open('./data/meta.bin', 'rb') as f: meta = pickle.load(f) headers = list(meta_to_header(meta, 'movie')) headers.extend(list(meta_to_header(meta, 'user'))) cvt = DataProviderConverter(headers) while True: movie_id = int(raw_input("Input movie_id: ")) user_id = int(raw_input("Input user_id: ")) movie_meta = meta['movie'][movie_id] # Query Data From Meta. user_meta = meta['user'][user_id] data = [movie_id - 1]
def main(): parser = argparse.ArgumentParser() parser.add_argument("-d", "--data_source", help="mnist or cifar or uniform") parser.add_argument("--use_gpu", default="1", help="1 means use gpu for training") parser.add_argument("--gpu_id", default="0", help="the gpu_id parameter") args = parser.parse_args() data_source = args.data_source use_gpu = args.use_gpu assert data_source in ["mnist", "cifar", "uniform"] assert use_gpu in ["0", "1"] if not os.path.exists("./%s_samples/" % data_source): os.makedirs("./%s_samples/" % data_source) if not os.path.exists("./%s_params/" % data_source): os.makedirs("./%s_params/" % data_source) api.initPaddle('--use_gpu=' + use_gpu, '--dot_period=10', '--log_period=100', '--gpu_id=' + args.gpu_id, '--save_dir=' + "./%s_params/" % data_source) if data_source == "uniform": conf = "gan_conf.py" num_iter = 10000 else: conf = "gan_conf_image.py" num_iter = 1000 gen_conf = parse_config(conf, "mode=generator_training,data=" + data_source) dis_conf = parse_config(conf, "mode=discriminator_training,data=" + data_source) generator_conf = parse_config(conf, "mode=generator,data=" + data_source) batch_size = dis_conf.opt_config.batch_size noise_dim = get_layer_size(gen_conf.model_config, "noise") if data_source == "mnist": data_np = load_mnist_data("./data/mnist_data/train-images-idx3-ubyte") elif data_source == "cifar": data_np = load_cifar_data("./data/cifar-10-batches-py/") else: data_np = load_uniform_data() # this creates a gradient machine for discriminator dis_training_machine = api.GradientMachine.createFromConfigProto( dis_conf.model_config) # this create a gradient machine for generator gen_training_machine = api.GradientMachine.createFromConfigProto( gen_conf.model_config) # generator_machine is used to generate data only, which is used for # training discriminator logger.info(str(generator_conf.model_config)) generator_machine = api.GradientMachine.createFromConfigProto( generator_conf.model_config) dis_trainer = api.Trainer.create(dis_conf, dis_training_machine) gen_trainer = api.Trainer.create(gen_conf, gen_training_machine) dis_trainer.startTrain() gen_trainer.startTrain() # Sync parameters between networks (GradientMachine) at the beginning copy_shared_parameters(gen_training_machine, dis_training_machine) copy_shared_parameters(gen_training_machine, generator_machine) # constrain that either discriminator or generator can not be trained # consecutively more than MAX_strike times curr_train = "dis" curr_strike = 0 MAX_strike = 5 for train_pass in xrange(100): dis_trainer.startTrainPass() gen_trainer.startTrainPass() for i in xrange(num_iter): # Do forward pass in discriminator to get the dis_loss noise = get_noise(batch_size, noise_dim) data_batch_dis_pos = prepare_discriminator_data_batch_pos( batch_size, data_np) dis_loss_pos = get_training_loss(dis_training_machine, data_batch_dis_pos) data_batch_dis_neg = prepare_discriminator_data_batch_neg( generator_machine, batch_size, noise) dis_loss_neg = get_training_loss(dis_training_machine, data_batch_dis_neg) dis_loss = (dis_loss_pos + dis_loss_neg) / 2.0 # Do forward pass in generator to get the gen_loss data_batch_gen = prepare_generator_data_batch(batch_size, noise) gen_loss = get_training_loss(gen_training_machine, data_batch_gen) if i % 100 == 0: print "d_pos_loss is %s d_neg_loss is %s" % (dis_loss_pos, dis_loss_neg) print "d_loss is %s g_loss is %s" % (dis_loss, gen_loss) # Decide which network to train based on the training history # And the relative size of the loss if (not (curr_train == "dis" and curr_strike == MAX_strike)) and \ ((curr_train == "gen" and curr_strike == MAX_strike) or dis_loss > gen_loss): if curr_train == "dis": curr_strike += 1 else: curr_train = "dis" curr_strike = 1 dis_trainer.trainOneDataBatch(batch_size, data_batch_dis_neg) dis_trainer.trainOneDataBatch(batch_size, data_batch_dis_pos) copy_shared_parameters(dis_training_machine, gen_training_machine) else: if curr_train == "gen": curr_strike += 1 else: curr_train = "gen" curr_strike = 1 gen_trainer.trainOneDataBatch(batch_size, data_batch_gen) # TODO: add API for paddle to allow true parameter sharing between different GradientMachines # so that we do not need to copy shared parameters. copy_shared_parameters(gen_training_machine, dis_training_machine) copy_shared_parameters(gen_training_machine, generator_machine) dis_trainer.finishTrainPass() gen_trainer.finishTrainPass() # At the end of each pass, save the generated samples/images fake_samples = get_fake_samples(generator_machine, batch_size, noise) if data_source == "uniform": plot2DScatter( fake_samples, "./%s_samples/train_pass%s.png" % (data_source, train_pass)) else: save_images( fake_samples, "./%s_samples/train_pass%s.png" % (data_source, train_pass)) dis_trainer.finishTrain() gen_trainer.finishTrain()