diff --git a/paddle/fluid/framework/framework.proto b/paddle/fluid/framework/framework.proto index 665adfd8cb4d9a4c286d293dcfd297d8f52d0756..efdabffb9b33ddf007c13008d0f3afb7a3961eda 100644 --- a/paddle/fluid/framework/framework.proto +++ b/paddle/fluid/framework/framework.proto @@ -13,7 +13,7 @@ See the License for the specific language governing permissions and limitations under the License. */ syntax = "proto2"; -/* option optimize_for = LITE_RUNTIME; */ +option optimize_for = LITE_RUNTIME; package paddle.framework.proto; // Any incompatible changes to ProgramDesc and its dependencies should diff --git a/paddle/fluid/imperative/layer.cc b/paddle/fluid/imperative/layer.cc index 2c615275d14e9ae99285eedcf3591fbd47080912..02d9ef866c4a8b6d46c87c812ac510cdd90810fe 100644 --- a/paddle/fluid/imperative/layer.cc +++ b/paddle/fluid/imperative/layer.cc @@ -192,7 +192,6 @@ std::vector OpBase::ApplyGrad(framework::Scope* scope) { LOG(ERROR) << "tracer doesn't support yet"; } } - VLOG(3) << "op grad output var " << outvar << " is inited"; } grad_op_desc_->InferShape(*block_); diff --git a/paddle/fluid/imperative/tracer.h b/paddle/fluid/imperative/tracer.h index c885f39ced4a213c126866704717491211164b0b..de7899055d588648d59c99853da5d820d9c0ba0d 100644 --- a/paddle/fluid/imperative/tracer.h +++ b/paddle/fluid/imperative/tracer.h @@ -52,7 +52,7 @@ class Tracer { const std::vector& outputs, framework::BlockDesc* block, const bool stop_gradient) { framework::OpDesc* op_desc = op->op_desc_; - LOG(ERROR) << "tracer tracing " << op_desc->Type(); + VLOG(3) << "tracer tracing " << op_desc->Type(); op_desc->InferShape(*block); op_desc->InferVarType(block); std::unique_ptr op_base = @@ -61,10 +61,7 @@ class Tracer { *op->input_vars_ = inputs; for (VarBase* input : inputs) { const std::string vname = input->var_desc_->Name(); - LOG(ERROR) << "input: " << vname; - LOG(ERROR) << "input var: " << input->var_; framework::Variable* var = root_scope_->Var(vname); - LOG(ERROR) << "var_ in tracer pointer: " << var; input->var_ = var; if (!var->IsInitialized()) { framework::VarDesc* var_desc = block->FindVar(vname); @@ -102,7 +99,7 @@ class Tracer { outputs[i]->pre_op_out_idx_ = i; } - LOG(ERROR) << "tracer running " << op_desc->Type(); + VLOG(3) << "tracer running " << op_desc->Type(); op_base->Run(*root_scope_, platform::CPUPlace()); if (!stop_gradient) { framework::OpDesc* grad_op_desc; diff --git a/paddle/fluid/operators/optimizers/sgd_op.h b/paddle/fluid/operators/optimizers/sgd_op.h index ec4218497a76c15f36827ca4bf432a4d796aeee8..98bae5e1d329005f9463fd7bb0751c44952dea88 100644 --- a/paddle/fluid/operators/optimizers/sgd_op.h +++ b/paddle/fluid/operators/optimizers/sgd_op.h @@ -29,8 +29,6 @@ class SGDOpKernel : public framework::OpKernel { const auto *param_var = ctx.InputVar("Param"); const auto *grad_var = ctx.InputVar("Grad"); - LOG(ERROR) << "grad_var: " << grad_var; - if (param_var->IsType()) { const auto *param = ctx.Input("Param"); auto *param_out = ctx.Output("ParamOut"); @@ -41,11 +39,8 @@ class SGDOpKernel : public framework::OpKernel { const auto *grad = ctx.Input("Grad"); auto p = framework::EigenVector::Flatten(*param); - LOG(ERROR) << "param flattened"; auto g = framework::EigenVector::Flatten(*grad); - LOG(ERROR) << "grad flattened"; auto o = framework::EigenVector::Flatten(*param_out); - LOG(ERROR) << "paramout flattened"; auto *lr = learning_rate->data(); o = p - lr[0] * g; diff --git a/paddle/fluid/pybind/pybind.cc b/paddle/fluid/pybind/pybind.cc index c690d1b8b341b7a4747bc2e9fb44c17bc3da8750..6c74eef07a9429e00c2dced04878cd34ad399880 100644 --- a/paddle/fluid/pybind/pybind.cc +++ b/paddle/fluid/pybind/pybind.cc @@ -117,19 +117,14 @@ PYBIND11_MODULE(core, m) { [](imperative::VarBase &self, framework::Scope *scope) { self.RunBackward(scope); }) - .def("_grad_var", - [](const imperative::VarBase &self) { - LOG(ERROR) << "grad_var_ pointer: " << self.grads_; - return self.grads_; - }, - py::return_value_policy::reference) .def("_grad_name", &imperative::VarBase::GradName) .def("_grad", &imperative::VarBase::Grad) - .def("_print_var_pointer", - [](const imperative::VarBase &self) { - LOG(ERROR) << self.var_desc_->Name() - << " print_var pointer: " << self.var_; - }) + .def_property("grad_value", + [](const imperative::VarBase &self) { return self.grads_; }, + [](imperative::VarBase &self, framework::Variable *grad) { + self.grads_ = grad; + }, + py::return_value_policy::reference) .def_property("value", [](const imperative::VarBase &self) { return self.var_; }, [](imperative::VarBase &self, framework::Variable *var) { diff --git a/python/paddle/fluid/framework.py b/python/paddle/fluid/framework.py index 9073fa79b0ca6efc46daadfc4e2de1075d68aea6..6c5dd844601cbfb6c0e6e453928d0426357cfd93 100644 --- a/python/paddle/fluid/framework.py +++ b/python/paddle/fluid/framework.py @@ -361,6 +361,7 @@ class Variable(object): self.block.vars[name] = self self.op = None + self.stop_gradient = stop_gradient self.is_data = is_data if _in_imperative_mode(): self._ivar = core.VarBase() @@ -368,7 +369,6 @@ class Variable(object): self._ivar.stop_gradient = stop_gradient def _numpy(self): - print("get_variable_tensor", self.desc.name()) scope = _imperative_tracer().get_scope() tensor = core.get_variable_tensor(scope, self.desc.name()) return np.array(tensor) @@ -597,8 +597,7 @@ class Operator(object): type=None, inputs=None, outputs=None, - attrs=None, - stop_gradient=False): + attrs=None): self.block = block self.desc = desc # note: not add self.attrs here: @@ -640,7 +639,6 @@ class Operator(object): if inputs is not None: for in_proto in proto.inputs: - print("create op: find_name", in_proto.name) found = find_name(inputs, in_proto.name) assert found or in_proto.dispensable, "Input {} not found".format( in_proto.name) @@ -1178,7 +1176,6 @@ class Block(object): def create_var(self, *args, **kwargs): var = Variable(block=self, *args, **kwargs) if 'initializer' in kwargs: - print("initializer, ", type(kwargs['initializer'])) kwargs['initializer'](var, self) return var @@ -1293,16 +1290,6 @@ class Block(object): """ op_desc = self.desc.append_op() op = Operator(block=self, desc=op_desc, *args, **kwargs) - print("op inputs: ", [v._numpy() for v in op.inputs]) - print("op inputs: ", [v for v in op.inputs]) - import sys - sys.stdout.flush() - for v in op.inputs: - v._ivar._print_var_pointer() - print("print var pointer end") - import sys - sys.stdout.flush() - if _in_imperative_mode(): _imperative_tracer().trace(op.iop, [v._ivar for v in op.inputs], [v._ivar for v in op.outputs], self.desc, @@ -1360,10 +1347,6 @@ class Block(object): _imperative_tracer().trace(op.iop, [v._ivar for v in op.inputs], [v._ivar for v in op.outputs], self.desc, kwargs.get("stop_gradient", False)) - print([v.name for v in op.outputs]) - for v in op.outputs: - v._ivar._print_var_pointer() - print("fill_constant end") self.ops.insert(0, op) return op diff --git a/python/paddle/fluid/initializer.py b/python/paddle/fluid/initializer.py index fe8357aa06acd26c7d185f8e5b75c0824fc364c2..7acaed2250520bea58d2597741a8fa43bcdef5ea 100644 --- a/python/paddle/fluid/initializer.py +++ b/python/paddle/fluid/initializer.py @@ -153,7 +153,6 @@ class ConstantInitializer(Initializer): assert isinstance(var, framework.Variable) assert isinstance(block, framework.Block) # Initialization Ops should be prepended and not appended - print("fill_constant") op = block._prepend_op( type="fill_constant", outputs={"Out": var}, diff --git a/python/paddle/fluid/layer_helper.py b/python/paddle/fluid/layer_helper.py index f3413d7296dd80b2d793459e992fe494ab5da438..8a8470db46eaf8855473b18d023dfe3c7a97da15 100644 --- a/python/paddle/fluid/layer_helper.py +++ b/python/paddle/fluid/layer_helper.py @@ -22,6 +22,7 @@ import numpy as np from .framework import Variable, Parameter, default_main_program, default_startup_program, dtype_is_floating from . import unique_name +from paddle.fluid.imperative import base as imperative_base from paddle.fluid.imperative.base import to_variable from paddle.fluid.initializer import Constant, Xavier from .param_attr import ParamAttr, WeightNormParamAttr @@ -369,13 +370,16 @@ class LayerHelper(object): def set_variable_initializer(self, var, initializer): assert isinstance(var, Variable) - return self.startup_program.global_block().create_var( - name=var.name, - type=var.type, - dtype=var.dtype, - shape=var.shape, - persistable=True, - initializer=initializer) + if imperative_base.enabled(): + initializer(var, self.startup_program.global_block()) + else: + self.startup_program.global_block().create_var( + name=var.name, + type=var.type, + dtype=var.dtype, + shape=var.shape, + persistable=True, + initializer=initializer) def append_bias_op(self, input_var, dim_start=1, dim_end=None): """ diff --git a/python/paddle/fluid/layers/tensor.py b/python/paddle/fluid/layers/tensor.py index a7565aa108b10584a911cd0ffe017569fbe381b8..fcad14c74857fe8c34eb2ee994791cd9a92976f2 100644 --- a/python/paddle/fluid/layers/tensor.py +++ b/python/paddle/fluid/layers/tensor.py @@ -132,16 +132,9 @@ def create_global_var(shape, persistable=persistable, name=name, stop_gradient=True) - print("set_variable_initializer, ", var.name) - if imperative_base.enabled(): - var = helper.set_variable_initializer( - var, initializer=Constant( - value=float(value), force_cpu=force_cpu)) - print("get var", var) - else: - helper.set_variable_initializer( - var, initializer=Constant( - value=float(value), force_cpu=force_cpu)) + helper.set_variable_initializer( + var, initializer=Constant( + value=float(value), force_cpu=force_cpu)) return var diff --git a/python/paddle/fluid/optimizer.py b/python/paddle/fluid/optimizer.py index ba3902bcb7415ded0f7e5ff96ea19972b933fabd..5a13ee536810cd065b7b050f4c82a8ecb6fd4432 100644 --- a/python/paddle/fluid/optimizer.py +++ b/python/paddle/fluid/optimizer.py @@ -109,7 +109,6 @@ class Optimizer(object): # create learning rate variable for every parameter param = param_and_grad[0] param_lr = param.optimize_attr['learning_rate'] - print("param_lr: ", param_lr, self._global_learning_rate()._numpy()) if type(param_lr) == Variable: return param_lr else: @@ -311,15 +310,12 @@ class Optimizer(object): parameters = program.global_block().all_parameters() params_grads = [] for param in parameters: + # create gradient variable grad_var = Variable( block=loss.block, name=param._ivar._grad_name(), stop_gradient=True) grad_var._value = param._ivar._grad_var() - print("create grad var: ", grad_var.name) - print("grad_var value: ", grad_var._numpy()) - import sys - sys.stdout.flush() params_grads.append((param, grad_var)) optimize_ops = self._create_optimization_pass(params_grads, loss, @@ -381,10 +377,6 @@ class SGDOptimizer(Optimizer): def _append_optimize_op(self, block, param_and_grad): assert isinstance(block, framework.Block) - print("append sgd") - import sys - sys.stdout.flush() - # create the optimize op sgd_op = block.append_op( type=self.type,