def _test_base(self, run_ipu=True): scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() SEED = self.SEED main_prog.random_seed = SEED startup_prog.random_seed = SEED with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): x = paddle.fluid.layers.fill_constant(**self.attrs) out = paddle.fluid.layers.elementwise_add(x, x) fetch_list = [out.name] if run_ipu: place = paddle.IPUPlace() else: place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) if run_ipu: feed_list = self.feed_list ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = self.is_training program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(feed_list, fetch_list) else: program = main_prog result = exe.run(program, feed=self.feed, fetch_list=fetch_list) return result[0]
def _test_save(self): scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() main_prog.random_seed = self.SEED startup_prog.random_seed = self.SEED generator = fluid.unique_name.UniqueNameGenerator() self.full_name = '/'.join( [self.attrs['path'], self.attrs['model_name']]) with fluid.unique_name.guard(generator): with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): x = paddle.static.data(name=self.feed_list[0], shape=self.feed_shape[0], dtype='float32') conv1 = paddle.static.nn.conv2d(x, num_filters=3, filter_size=3, bias_attr=False, name='conv2d') loss = paddle.mean(conv1) if self.attrs['is_training']: if self.attrs['opt_type'] == 'sgd': sgd = paddle.optimizer.SGD(learning_rate=1e-2) sgd.minimize(loss) elif self.attrs['opt_type'] == 'adam': adam = paddle.optimizer.Adam(learning_rate=1e-2) adam.minimize(loss) elif self.attrs['opt_type'] == 'lamb': lamb = paddle.optimizer.Lamb(learning_rate=1e-2) lamb.minimize(loss) fetch_list = [loss.name] place = paddle.IPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = self.attrs['is_training'] program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(self.feed_list, fetch_list) result = [] for i in range(self.attrs['steps']): tmp = exe.run(program, feed=self.feed, fetch_list=fetch_list) result.append(tmp) paddle.static.save_inference_model(self.full_name, x, loss, exe, program=program.org_program)
def _test(self, run_ipu=True): scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() main_prog.random_seed = SEED startup_prog.random_seed = SEED np.random.seed(SEED) np_image = np.random.rand(1, 3, 10, 10).astype(np.float32) with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): image = paddle.static.data(name='image', shape=[1, 3, 10, 10], dtype='float32') conv1 = paddle.static.nn.conv2d(image, num_filters=3, filter_size=3, bias_attr=False) loss = paddle.mean(conv1) sgd = paddle.optimizer.SGD(learning_rate=LR_New()) sgd.minimize(loss) if run_ipu: place = paddle.IPUPlace() else: place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) if run_ipu: feed_list = [image.name] fetch_list = [loss.name] ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = True program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(feed_list, fetch_list) else: program = main_prog result = [] for epoch in range(100): if hasattr(program, "lr_sheduler"): program.lr_sheduler.step() loss_res = exe.run(program, feed={image.name: np_image}, fetch_list=[loss]) result.append(loss_res) return np.array(result)
def _test_base(self, run_ipu=True): scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() SEED = self.SEED main_prog.random_seed = SEED startup_prog.random_seed = SEED with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): x = paddle.static.data( name=self.feed_list[0], shape=self.feed_shape[0], dtype=self.feed_dtype[0]) # [warning] Copying (host) tensor input/1 from INT64 to INT32. # Will only warn once if run_ipu: label = paddle.static.data( name=self.feed_list[1], shape=self.feed_shape[1], dtype='int32') else: label = paddle.static.data( name=self.feed_list[1], shape=self.feed_shape[1], dtype='int64') out = fluid.layers.cross_entropy( input=x, label=label, **self.attrs) fetch_list = [out.name] if run_ipu: place = paddle.IPUPlace() else: place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) if run_ipu: feed_list = self.feed_list ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = self.is_training program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(feed_list, fetch_list) else: program = main_prog result = exe.run(program, feed=self.feed, fetch_list=fetch_list) return result[0]
def _test_func(self, run_ipu=True): scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() main_prog.random_seed = SEED startup_prog.random_seed = SEED np.random.seed(SEED) bps = 5 n = 1 if run_ipu else -1 c, h, w = 3, 10, 10 np_image = np.random.uniform(size=[1 * bps, c, h, w]).astype(np.float32) with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): image = paddle.static.data( name='image', shape=[n, c, h, w], dtype='float32') conv2d = paddle.static.nn.conv2d( image, num_filters=3, filter_size=3, bias_attr=False) # paddle.mean oshape on ipu is [bps], need another mean() # paddle.mean oshape on cpu is [1] # out = paddle.mean(conv2d) out = conv2d if run_ipu: place = paddle.IPUPlace() else: place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) if run_ipu: feed_list = [image.name] fetch_list = [out.name] ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = False ipu_strategy.batches_per_step = bps program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(feed_list, fetch_list) else: program = main_prog result = exe.run(program, feed={image.name: np_image}, fetch_list=[out]) return result[0]
def _test_base(self, run_ipu=True, op=None, data_feed=None): assert (op is not None) assert (data_feed is not None) scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() SEED = self.SEED main_prog.random_seed = SEED startup_prog.random_seed = SEED with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): x = paddle.static.data(name=self.feed_list[0], shape=self.feed_shape[0], dtype='float32') if not self.use_K_as_const_variable: topk_values, topk_indices = op(x, **self.attrs) else: # !important, popart cannot accept non const tensor # K_t = paddle.static.data(name="in_1", shape=[1], dtype='int32') K_t = fluid.layers.fill_constant(shape=[1], dtype='int32', value=self.k, name="in_2") topk_values, topk_indices = op(x, K_t, **self.attrs) fetch_list = [topk_values.name, topk_indices.name] if run_ipu: place = paddle.IPUPlace() else: place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) if run_ipu: feed_list = self.feed_list ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = self.is_training program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(feed_list, fetch_list) else: program = main_prog print("Running inference ...") result = exe.run(program, feed=data_feed, fetch_list=fetch_list) print("Complete running infrence.") return result
def _test(self, run_ipu=True): scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() main_prog.random_seed = SEED startup_prog.random_seed = SEED np.random.seed(SEED) np_image = np.random.rand(1, 3, 10, 10).astype(np.float32) with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): image = paddle.static.data( name='image', shape=[1, 3, 10, 10], dtype='float32') with fluid.ipu_shard(ipu_index=0): conv1 = paddle.static.nn.conv2d( image, num_filters=3, filter_size=3, bias_attr=False) with fluid.ipu_shard(ipu_index=1): conv2 = paddle.static.nn.conv2d( conv1, num_filters=3, filter_size=3, bias_attr=False) loss = paddle.mean(conv2) if run_ipu: place = paddle.IPUPlace() else: place = paddle.CPUPlace() executor = paddle.static.Executor(place) executor.run(startup_prog) if run_ipu: feed_list = [image.name] fetch_list = [loss.name] ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.num_ipus = 2 ipu_strategy.is_training = False ipu_strategy.enable_manual_shard = True ipu_strategy.enable_pipelining = False program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(feed_list, fetch_list) else: program = main_prog loss_res = executor.run(program, feed={"image": np_image}, fetch_list=[loss]) return loss_res
def _test_base(self, run_ipu=True): scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() SEED = self.SEED main_prog.random_seed = SEED startup_prog.random_seed = SEED with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): x = paddle.static.data( name=self.feed_list[0], shape=self.feed_shape[0], dtype='float32') conv1 = paddle.static.nn.conv2d( x, num_filters=3, filter_size=3, bias_attr=False) conv2 = paddle.static.nn.conv2d( conv1, num_filters=3, filter_size=3, bias_attr=False) conv3 = paddle.static.nn.conv2d( conv2, num_filters=3, filter_size=3, bias_attr=False) conv4 = paddle.static.nn.conv2d( conv3, num_filters=3, filter_size=3, bias_attr=False) fetch_list = [conv4.name] if run_ipu: place = paddle.IPUPlace() else: place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) if run_ipu: feed_list = self.feed_list ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = self.is_training # set batch size ipu_strategy.batch_size = 2 program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(feed_list, fetch_list) else: program = main_prog result = exe.run(program, feed=self.feed, fetch_list=fetch_list) return result[0]
def _test_base(self, run_ipu=True): scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() SEED = self.SEED main_prog.random_seed = SEED startup_prog.random_seed = SEED with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): x = paddle.static.data(name=self.feed_list[0], shape=self.feed_shape[0], dtype=self.feed_dtype[0]) add1 = paddle.fluid.layers.elementwise_add(x, x) reshape = paddle.fluid.layers.reshape(add1, **self.attrs) add2 = paddle.fluid.layers.elementwise_add(reshape, reshape) scale1 = paddle.fluid.layers.scale(add2) scale2 = paddle.fluid.layers.scale(scale1, scale=1.3, bias=0.5) scale3 = paddle.fluid.layers.scale(scale2, scale=2, bias=0.7) fetch_list = [scale3.name] if run_ipu: place = paddle.IPUPlace() else: place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) scale1_out = main_prog.global_block().ops[4].output("Out")[0] main_prog.global_block().ops[4]._rename_output( scale1_out, add2.name) main_prog.global_block().ops[5]._rename_input( scale1_out, add2.name) if run_ipu: feed_list = self.feed_list ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = self.is_training program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(feed_list, fetch_list) else: program = main_prog result = exe.run(program, feed=self.feed, fetch_list=fetch_list) return result[0]
def _test_base(self, run_ipu=True): scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() SEED = self.SEED main_prog.random_seed = SEED startup_prog.random_seed = SEED with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): x = paddle.static.data( name=self.feed_list[0], shape=self.feed_shape[0], dtype=self.feed_dtype[0]) starts = paddle.static.data( name=self.feed_list[1], shape=self.feed_shape[1], dtype=self.feed_dtype[1]) ends = paddle.static.data( name=self.feed_list[2], shape=self.feed_shape[2], dtype=self.feed_dtype[2]) out = paddle.fluid.layers.slice( x, starts=starts, ends=ends, **self.attrs) fetch_list = [out.name] if run_ipu: place = paddle.IPUPlace() else: place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) if run_ipu: feed_list = self.feed_list ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = self.is_training program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(feed_list, fetch_list) else: program = main_prog result = exe.run(program, feed=self.feed, fetch_list=fetch_list) return result[0]
def _test_base(self, run_ipu=True): scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() SEED = self.SEED main_prog.random_seed = SEED startup_prog.random_seed = SEED with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): x = paddle.static.data( name=self.feed_list[0], shape=self.feed_shape[0], dtype=self.feed_dtype[0]) conv1 = paddle.static.nn.conv2d( x, num_filters=3, filter_size=3, bias_attr=False) conv2 = paddle.static.nn.conv2d( x, num_filters=3, filter_size=3, bias_attr=False) add1 = conv1 + conv2 conv3 = paddle.static.nn.conv2d( add1, num_filters=8, filter_size=8, bias_attr=False) out = paddle.fluid.layers.relu(conv3, **self.attrs) fetch_list = [out.name] if run_ipu: place = paddle.IPUPlace() else: place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) feed = self.feed_ipu if run_ipu else self.feed_cpu if run_ipu: feed_list = self.feed_list ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = False ipu_strategy.enable_fp16 = True program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(feed_list, fetch_list) else: feed_list = self.feed_list program = main_prog result = exe.run(program, feed=feed, fetch_list=fetch_list) return result[0]
def _test_load(self, run_ipu): if run_ipu: place = paddle.IPUPlace() else: place = paddle.CPUPlace() exe = paddle.static.Executor(place) [inference_program, feed_target_names, fetch_targets ] = (paddle.static.load_inference_model(self.full_name, exe)) if run_ipu: feed_list = feed_target_names fetch_list = [fetch_targets[0].name] ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = False program = compiler.IPUCompiledProgram( inference_program, ipu_strategy=ipu_strategy).compile(feed_list, fetch_list) else: program = inference_program tmp = exe.run(program, feed=self.feed, fetch_list=[fetch_targets]) return tmp
def _test_base(self, run_ipu=True): scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() SEED = self.SEED main_prog.random_seed = SEED startup_prog.random_seed = SEED with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): x = paddle.static.data(name=self.feed_list[0], shape=self.feed_shape[0], dtype=self.feed_dtype[0]) if self.is_training: ch = self.feed_shape[0][1] conv1 = paddle.static.nn.conv2d(x, num_filters=ch, filter_size=3, bias_attr=False) scale = paddle.ParamAttr(trainable=True) bias = paddle.ParamAttr(trainable=True) out = paddle.fluid.layers.nn.group_norm(conv1, param_attr=scale, bias_attr=bias, **self.attrs) else: scale = True bias = True out = paddle.fluid.layers.nn.group_norm(x, param_attr=scale, bias_attr=bias, **self.attrs) if self.is_training: loss = paddle.mean(out) adam = paddle.optimizer.Adam(learning_rate=1e-2) adam.minimize(loss) fetch_list = [loss.name] else: fetch_list = [out.name] if run_ipu: place = paddle.IPUPlace() else: place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) if run_ipu: feed_list = self.feed_list ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = self.is_training program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(feed_list, fetch_list) else: program = main_prog if self.is_training: result = [] for _ in range(self.epoch): loss_res = exe.run(program, feed=self.feed, fetch_list=fetch_list) result.append(loss_res[0]) return np.array(result) else: result = exe.run(program, feed=self.feed, fetch_list=fetch_list) return result[0]
def _test_base(self, run_ipu=True): scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() SEED = self.SEED main_prog.random_seed = SEED startup_prog.random_seed = SEED if run_ipu: self.feed = { "x": np.array([[[1], [3]], [[2], [4]], [[4], [127]]]).astype(np.int32) } else: self.feed = { "x": np.array([[[1], [3]], [[2], [4]], [[4], [127]]]).astype(np.int64) } self.set_feed_attr() with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): x = paddle.static.data(name=self.feed_list[0], shape=self.feed_shape[0], dtype=self.feed_dtype[0]) out = paddle.fluid.layers.embedding(x, **self.attrs) if self.is_training: loss = paddle.mean(out) adam = paddle.optimizer.Adam(learning_rate=1e-2) adam.minimize(loss) fetch_list = [loss.name] else: fetch_list = [out.name] if run_ipu: place = paddle.IPUPlace() else: place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) if run_ipu: feed_list = self.feed_list ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = self.is_training program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(feed_list, fetch_list) else: program = main_prog if self.is_training: result = [] for _ in range(self.epoch): loss_res = exe.run(program, feed=self.feed, fetch_list=fetch_list) result.append(loss_res[0]) return np.array(result) else: result = exe.run(program, feed=self.feed, fetch_list=fetch_list) return result[0]
main_prog = paddle.static.default_main_program() paddle.static.save(main_prog, "model/ernie") paddle.static.load(main_prog, "model/ernie") if args.run_on_ipu: ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.num_ipus = args.num_ipus ipu_strategy.enable_manual_shard = args.num_ipus > 1 ipu_strategy.enable_pipelining = args.enable_pipelining if args.enable_pipelining: if args.is_training: ipu_strategy.batches_per_step = args.num_ipus + 1 else: ipu_strategy.batches_per_step = args.num_ipus ipu_strategy.is_training = args.is_training ipu_compiler = compiler.IPUCompiledProgram(main_prog, ipu_strategy=ipu_strategy) program = ipu_compiler.compile(feed_list, fetch_list) else: program = main_prog # executor run results = [] for i in range(total_steps): start = i * (batches_per_step if args.run_on_ipu else 1) end = start + (batches_per_step if args.run_on_ipu else 1) feed_dict = { src_ids.name: np_inputs[0][start:end], sent_ids.name: np_inputs[1][start:end], pos_ids.name: np_inputs[2][start:end], input_mask.name: np_inputs[3][start:end] }
def _test_base(self, save_otherwise_load): scope = fluid.core.Scope() main_prog = paddle.static.Program() startup_prog = paddle.static.Program() main_prog.random_seed = self.SEED startup_prog.random_seed = self.SEED generator = fluid.unique_name.UniqueNameGenerator() with fluid.unique_name.guard(generator): with fluid.scope_guard(scope): with paddle.static.program_guard(main_prog, startup_prog): x = paddle.static.data(name=self.feed_list[0], shape=self.feed_shape[0], dtype='float32') conv1 = paddle.static.nn.conv2d(x, num_filters=3, filter_size=3, bias_attr=False, name='conv2d') loss = paddle.mean(conv1) if self.attrs['is_training']: if self.attrs['opt_type'] == 'sgd': sgd = paddle.optimizer.SGD(learning_rate=1e-2) sgd.minimize(loss) elif self.attrs['opt_type'] == 'adam': adam = paddle.optimizer.Adam(learning_rate=1e-2) adam.minimize(loss) elif self.attrs['opt_type'] == 'lamb': lamb = paddle.optimizer.Lamb(learning_rate=1e-2) lamb.minimize(loss) fetch_list = [loss.name] place = paddle.IPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) if not save_otherwise_load: paddle.static.load(main_prog, "model/model") ipu_strategy = compiler.get_ipu_strategy() ipu_strategy.is_training = self.attrs['is_training'] program = compiler.IPUCompiledProgram( main_prog, ipu_strategy=ipu_strategy).compile(self.feed_list, fetch_list) result = [] run_steps = self.attrs['steps'] if save_otherwise_load \ else self.attrs['steps'] - self.attrs['save_at_step'] for i in range(run_steps): tmp = exe.run(program, feed=self.feed, fetch_list=fetch_list) # currently, we update opt state every sess.run, # will optimize if save_otherwise_load and \ i == self.attrs['save_at_step'] - 1: paddle.static.save(main_prog, "model/model") if save_otherwise_load and i >= self.attrs['save_at_step']: result.append(tmp) elif not save_otherwise_load: result.append(tmp) return np.asarray(result).flatten()