diff --git a/paddle/fluid/framework/details/async_ssa_graph_executor.cc b/paddle/fluid/framework/details/async_ssa_graph_executor.cc index 9615347d5478873aa000b6320f35040cc9537243..1cf4eb6c2989346c9e9acef648aa74615c7bcb10 100644 --- a/paddle/fluid/framework/details/async_ssa_graph_executor.cc +++ b/paddle/fluid/framework/details/async_ssa_graph_executor.cc @@ -42,53 +42,18 @@ inline void InitVarsInScope(const std::vector &var_infos, Scope *scope, } } -// get RpcContext and remote send and recv op +// get CommContext and remote send and recv op void ProcessGraph(std::vector graphs, Scope *scope) { #ifdef PADDLE_WITH_DISTRIBUTE - using RpcCtxMap = operators::distributed::RpcCtxMap; - VLOG(3) << "ProcessGraph"; - RpcCtxMap send_varname_to_ctx; - - for (auto &node : graphs[0]->Nodes()) { - VLOG(3) << "node name " << node->Name(); - if (node && node->IsOp()) { - if (node->Name() == "send") { - auto send_var_name = node->Op()->Input("X")[0]; - auto send_varnames = - BOOST_GET_CONST(std::vector, - node->Op()->GetNullableAttr("send_varnames")); - auto epmap = BOOST_GET_CONST(std::vector, - node->Op()->GetNullableAttr("epmap")); - auto height_section = BOOST_GET_CONST( - std::vector, node->Op()->GetNullableAttr("sections")); - auto trainer_id = - BOOST_GET_CONST(int, node->Op()->GetNullableAttr("trainer_id")); - auto merge_add = - BOOST_GET_CONST(bool, node->Op()->GetNullableAttr("merge_add")); - if (!merge_add) { - merge_add = FLAGS_communicator_is_sgd_optimizer; - } - auto use_send_handler = BOOST_GET_CONST( - bool, node->Op()->GetNullableAttr("use_send_handler")); - send_varname_to_ctx[send_var_name] = operators::distributed::RpcContext( - send_var_name, send_varnames, epmap, height_section, trainer_id, - merge_add, use_send_handler); - VLOG(3) << "find and init an send op: " - << send_varname_to_ctx[send_var_name]; - } - } - } - // init communicator here - if (send_varname_to_ctx.size() > 0) { - auto *instance = operators::distributed::Communicator::GetInstance(); - auto initialized = instance ? true : false; - PADDLE_ENFORCE_EQ(initialized, true, - platform::errors::InvalidArgument( - "Communicator is not Initialized, you may use " - "FleetAPI(https://github.com/PaddlePaddle/Fleet/tree/" - "develop/markdown_doc/transpiler)")); - } + auto *instance = operators::distributed::Communicator::GetInstance(); + auto initialized = instance ? true : false; + PADDLE_ENFORCE_EQ(initialized, true, + platform::errors::InvalidArgument( + "Communicator is not Initialized, you may use " + "FleetAPI(https://github.com/PaddlePaddle/Fleet/tree/" + "develop/markdown_doc/transpiler)")); + #endif } diff --git a/paddle/fluid/framework/selected_rows.h b/paddle/fluid/framework/selected_rows.h index f8a40a5d99a44bce11e4e952aaf958e9ac7823f4..5f733139419dbc1769d9eb4efe7e793f8fb2752f 100644 --- a/paddle/fluid/framework/selected_rows.h +++ b/paddle/fluid/framework/selected_rows.h @@ -122,7 +122,7 @@ class SelectedRows { /* * @brief Get the index of the key from id_to_index_ map. */ - inline int64_t GetIndexFromId(int64_t key) { + inline int64_t GetIndexFromId(int64_t key) const { auto iter = id_to_index_.find(key); if (iter == id_to_index_.end()) { return -1; diff --git a/paddle/fluid/framework/variable_helper.cc b/paddle/fluid/framework/variable_helper.cc index 34adbbc0abc879f305618bbd1f3a159600c3496c..67e17410a29aff435921f46eeb2691a025d5a9eb 100644 --- a/paddle/fluid/framework/variable_helper.cc +++ b/paddle/fluid/framework/variable_helper.cc @@ -79,5 +79,6 @@ void CopyVariable(const Variable &src_var, Variable *dst_var) { PADDLE_THROW("unknown var type to copy"); } } + } // namespace framework } // namespace paddle diff --git a/paddle/fluid/framework/variable_helper.h b/paddle/fluid/framework/variable_helper.h index 5a2c267b7388f6c2de89054dc480fd74b4544bed..01a5d09e0728b2af6e9bf650f0d58af43a9a53ab 100644 --- a/paddle/fluid/framework/variable_helper.h +++ b/paddle/fluid/framework/variable_helper.h @@ -13,8 +13,11 @@ See the License for the specific language governing permissions and limitations under the License. */ #pragma once +#include + #include "paddle/fluid/framework/framework.pb.h" #include "paddle/fluid/framework/variable.h" + namespace paddle { namespace framework { diff --git a/paddle/fluid/operators/distributed/CMakeLists.txt b/paddle/fluid/operators/distributed/CMakeLists.txt index 5aa91733fe3ed1bfc51b47b331488ce2211be2fb..f35ccefa7ffa24f9e86a5d2edddf4585121dcc2a 100644 --- a/paddle/fluid/operators/distributed/CMakeLists.txt +++ b/paddle/fluid/operators/distributed/CMakeLists.txt @@ -13,6 +13,7 @@ cc_library(async_sparse_param_update_recorder SRCS async_sparse_param_update_rec cc_test(async_sparse_param_update_recorder_test SRCS async_sparse_param_update_recorder_test.cc DEPS async_sparse_param_update_recorder) cc_library(heart_beat_monitor SRCS heart_beat_monitor.cc DEPS enforce simple_threadpool) +cc_library(large_scale_kv SRCS large_scale_kv.cc DEPS enforce simple_threadpool) cc_test(heart_beat_monitor_test SRCS heart_beat_monitor_test.cc DEPS heart_beat_monitor) # FIXME(typhoonzero): use add_subdirectory once we clean the dependency of these files @@ -26,7 +27,7 @@ if(WITH_GRPC) collective_client.cc collective_server.cc ${GRPC_SRCS} PROTO send_recv.proto - DEPS lod_tensor selected_rows_functor memory scope ${GRPC_DEPS} async_sparse_param_update_recorder heart_beat_monitor) + DEPS lod_tensor selected_rows_functor memory scope ${GRPC_DEPS} async_sparse_param_update_recorder heart_beat_monitor large_scale_kv) set_source_files_properties(grpc_serde_test.cc rpc_server_test.cc PROPERTIES COMPILE_FLAGS ${DISTRIBUTE_COMPILE_FLAGS}) set(RPC_DEPS sendrecvop_rpc ${GRPC_DEPS}) @@ -50,12 +51,12 @@ else() set(RPC_DEPS sendrecvop_rpc ${BRPC_DEPS}) cc_test(brpc_serde_test SRCS brpc/brpc_serde_test.cc - DEPS ${RPC_DEPS} gflags glog executor proto_desc lookup_sparse_table_op) + DEPS ${RPC_DEPS} gflags glog executor proto_desc lookup_sparse_table_read_op) endif() cc_test(rpc_server_test SRCS rpc_server_test.cc - DEPS ${RPC_DEPS} executor scope proto_desc lookup_sparse_table_op) + DEPS ${RPC_DEPS} executor scope proto_desc lookup_sparse_table_read_op) cc_test(varhandle_test SRCS varhandle_test.cc DEPS profiler scope) cc_library(parameter_prefetch SRCS parameter_prefetch.cc DEPS sendrecvop_rpc memory) cc_library(parameter_send SRCS parameter_send.cc DEPS sendrecvop_rpc memory) diff --git a/paddle/fluid/operators/distributed/brpc/brpc_client.cc b/paddle/fluid/operators/distributed/brpc/brpc_client.cc index 32612e63e7dc798b5c51456fb13a32eb60b35d18..cb93b8d910a2353b8c9a1e793338fa5d50a93165 100644 --- a/paddle/fluid/operators/distributed/brpc/brpc_client.cc +++ b/paddle/fluid/operators/distributed/brpc/brpc_client.cc @@ -446,11 +446,12 @@ VarHandlePtr BRPCClient::AsyncSendMessage(const std::string& ep, } VarHandlePtr BRPCClient::AsyncCheckpointNotify(const std::string& ep, - const std::string& dir, + const std::string& dirname, + const std::string& varname, int64_t time_out) { sendrecv::VariableMessage req; - req.set_varname(CHECKPOINT_SAVE_MESSAGE); - req.set_out_varname(dir); + req.set_varname(varname); + req.set_out_varname(dirname); return AsyncSendVarMessage(ep, "CheckPointNotifyRPC", req, time_out); } diff --git a/paddle/fluid/operators/distributed/brpc/brpc_client.h b/paddle/fluid/operators/distributed/brpc/brpc_client.h index 51864dfdca53eb4b1d9045188a6347781130e785..2ea90d560f5685e19a8f16d15d07414c927001ba 100644 --- a/paddle/fluid/operators/distributed/brpc/brpc_client.h +++ b/paddle/fluid/operators/distributed/brpc/brpc_client.h @@ -102,7 +102,8 @@ class BRPCClient : public RPCClient { const std::string& ep, int64_t time_out = FLAGS_rpc_deadline) override; VarHandlePtr AsyncCheckpointNotify( - const std::string& ep, const std::string& dir, + const std::string& ep, const std::string& dirname, + const std::string& varname, int64_t time_out = FLAGS_rpc_deadline) override; bool Wait() override; diff --git a/paddle/fluid/operators/distributed/communicator.cc b/paddle/fluid/operators/distributed/communicator.cc index 19187d01f55d016fde5c068df78f45fd880209f5..b2cc9390fa2267404ac246c6b36800833d0dd679 100644 --- a/paddle/fluid/operators/distributed/communicator.cc +++ b/paddle/fluid/operators/distributed/communicator.cc @@ -15,6 +15,7 @@ limitations under the License. */ #include "paddle/fluid/operators/distributed/communicator.h" #include #include +#include #include // NOLINT #include #include // NOLINT @@ -44,21 +45,8 @@ inline double GetCurrentUS() { return 1e+6 * time.tv_sec + time.tv_usec; } -template -inline void VSUB(int n, const T *x, const T *y, T *z) { - for (int i = 0; i < n; ++i) { - z[i] = x[i] - y[i]; - } -} - Communicator::Communicator() {} -Communicator::Communicator(const std::map &envs_) { - for (auto &iter : envs_) { - envs[iter.first] = iter.second; - } -} - std::once_flag Communicator::init_flag_; std::shared_ptr Communicator::communicator_(nullptr); @@ -88,182 +76,150 @@ void AsyncCommunicator::InitImpl(const RpcCtxMap &send_varname_to_ctx, } } -void AsyncCommunicator::InitImpl(const paddle::framework::ProgramDesc &program, - Scope *param_scope) { - RpcCtxMap send_varname_to_ctx; - RpcCtxMap recv_varname_to_ctx; - for (auto *op : program.Block(0).AllOps()) { - VLOG(3) << "node name " << op->Type(); - if (op->Type() == "send") { - auto send_var_name = op->Input("X")[0]; - auto send_varnames = BOOST_GET_CONST( - std::vector, op->GetNullableAttr("send_varnames")); - auto epmap = BOOST_GET_CONST(std::vector, - op->GetNullableAttr("epmap")); - auto height_section = BOOST_GET_CONST(std::vector, - op->GetNullableAttr("sections")); - auto trainer_id = BOOST_GET_CONST(int, op->GetNullableAttr("trainer_id")); - auto merge_add = BOOST_GET_CONST(bool, op->GetNullableAttr("merge_add")); - if (!merge_add) { - merge_add = is_sgd_optimizer_; - } - auto use_send_handler = - BOOST_GET_CONST(bool, op->GetNullableAttr("use_send_handler")); - send_varname_to_ctx[send_var_name] = operators::distributed::RpcContext( - send_var_name, send_varnames, epmap, height_section, trainer_id, - merge_add, use_send_handler); - VLOG(3) << "find and init an send op: " - << send_varname_to_ctx[send_var_name]; - } else if (op->Type() == "recv") { - auto do_not_run = BOOST_GET_CONST(int, op->GetNullableAttr("do_not_run")); - PADDLE_ENFORCE_GT(do_not_run, 0, - platform::errors::InvalidArgument( - "recv op's attr `do_not_run` must be True!")); - auto recv_var_name = op->Output("Out")[0]; - auto recv_varnames = BOOST_GET_CONST( - std::vector, op->GetNullableAttr("recv_varnames")); - auto epmap = BOOST_GET_CONST(std::vector, - op->GetNullableAttr("epmap")); - auto trainer_id = BOOST_GET_CONST(int, op->GetNullableAttr("trainer_id")); - recv_varname_to_ctx[recv_var_name] = operators::distributed::RpcContext( - recv_var_name, recv_varnames, epmap, {}, trainer_id); - } +AsyncCommunicator::~AsyncCommunicator() { + running_ = false; + if (main_thread_) main_thread_->join(); +} + +void AsyncCommunicator::SendGlobalStep(int batches) { + if (!need_global_step_) { + return; } - // init communicator here - if (send_varname_to_ctx.size() == 0 && recv_varname_to_ctx.size() == 0) { - LOG(WARNING) << "no var need to send and recv!!"; + if (batches == 0) { + return; } - operators::distributed::AsyncCommunicator::InitImpl( - send_varname_to_ctx, recv_varname_to_ctx, param_scope); -} + auto &var_name = STEP_COUNTER; + auto *out_var = send_scope_->Var(var_name); + auto *out_t = out_var->GetMutable(); + auto *data = out_t->mutable_data({1}, platform::CPUPlace()); + data[0] = static_cast(batches); -AsyncCommunicator::~AsyncCommunicator() { - running_ = false; - if (send_thread_) send_thread_->join(); - if (recv_thread_) recv_thread_->join(); + auto &ctx = send_varname_to_ctx_.at(var_name); + auto send_functor = distributed::ParameterSend(); + send_functor(ctx, *send_scope_, true, 1); } -void AsyncCommunicator::SendThread() { - VLOG(3) << "SendThread start!"; - while (running_) { - std::vector> task_futures; - task_futures.reserve(send_varname_to_ctx_.size()); - VLOG(4) << "run send graph"; - auto before_run_send_graph = GetCurrentUS(); - for (auto &iter : send_varname_to_queue_) { - auto &var_name = iter.first; - auto &var_queue = iter.second; - if (var_queue->Size() > 0) { - auto send_task = [this, &var_name, &var_queue] { - VLOG(4) << var_name << " merge and send"; - std::vector> vars; - int merged_var_num = 0; - int wait_times = 0; - while (merged_var_num < max_merge_var_num_) { - if (var_queue->Size() == 0) { - VLOG(4) << "wait_times -> " << wait_times; - if (wait_times >= send_wait_times_) { - break; - } - std::this_thread::sleep_for(std::chrono::milliseconds(10)); - wait_times++; - continue; - } else { - wait_times = 0; - - vars.push_back(var_queue->Pop()); - // only count the send number of the first var - if (var_name == send_varname_to_queue_.begin()->first) { - grad_num_.fetch_add(1, std::memory_order_relaxed); - } - merged_var_num++; - } - } - auto before_merge = GetCurrentUS(); - auto &ctx = send_varname_to_ctx_.at(var_name); - if (ctx.use_send_handler) { - MergeVars(var_name, vars, send_scope_.get(), ctx.merge_add); - } else { - MergeVars(var_name, vars, send_scope_.get(), - ctx.merge_add); - } - auto after_merge = GetCurrentUS(); - VLOG(4) << "merge " << merged_var_num << " " << var_name - << " use time " << after_merge - before_merge; - auto send_functor = distributed::ParameterSend(); - send_functor(ctx, *send_scope_, true, 1); - auto after_send = GetCurrentUS(); - VLOG(4) << "send " << var_name << " use time " - << after_send - after_merge; - }; - task_futures.emplace_back( - send_threadpool_->enqueue(std::move(send_task))); - } else { - VLOG(4) << var_name << " queue empty"; +void AsyncCommunicator::SendByCommunicator(int batches) { + std::vector> task_futures; + task_futures.reserve(send_varname_to_ctx_.size()); + VLOG(3) << "run send graph"; + auto before_run_send_graph = GetCurrentUS(); + for (auto &iter : send_varname_to_queue_) { + auto &var_name = iter.first; + auto &var_queue = iter.second; + + auto send_task = [this, batches, &var_name, &var_queue] { + if (var_name == STEP_COUNTER) { + return; } - } - for (auto &task_f : task_futures) { - task_f.wait(); - } - auto after_run_send_graph = GetCurrentUS(); - VLOG(4) << "run send graph use time " - << after_run_send_graph - before_run_send_graph; - Recv(); - } - VLOG(1) << "communicator stopped, send thread exit"; -} + VLOG(3) << var_name << " merge and send"; + std::vector> vars; + vars.reserve(batches); -void AsyncCommunicator::RecvThread() { - VLOG(3) << "RecvThread start!"; - while (running_) { - int grad_num = grad_num_.load(); - if (grad_num > min_send_grad_num_before_recv_) { - RecvAll(); - grad_num_.store(0); - } else { - std::this_thread::sleep_for(std::chrono::milliseconds(10)); - } + for (int i = 0; i < batches; ++i) { + vars.push_back(var_queue->Pop()); + } + + auto &ctx = send_varname_to_ctx_.at(var_name); + + auto before_merge = GetCurrentUS(); + MergeVars(var_name, vars, send_scope_.get(), ctx.merge_add); + auto after_merge = GetCurrentUS(); + VLOG(3) << "merge " << batches << " " << var_name << " use time " + << after_merge - before_merge; + + auto send_functor = distributed::ParameterSend(); + send_functor(ctx, *send_scope_, true, 1); + auto after_send = GetCurrentUS(); + VLOG(3) << "send " << var_name << " use time " + << after_send - after_merge; + }; + task_futures.emplace_back(send_threadpool_->enqueue(std::move(send_task))); } - VLOG(1) << "communicator stopped, recv thread exit"; + for (auto &task_f : task_futures) { + task_f.wait(); + } + auto after_run_send_graph = GetCurrentUS(); + + VLOG(3) << "run send graph use time " + << after_run_send_graph - before_run_send_graph; } -void AsyncCommunicator::Recv() { - if (independent_recv_thread_) { - return; +void AsyncCommunicator::MainThread() { + VLOG(3) << "MainThread start and wait"; + + while (waiting_ && running_) { + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + VLOG(3) << "wait for running"; } - auto grad_num = grad_num_.load(); - if (grad_num > 0) { - RecvAll(); - grad_num_.store(0); - } else { - std::this_thread::sleep_for(std::chrono::milliseconds(10)); + while (running_) { + int meet = Meet(); + + VLOG(1) << "async_meet: " << meet; + + SendGlobalStep(meet); + SendByCommunicator(meet); + BarrierSend(); + RecvByCommunicator(); + BarrierRecv(); + BarrierWeakUp(); } + VLOG(1) << "communicator stopped, send thread exit"; } -void AsyncCommunicator::RecvAll() { +void AsyncCommunicator::RecvByCommunicator() { VLOG(3) << "parallel run recv graph"; if (!running_) return; - auto before_send = GetCurrentUS(); + RecvNoBarrier(); + VLOG(3) << "run recv graph use time"; +} + +void AsyncCommunicator::RecvNoBarrier() { std::vector> task_futures; task_futures.reserve(recv_varname_to_ctx_.size()); + for (auto &iter : recv_varname_to_ctx_) { auto recv_task = [this, &iter] { auto &var_name = iter.first; VLOG(4) << "recv var " << var_name; auto recv_functor = distributed::ParameterRecv(); - recv_functor(iter.second, *recv_scope_); + recv_functor(iter.second, *recv_scope_, false); }; task_futures.emplace_back(recv_threadpool_->enqueue(std::move(recv_task))); } + for (auto &task : task_futures) { task.wait(); } - auto after_recv = GetCurrentUS(); - VLOG(3) << "run recv graph use time " << after_recv - before_send; +} + +int AsyncCommunicator::Meet() { + auto &step_queue = send_varname_to_queue_.at(STEP_COUNTER); + + size_t merged_var_num = 0; + size_t wait_times = 0; + + while (merged_var_num < static_cast(max_merge_var_num_)) { + if (step_queue->Size() == 0) { + VLOG(3) << "wait_times -> " << wait_times; + if (wait_times >= static_cast(send_wait_times_)) { + break; + } + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + wait_times++; + continue; + } else { + step_queue->Pop(); + wait_times = 0; + merged_var_num++; + } + } + + return merged_var_num; } void AsyncCommunicator::Start() { @@ -272,14 +228,12 @@ void AsyncCommunicator::Start() { VLOG(0) << "Communicator is not inited, do nothing"; } else { VLOG(1) << "start send thread and recv thread"; + waiting_ = true; running_ = true; + BarrierTriggerReset(max_merge_var_num_); // start send and recv thread - send_thread_.reset( - new std::thread(std::bind(&AsyncCommunicator::SendThread, this))); - if (independent_recv_thread_) { - recv_thread_.reset( - new std::thread(std::bind(&AsyncCommunicator::RecvThread, this))); - } + main_thread_.reset( + new std::thread(std::bind(&AsyncCommunicator::MainThread, this))); } } @@ -289,15 +243,10 @@ void AsyncCommunicator::Stop() { if (!communicator_) { VLOG(0) << "Communicator is not inited, do nothing"; } else { - if (send_thread_) { + if (main_thread_) { VLOG(1) << "stop send thread"; - send_thread_->join(); - send_thread_.reset(nullptr); - } - if (recv_thread_) { - VLOG(1) << "stop recv thread"; - recv_thread_->join(); - recv_thread_.reset(nullptr); + main_thread_->join(); + main_thread_.reset(nullptr); } } VLOG(1) << "Communicator stop done"; @@ -306,964 +255,553 @@ void AsyncCommunicator::Stop() { void AsyncCommunicator::Send(const std::vector &var_names, const std::vector &var_tables, const framework::Scope &scope) { + waiting_ = false; + PADDLE_ENFORCE_EQ( - var_names.size(), 1, - platform::errors::InvalidArgument("var_names.size() == 1 is permitted")); - auto var_name = var_names[0]; - // push var into send queue by var_name - auto *grad_var = scope.FindVar(var_name); - PADDLE_ENFORCE_EQ( - grad_var->IsInitialized(), true, - platform::errors::InvalidArgument("grad var should be inited")); - - auto tmp_grad_var = std::make_shared(); - framework::CopyVariable(*grad_var, tmp_grad_var.get()); - auto &queue = send_varname_to_queue_.at(var_name); - VLOG(3) << "send " << var_name << " queue size " << queue->Size(); - queue->Push(tmp_grad_var); + var_tables.size(), 1, + platform::errors::InvalidArgument("var_tables.size() == 1 is permitted")); + + auto table_name = var_tables[0]; + auto &queue = send_varname_to_queue_.at(table_name); + + if (table_name == STEP_COUNTER) { + auto tmp_var = std::make_shared(); + auto *tensor = tmp_var->GetMutable(); + tensor->Resize(framework::make_ddim({1})); + auto *out_d = tensor->mutable_data(platform::CPUPlace()); + out_d[0] = 1; + VLOG(3) << "send to " << table_name << " with queue size " << queue->Size(); + queue->Push(tmp_var); + } else { + PADDLE_ENFORCE_GE(var_names.size(), 1, + platform::errors::InvalidArgument( + "var_names.size() >= 1 is permitted")); + + auto *var = scope.FindVar(var_names[0]); + + PADDLE_ENFORCE_EQ( + var->IsInitialized(), true, + platform::errors::InvalidArgument("grad var should be inited")); + + auto tmp_var = std::make_shared(); + if (var->IsType()) { + framework::CopyVariable(*var, tmp_var.get()); + VLOG(3) << "send to " << table_name << " with queue size " + << queue->Size(); + queue->Push(tmp_var); + } else if (var->IsType()) { + // push var into send queue by var_name + auto var_name = var_names[0]; + framework::CopyVariable(*var, tmp_var.get()); + VLOG(3) << "send to " << table_name << " with queue size " + << queue->Size(); + queue->Push(tmp_var); + } else { + PADDLE_THROW(platform::errors::InvalidArgument( + "unknown var type to copy, only support LoDTensor/SelectedRows")); + } + } } -GeoSgdCommunicator::~GeoSgdCommunicator() { - running_ = false; - if (send_thread_) send_thread_->join(); -} +void HalfAsyncCommunicator::Clean() { + for (auto &iter : send_varname_to_queue_) { + auto &var_name = iter.first; + auto &var_queue = iter.second; -void GeoSgdCommunicator::InitImpl(const paddle::framework::ProgramDesc &program, - Scope *recv_scope) { - training_scope_ = std::move(recv_scope); - - auto geo_send_varnames = envs["geo_send_varnames"]; - auto varnames = paddle::string::Split(geo_send_varnames, '#'); - - for (auto &var_name : varnames) { - auto var_attr_str = envs.at(var_name); - auto var_attrs = paddle::string::Split(var_attr_str, '#'); - auto split_varnames = paddle::string::Split(var_attrs[0], '&'); - auto sections = paddle::string::Split(var_attrs[1], '&'); - auto endpoints = paddle::string::Split(var_attrs[2], '&'); - bool is_sparse = static_cast(std::stoi(var_attrs[3])); - - std::string send_var_name = VarToDeltaVar(var_name); - std::vector send_var_names; - for (auto origin_var_name : split_varnames) { - send_var_names.push_back(VarToDeltaVar(origin_var_name)); + while (var_queue->Size() > 0) { + var_queue->Pop(); } - std::vector vars_sections_int = {}; - for (std::string str : sections) { - int64_t str2i = std::stol(str.c_str()); - vars_sections_int.push_back(str2i); + VLOG(3) << "clean var: " << var_name << " done"; + } +} + +int HalfAsyncCommunicator::Meet() { + while (running_) { + if (barrier_counter_.load() >= barrier_trigger_.load() && + barrier_trigger_.load() != 0) { + break; + } else { + std::this_thread::sleep_for(std::chrono::milliseconds(10)); } + } - var_list_[var_name] = is_sparse; - send_varname_to_ctx_[send_var_name] = operators::distributed::RpcContext( - send_var_name, send_var_names, endpoints, vars_sections_int, 0); - recv_varname_to_ctx_[var_name] = operators::distributed::RpcContext( - var_name, split_varnames, endpoints, vars_sections_int, 0); + return barrier_counter_.load(); +} - absolute_section_[var_name] = operators::ToAbsoluteSection( - send_varname_to_ctx_[send_var_name].height_sections); +void HalfAsyncCommunicator::Barrier() { + barrier_counter_++; - vars_first_dimension_[var_name] = 0; - for (int64_t section : vars_sections_int) { - vars_first_dimension_[var_name] += section; - } - send_var_nums_ += split_varnames.size(); + if (!running_) { + VLOG(3) << "Communicator is not running, release barrier"; + return; } - if (send_varname_to_ctx_.size() == 0 && recv_varname_to_ctx_.size() == 0) { - LOG(WARNING) << "no var need to send and recv!!"; + { + std::unique_lock lk(barrier_mutex_); + barrier_cond_.wait(lk, [this] { return (barrier_counter_ == 0); }); } +} - send_threadpool_.reset(new ::ThreadPool(thread_pool_size_)); - need_push_queue_ = - std::make_shared>>( - geo_need_push_nums_); - delta_scope_.reset(new Scope()); - old_scope_.reset(new Scope()); - pserver_scope_.reset(new Scope()); +void HalfAsyncCommunicator::BarrierTriggerDecrement() { + barrier_trigger_--; + VLOG(3) << "BarrierTriggerDecrement decrement barrier trigger to " + << barrier_trigger_.load(); } -void GeoSgdCommunicator::Start() { - VLOG(1) << "Geo Sgd Communicator start"; - if (!communicator_) { - VLOG(0) << "Geo Sgd Communicator is not inited, do nothing"; - } else { - VLOG(1) << "start send thread "; - running_ = true; - // start send and recv thread - send_thread_.reset( - new std::thread(std::bind(&GeoSgdCommunicator::SendThread, this))); - } +void HalfAsyncCommunicator::BarrierTriggerReset(int initial_val) { + barrier_trigger_.store(initial_val); + + VLOG(3) << "BarrierTriggerReset reset barrier trigger to " + << barrier_trigger_.load(); } -void GeoSgdCommunicator::Stop() { - VLOG(1) << "Geo Sgd Communicator stop"; - running_ = false; - if (!communicator_) { - VLOG(0) << "Geo Sgd Communicator is not inited, do nothing"; - } else { - if (send_thread_) { - VLOG(1) << "stop send thread"; - send_thread_->join(); - send_thread_.reset(nullptr); - } +void HalfAsyncCommunicator::BarrierWeakUp() { + barrier_counter_.store(0); + barrier_cond_.notify_all(); +} + +void SyncCommunicator::BarrierSend() { + if (!running_) return; + + distributed::RPCClient *rpc_client = + distributed::RPCClient::GetInstance(trainer_id_); + + std::vector rets; + + for (auto &ep : pserver_endpoints_) { + rets.push_back(rpc_client->AsyncSendBatchBarrier(ep)); } - VLOG(1) << "Geo Sgd Communicator stop done"; + + for (size_t i = 0; i < rets.size(); i++) { + PADDLE_ENFORCE_NE(rets[i]->Wait(), 0U, platform::errors::External( + "internal error in RPCClient")); + } + + VLOG(4) << "BarrierSend with SyncCommunicator"; } -void GeoSgdCommunicator::Send(const std::vector &sparse_var_names, - const std::vector &sparse_var_tables, - const framework::Scope &scope) { - if (sparse_var_names.size() == 1 && sparse_var_names[0] == "param_init") { - for (auto &iter : var_list_) { - // For sparse param, old_scope store LoDTensor, - // pserver_scope store SelectedRows. - auto local_var_name = iter.first; - if (var_list_[local_var_name] == true) { - GeoSgdSparseParamInit(training_scope_, pserver_scope_.get(), - local_var_name); - } else { - GeoSgdDenseParamInit(training_scope_, pserver_scope_.get(), - local_var_name); - } - GeoSgdDenseParamInit(training_scope_, old_scope_.get(), local_var_name); - } - return; +void SyncCommunicator::BarrierRecv() { + if (!running_) return; + + distributed::RPCClient *rpc_client = + distributed::RPCClient::GetInstance(trainer_id_); + + std::vector rets; + for (auto &ep : pserver_endpoints_) { + rets.push_back(rpc_client->AsyncSendFetchBarrier(ep)); } - std::shared_ptr ids_table = std::make_shared(); - auto before_run_send = GetCurrentUS(); - for (size_t i = 0; i < sparse_var_tables.size(); i++) { - if (ids_table->find(sparse_var_tables[i]) == ids_table->end()) { - // create empty set for new sparse var - auto splited_var_nums = - recv_varname_to_ctx_[sparse_var_tables[i]].splited_var_names.size(); - ids_table->insert( - std::pair>>( - sparse_var_tables[i], - std::vector>{splited_var_nums})); - } - auto *var = scope.FindVar(sparse_var_names[i]); - auto var_tensor = var->Get(); - int element_number = var_tensor.numel(); - int *var_mutable_data = var_tensor.mutable_data(var_tensor.place()); - // insert ids which has not been record - for (int j = 0; j < element_number; j++) { - auto ep_idx = GetSectionIndex(var_mutable_data[j], - absolute_section_[sparse_var_tables[i]]); - ids_table->at(sparse_var_tables[i])[ep_idx].insert(var_mutable_data[j]); - VLOG(4) << "Sparse var " << sparse_var_tables[i] << " insert " - << var_mutable_data[j]; - } + for (size_t i = 0; i < rets.size(); i++) { + PADDLE_ENFORCE_NE(rets[i]->Wait(), 0U, platform::errors::External( + "internal error in RPCClient")); } - need_push_queue_->Push(ids_table); - auto after_run_send = GetCurrentUS(); - VLOG(4) << "run send_op use time " << after_run_send - before_run_send; + + VLOG(4) << "BarrierRecv with SyncCommunicator"; } -void GeoSgdCommunicator::SendThread() { - VLOG(1) << "SendThread start!"; - auto before_run_training = GetCurrentUS(); +void GeoCommunicator::InitImpl(const RpcCtxMap &send_varname_to_ctx, + const RpcCtxMap &recv_varname_to_ctx, + Scope *recv_scope) { + send_varname_to_ctx_ = std::move(send_varname_to_ctx); + recv_varname_to_ctx_ = std::move(recv_varname_to_ctx); + recv_scope_ = std::move(recv_scope); - while (running_) { - std::vector> task_futures; - task_futures.reserve(send_var_nums_); - - int wait_times = 0; - while (ids_send_vec_.size() < static_cast(geo_need_push_nums_)) { - VLOG(4) << "ids_send_vec_ Size: " << ids_send_vec_.size(); - if (need_push_queue_->Size() > 0) { - wait_times = 0; - ids_send_vec_.push_back(*(need_push_queue_->Pop())); - VLOG(4) << "ids_send_vec_ pushed"; - } else if (need_push_queue_->Size() == 0) { - VLOG(4) << "wait_times -> " << wait_times; - if (wait_times >= send_wait_times_) { - break; - } - std::this_thread::sleep_for(std::chrono::milliseconds(10)); - wait_times++; + PADDLE_ENFORCE_GT( + send_varname_to_ctx.size(), 0, + platform::errors::InvalidArgument("send var contexts can not be zero")); + + send_scope_.reset(new Scope()); + for (auto &iter : send_varname_to_ctx_) { + auto &varname = iter.first; + + if (varname == STEP_COUNTER) { + send_varname_to_queue_[varname] = + std::make_shared>>( + send_queue_size_); + } else { + auto &send_ctx = iter.second; + + if (!send_ctx.is_sparse) { continue; } - } - if (ids_send_vec_.size() >= static_cast(geo_need_push_nums_)) { - auto after_run_training = GetCurrentUS(); - VLOG(4) << "run Training use time " - << after_run_training - before_run_training; - before_run_training = GetCurrentUS(); - VLOG(4) << "Start send after get need_push_num"; - - for (auto &iter : send_varname_to_ctx_) { - auto &var_name = iter.first; - if (var_list_[DeltaVarToVar(var_name)] == true) { - // sparse var: merge->send->recv - for (auto &splited_var_name : iter.second.splited_var_names) { - auto send_task = [this, &var_name, &splited_var_name] { - auto before_run_geo = GetCurrentUS(); - VLOG(4) << "ids_send_vec_ size: " << ids_send_vec_.size(); - auto ids_set = - SparseIdsMerge(ids_send_vec_, var_name, splited_var_name); - SendUpdateSparseVars(var_name, splited_var_name, ids_set); - RecvUpdateSparseVars(var_name, splited_var_name); - auto after_run_geo = GetCurrentUS(); - VLOG(3) << "run GEO-SGD var " << splited_var_name << " use time " - << after_run_geo - before_run_geo; - }; - task_futures.emplace_back( - send_threadpool_->enqueue(std::move(send_task))); - } - } else { - for (auto &splited_var_name : iter.second.splited_var_names) { - auto send_task = [this, &var_name, &splited_var_name] { - auto before_run_geo = GetCurrentUS(); - SendUpdateDenseVars(var_name, splited_var_name); - RecvUpdateDenseVars(var_name, splited_var_name); - auto after_run_geo = GetCurrentUS(); - VLOG(3) << "run GEO-SGD var " << splited_var_name << " use time " - << after_run_geo - before_run_geo; - }; - task_futures.emplace_back( - send_threadpool_->enqueue(std::move(send_task))); - } - } - } - for (auto &task_f : task_futures) { - task_f.wait(); - } - ids_send_vec_.clear(); + send_ids_to_queue_[varname] = + std::make_shared>>( + send_queue_size_); } } -} + send_threadpool_.reset(new ::ThreadPool(thread_pool_size_)); -std::unordered_set GeoSgdCommunicator::SparseIdsMerge( - const std::vector &ids_send_vec, const std::string &var_name, - const std::string &splited_var_name) { - // every batch has some sparse id, merge them into one unoredered_set - VLOG(4) << "Sparse Ids merge var: " << var_name - << " split var: " << splited_var_name; - auto before_run_ids_merge_ = GetCurrentUS(); - auto origin_var_name = DeltaVarToVar(var_name); - auto splited_var_index = GetSplitedVarIndex(var_name, splited_var_name); - std::unordered_set ids_set; - for (auto ids_map : ids_send_vec) { - for (auto id : ids_map[origin_var_name][splited_var_index]) { - ids_set.insert(id); - } + if (recv_varname_to_ctx.size() == 0) { + VLOG(0) << "nothing need to be received, will not start recv_thread"; + } else { + recv_threadpool_.reset(new ::ThreadPool(thread_pool_size_)); } - auto after_run_ids_merge_ = GetCurrentUS(); - VLOG(4) << "run SparseIdsMerge " << splited_var_name << " has nums " - << ids_set.size() << " use time " - << after_run_ids_merge_ - before_run_ids_merge_; - return ids_set; -} - -void GeoSgdCommunicator::SendUpdateDenseVars( - const std::string &var_name, const std::string &splited_var_name) { - // calc var_delata = (var_training - var_old)/trainer_nums - // calc var_old += var_delta - // var_name: param.delta - auto origin_var_name = DeltaVarToVar(var_name); - auto splited_var_index = GetSplitedVarIndex(var_name, splited_var_name); - VLOG(4) << "Dense var: " << var_name << " 's split var: " << splited_var_name - << " split var index: " << splited_var_index; - auto before_run_send_dense = GetCurrentUS(); - auto cpu_ctx = paddle::platform::CPUDeviceContext(); - auto *var_x = training_scope_->FindVar(origin_var_name); - auto var_x_tensor = var_x->Get(); - - auto *var_y = old_scope_->FindVar(origin_var_name); - auto var_y_tensor = var_y->Get(); - - auto dims = var_x_tensor.dims(); - auto total_element = var_x_tensor.numel(); - int64_t section = 0; - int64_t begin_loc = 0; - int64_t dimension = 0; - - size_t out_num = send_varname_to_ctx_[var_name].height_sections.size(); - if (out_num > 1) { - section = send_varname_to_ctx_[var_name].height_sections[splited_var_index]; - dims[0] = section; - begin_loc = absolute_section_[origin_var_name][splited_var_index]; - dimension = total_element / vars_first_dimension_[origin_var_name]; - total_element = section * dimension; - VLOG(4) << "Dense split var: " << splited_var_name - << " section: " << section << " dimension: " << dimension - << " begin loc: " << begin_loc << " total_element " - << total_element; - } + delta_scope_.reset(new Scope()); + old_scope_.reset(new Scope()); + pserver_scope_.reset(new Scope()); - auto *var_x_data = var_x_tensor.mutable_data(var_x_tensor.place()) + - begin_loc * dimension; - VLOG(4) << "Dense split var: " << splited_var_name << " var_x_data[0] " - << var_x_data[0] << " var_x_data[end] " - << var_x_data[total_element - 1]; - auto *var_y_data = var_y_tensor.mutable_data(var_y_tensor.place()) + - begin_loc * dimension; - VLOG(4) << "Dense split var: " << splited_var_name << " var_y_data[0] " - << var_y_data[0] << " var_y_data[end] " - << var_y_data[total_element - 1]; - - // create delta var in delta scope - auto *var_z_tensor = - delta_scope_->Var(splited_var_name)->GetMutable(); - var_z_tensor->Resize(dims); - var_z_tensor->mutable_data(dims, cpu_ctx.GetPlace()); - auto *var_z_data = var_z_tensor->mutable_data(cpu_ctx.GetPlace()); - - VLOG(4) << "Dense split var: " << splited_var_name << "var_z_data[0] " - << var_z_data[0] << " var_z_data[end] " - << var_z_data[total_element - 1]; - - // calc sub = var_training - var_old - auto blas = math::GetBlas(cpu_ctx); - blas.VSUB(total_element, var_x_data, var_y_data, var_z_data); - VLOG(4) << "Dense split var: " << splited_var_name << " var_z_data[0] " - << var_z_data[0] << " var_z_data[end] " - << var_z_data[total_element - 1]; - - // calc var_delta = sub / trainer_nums - float trainer_param = 1.0 / static_cast(trainer_nums_); - blas.SCAL(total_element, trainer_param, var_z_data); - - // calc var_old += var_delta - blas.VADD(total_element, var_y_data, var_z_data, var_y_data); - VLOG(4) << "Dense split var: " << splited_var_name << " var_y_data[0] " - << var_y_data[0] << " var_y_data[end] " - << var_y_data[total_element - 1]; - - auto after_run_send_dense = GetCurrentUS(); - VLOG(4) << "run send update dense var " << var_name << " use time " - << after_run_send_dense - before_run_send_dense; - - auto before_send_dense = GetCurrentUS(); - RpcSend(var_name, splited_var_name, splited_var_index); - auto after_send_dense = GetCurrentUS(); - VLOG(4) << "send " << splited_var_name << " use time " - << after_send_dense - before_send_dense; + Init(); } -void GeoSgdCommunicator::SendUpdateSparseVars( - const std::string &var_name, const std::string &splited_var_name, - const std::unordered_set &ids_table) { - // calc var_delata = (var_training - var_old)/trainer_nums - // calc var_old += var_delta - // var_name: param.delta, splited_var_name: param.block0.delta - // origin_var_name: param - auto before_run_send_sparse = GetCurrentUS(); +void GeoCommunicator::Send(const std::vector &var_names, + const std::vector &var_tables, + const framework::Scope &scope) { + waiting_ = false; - auto ids_num = ids_table.size(); - VLOG(4) << "Sparse Ids nums is : " << ids_num; - auto origin_var_name = DeltaVarToVar(var_name); + PADDLE_ENFORCE_EQ( + var_tables.size(), 1, + platform::errors::InvalidArgument("var_tables.size() == 1 is permitted")); - auto *var_x = training_scope_->FindVar(origin_var_name); - auto var_x_tensor = var_x->Get(); + auto table_name = var_tables[0]; - auto *var_y = old_scope_.get()->FindVar(origin_var_name); - auto var_y_tensor = var_y->Get(); + if (table_name == STEP_COUNTER) { + auto &queue = send_varname_to_queue_.at(table_name); - auto dims = var_x_tensor.dims(); - auto row_numel = dims[1]; + auto tmp_var = std::make_shared(); + auto *tensor = tmp_var->GetMutable(); + tensor->Resize(framework::make_ddim({1})); + auto *out_d = tensor->mutable_data(platform::CPUPlace()); + out_d[0] = 1; + VLOG(3) << "send to " << table_name << " with queue size " << queue->Size(); + queue->Push(tmp_var); + } else { + auto &queue = send_ids_to_queue_.at(table_name); + PADDLE_ENFORCE_EQ(var_names.size(), 1, + platform::errors::InvalidArgument( + "var_names.size() == 1 is permitted")); - float *x_value = var_x_tensor.mutable_data(var_x_tensor.place()); - float *y_value = var_y_tensor.mutable_data(var_y_tensor.place()); + auto *var = scope.FindVar(var_names[0]); - auto *var_z = delta_scope_->Var(splited_var_name); - auto *var_z_select_rows = var_z->GetMutable(); - auto *var_z_value = var_z_select_rows->mutable_value(); - var_z_value->Resize({static_cast(ids_num), row_numel}); - auto *z_value = var_z_value->mutable_data(var_x_tensor.place()); + PADDLE_ENFORCE_EQ( + var->IsInitialized(), true, + platform::errors::InvalidArgument("grad var should be inited")); - std::vector new_rows; - new_rows.insert(new_rows.begin(), ids_table.begin(), ids_table.end()); + if (!var->IsType()) { + PADDLE_THROW(platform::errors::InvalidArgument( + "Only LodTensor can be send in GeoCommunicator::Send")); + } - auto cpu_ctx = paddle::platform::CPUDeviceContext(); - auto blas = math::GetBlas(cpu_ctx); - float avg = 1 / static_cast(trainer_nums_); - for (size_t y = 0; y < new_rows.size(); y++) { - auto ids = new_rows[y]; - - float *x_val = x_value + ids * row_numel; - float *y_val = y_value + ids * row_numel; - float *z_val = z_value + y * row_numel; - - std::vector row_delta(row_numel, 0); - blas.VSUB(row_numel, x_val, y_val, row_delta.data()); - blas.SCAL(row_numel, avg, row_delta.data()); - blas.VADD(row_numel, row_delta.data(), y_val, y_val); - blas.VCOPY(row_numel, row_delta.data(), z_val); + std::vector ids; + auto &rows = var->Get().rows(); + ids.assign(rows.begin(), rows.end()); + queue->Push(ids); } +} + +void GeoCommunicator::SendByCommunicator(int batches) { + std::vector> tasks; + tasks.reserve(send_varname_to_ctx_.size()); + + for (auto &iter : send_varname_to_ctx_) { + auto &var_name = iter.first; + auto &send_ctx = iter.second; - auto after_run_send_sparse = GetCurrentUS(); - VLOG(4) << "run send update sparse var " << splited_var_name << " use time " - << after_run_send_sparse - before_run_send_sparse; + auto send_task = [this, batches, &var_name, &send_ctx] { + if (var_name == STEP_COUNTER) { + return; + } - auto splited_var_index = GetSplitedVarIndex(var_name, splited_var_name); - std::vector send_rows; - send_rows.reserve(new_rows.size()); - for (auto idx : new_rows) { - send_rows.push_back(idx - - absolute_section_[origin_var_name][splited_var_index]); + if (send_ctx.is_sparse) { + SendSparse(var_name, batches); + } else { + VLOG(1) << "send dense " << var_name << " begin"; + SendDense(var_name); + VLOG(1) << "send dense " << var_name << " done"; + } + }; + tasks.emplace_back(send_threadpool_->enqueue(std::move(send_task))); } - var_z_select_rows->set_rows(send_rows); - var_z_select_rows->set_height( - send_varname_to_ctx_[var_name].height_sections[splited_var_index]); - - auto before_send_sparse = GetCurrentUS(); - RpcSend(var_name, splited_var_name, splited_var_index); - auto after_send_sparse = GetCurrentUS(); - VLOG(4) << "send " << splited_var_name << " has nums " << new_rows.size() - << " use time " << after_send_sparse - before_send_sparse; -} -void GeoSgdCommunicator::RecvUpdateDenseVars( - const std::string &var_name, const std::string &splited_var_name) { - // calc var_training += var_pserver - var_old - // calc var_old = var_pserver - // var_name: param.delta + for (auto &task : tasks) { + task.wait(); + } +} - // step1: recv dense var from pserver - auto origin_var_name = DeltaVarToVar(var_name); - auto origin_splited_var_name = DeltaVarToVar(splited_var_name); - auto splited_var_index = GetSplitedVarIndex(var_name, splited_var_name); - auto cpu_ctx = paddle::platform::CPUDeviceContext(); +void GeoCommunicator::SendSparse(const std::string &varname, int batches) { + std::vector ids; + auto &ids_queue = send_ids_to_queue_.at(varname); - auto before_run_recv = GetCurrentUS(); - VLOG(4) << "Dense recv origin_var_name: " << origin_var_name - << " origin_splited_var_name: " << origin_splited_var_name - << " splited_var_index: " << splited_var_index; - RpcRecv(origin_var_name, origin_splited_var_name, splited_var_index); - auto after_run_recv = GetCurrentUS(); - VLOG(4) << "recv var " << origin_splited_var_name << " use time " - << after_run_recv - before_run_recv; - - // step2: update dense var - auto before_run_update = GetCurrentUS(); - auto *var_x = training_scope_->FindVar(origin_var_name); - auto var_x_tensor = var_x->Get(); - - auto *var_y = old_scope_->FindVar(origin_var_name); - auto var_y_tensor = var_y->Get(); - - auto *var_z = pserver_scope_.get()->FindVar(origin_splited_var_name); - auto var_z_tensor = var_z->Get(); - auto dims = var_z_tensor.dims(); - auto total_element = var_z_tensor.numel(); - - int64_t section = 0; - int64_t begin_loc = 0; - int64_t dimension = 0; - size_t out_num = recv_varname_to_ctx_[origin_var_name].height_sections.size(); - if (out_num > 1) { - section = dims[0]; - begin_loc = absolute_section_[origin_var_name][splited_var_index]; - dimension = total_element / section; - VLOG(4) << "Dense split var: " << splited_var_name - << " section: " << section << " dimension: " << dimension - << " begin loc: " << begin_loc << " total_element " - << total_element; + for (int i = 0; i < batches; ++i) { + auto pop_ids = ids_queue->Pop(); + std::copy(pop_ids.begin(), pop_ids.end(), back_inserter(ids)); } - auto *var_x_data = var_x_tensor.mutable_data(var_x_tensor.place()) + - begin_loc * dimension; - VLOG(4) << "Dense split var: " << splited_var_name << " var_x_data[0] " - << var_x_data[0] << " var_x_data[end] " - << var_x_data[total_element - 1]; - - auto *var_y_data = var_y_tensor.mutable_data(var_y_tensor.place()) + - begin_loc * dimension; - VLOG(4) << "Dense split var: " << splited_var_name << " var_y_data[0] " - << var_y_data[0] << " var_y_data[end] " - << var_y_data[total_element - 1]; - - auto *var_z_data = var_z_tensor.mutable_data(cpu_ctx.GetPlace()); - VLOG(4) << "Dense split var: " << splited_var_name << " var_z_data[0] " - << var_z_data[0] << " var_z_data[end] " - << var_z_data[total_element - 1]; - - auto *var_y_sub_tensor = old_scope_->Var(origin_splited_var_name) - ->GetMutable(); - var_y_sub_tensor->Resize(dims); - var_y_sub_tensor->mutable_data(dims, cpu_ctx.GetPlace()); - auto *var_y_sub_data = - var_y_sub_tensor->mutable_data(cpu_ctx.GetPlace()); - - VLOG(4) << "Dense split var: " << splited_var_name << " var_y_sub_data[0] " - << var_y_sub_data[0] << " var_y_sub_data[end] " - << var_y_sub_data[total_element - 1]; - - auto blas = math::GetBlas(cpu_ctx); - - // calc sub = pserver - old - blas.VSUB(total_element, var_z_data, var_y_data, var_y_sub_data); - VLOG(4) << "Dense split var: " << splited_var_name << " var_y_sub_data[0] " - << var_y_sub_data[0] << " var_y_sub_data[end] " - << var_y_sub_data[total_element - 1]; - - // calc train += sub - blas.VADD(total_element, var_x_data, var_y_sub_data, var_x_data); - VLOG(4) << "Dense split var: " << splited_var_name << " var_x_data[0] " - << var_x_data[0] << " var_x_data[end] " - << var_x_data[total_element - 1]; - - // calc old = pserver - blas.VCOPY(total_element, var_z_data, var_y_data); - VLOG(4) << "Dense split var: " << splited_var_name << " var_y_data[0] " - << var_y_data[0] << " var_y_data[end] " - << var_y_data[total_element - 1]; - - auto after_run_update = GetCurrentUS(); - VLOG(4) << "dense var update " << origin_splited_var_name << " use time " - << after_run_update - before_run_update; -} + auto size = ids.size(); + + std::set st(ids.begin(), ids.end()); + ids.assign(st.begin(), st.end()); + VLOG(1) << "SendSparse receive var: " << varname << " unset: " << size + << " set: " << ids.size(); -void GeoSgdCommunicator::RecvUpdateSparseVars( - const std::string &var_name, const std::string &splited_var_name) { - // step 1: recv split var from pserver - auto splited_var_index = GetSplitedVarIndex(var_name, splited_var_name); - auto origin_var_name = DeltaVarToVar(var_name); - auto origin_splited_var_name = DeltaVarToVar(splited_var_name); - - auto before_run_recv = GetCurrentUS(); - RpcRecv(origin_var_name, origin_splited_var_name, splited_var_index); - auto after_run_recv = GetCurrentUS(); - VLOG(4) << "recv var " << origin_splited_var_name << " use time " - << after_run_recv - before_run_recv; - - // step 2: update sparse var - auto before_run_update = GetCurrentUS(); - auto *var_x = training_scope_->FindVar(origin_var_name); - auto var_x_tensor = var_x->Get(); - auto dims = var_x_tensor.dims(); - float *x_value = var_x_tensor.mutable_data(var_x_tensor.place()); - - auto *var_y = old_scope_->FindVar(origin_var_name); - auto var_y_tensor = var_y->Get(); - float *y_value = var_y_tensor.mutable_data(var_y_tensor.place()); - - auto *var_z = pserver_scope_.get()->FindVar(origin_splited_var_name); - auto var_z_slr = var_z->GetMutable(); - auto row_size = var_z_slr->rows().size(); - - std::vector new_rows; - new_rows.reserve(row_size); - - for (auto ids : var_z_slr->rows()) { - new_rows.push_back(ids + - absolute_section_[origin_var_name][splited_var_index]); + if (ids.empty()) { + LOG(WARNING) << "WARNING: GEO has nothing to send, return directly "; + return; } - auto *new_value = var_z_slr->mutable_value(); - auto row_numel = dims[1]; - auto *z_value = new_value->mutable_data(var_x_tensor.place()); + auto *var_latest = recv_scope_->FindVar(varname); + + PADDLE_ENFORCE_EQ(var_latest->IsInitialized(), true, + platform::errors::Unavailable( + "%s is not initialized, please check", varname)); + auto &t_latest = var_latest->Get(); + + auto dims1 = t_latest.dims()[1]; auto cpu_ctx = paddle::platform::CPUDeviceContext(); - auto blas = math::GetBlas(cpu_ctx); - for (size_t y = 0; y < new_rows.size(); y++) { - std::vector row_delta(row_numel, 0); + auto *var_delta = delta_scope_->Var(varname); + auto *t_delta = var_delta->GetMutable(); + t_delta->set_height(ids.size()); + t_delta->mutable_rows()->assign(ids.begin(), ids.end()); + auto *t_value = t_delta->mutable_value(); + t_value->mutable_data( + framework::make_ddim({static_cast(ids.size()), dims1}), + cpu_ctx.GetPlace()); - auto ids = new_rows[y]; + std::vector *>> values; + auto *ins = distributed::LargeScaleKV::GetInstance(); + ins->Get(varname)->Get(ids, {"Param"}, &values); - float *x_val = x_value + ids * row_numel; - float *y_val = y_value + ids * row_numel; - float *z_val = z_value + y * row_numel; + auto blas = math::GetBlas(cpu_ctx); + float coefficient = 1.0 / static_cast(trainers_); - blas.VSUB(row_numel, z_val, y_val, row_delta.data()); - blas.VADD(row_numel, row_delta.data(), x_val, x_val); - blas.VCOPY(row_numel, z_val, y_val); + for (auto j = 0; j < static_cast(ids.size()); ++j) { + blas.VSUB(dims1, t_latest.data() + ids[j] * dims1, + values[j][0]->data(), t_value->data() + j * dims1); + blas.SCAL(dims1, coefficient, t_value->data() + j * dims1); + blas.VADD(dims1, values[j][0]->data(), t_value->data() + j * dims1, + values[j][0]->data()); } - auto after_run_update = GetCurrentUS(); - VLOG(4) << "sparse var recv update " << origin_splited_var_name << " has num " - << new_rows.size() << " use time " - << after_run_update - before_run_update; + auto &ctx = send_varname_to_ctx_.at(varname); + auto send = distributed::ParameterSend(); + send(ctx, *delta_scope_, true, 1); } -void GeoSgdCommunicator::GeoSgdSparseParamInit(framework::Scope *scope_x, - framework::Scope *scope_y, - const std::string var_name) { - // create selectedrows var from lodtensor var info - auto *var_x = scope_x->Var(var_name); - auto *var_y = scope_y->Var(var_name); - - auto var_x_tensor = var_x->Get(); - auto *var_y_select_rows = var_y->GetMutable(); - - auto dims = var_x_tensor.dims(); - auto rows = dims[0]; - auto row_numel = dims[1]; - - var_y_select_rows->set_height(rows); - std::vector new_rows{}; - var_y_select_rows->set_rows(new_rows); - auto *var_y_value = var_y_select_rows->mutable_value(); - var_y_value->Resize({rows, row_numel}); - var_y_value->mutable_data(var_x_tensor.place()); -} +void GeoCommunicator::SendDense(const std::string &varname) { + auto *var_latest = recv_scope_->FindVar(varname); + auto *var_timestamp = old_scope_->FindVar(varname); -void GeoSgdCommunicator::GeoSgdDenseParamInit(framework::Scope *scope_x, - framework::Scope *scope_y, - const std::string var_name) { - auto *var_x = scope_x->Var(var_name); - auto *var_y = scope_y->Var(var_name); - framework::CopyVariable(*var_x, var_y); -} + PADDLE_ENFORCE_EQ(var_latest->IsInitialized(), true, + platform::errors::Unavailable( + "%s is not initialized, please check", varname)); + PADDLE_ENFORCE_EQ(var_timestamp->IsInitialized(), true, + platform::errors::Unavailable( + "%s is not initialized, please check", varname)); -void GeoSgdCommunicator::RpcSend(const std::string &origin_var_name, - const std::string &splited_var_name, - const size_t &splited_var_index) { - auto trainer_id = send_varname_to_ctx_[origin_var_name].trainer_id; - auto endpoint = - send_varname_to_ctx_[origin_var_name].epmap[splited_var_index]; + auto &t_latest = var_latest->Get(); + auto t_timestamp = var_timestamp->GetMutable(); - platform::DeviceContextPool &pool = platform::DeviceContextPool::Instance(); - auto &cpu_ctx_send = *pool.Get(platform::CPUPlace()); - distributed::RPCClient *rpc_client = - distributed::RPCClient::GetInstance(trainer_id); - auto handle = rpc_client->AsyncSendVar(endpoint, cpu_ctx_send, - *delta_scope_.get(), splited_var_name); - handle->Wait(); -} + auto cpu_ctx = paddle::platform::CPUDeviceContext(); + auto *var_delta = delta_scope_->Var(varname); + auto *t_delta = var_delta->GetMutable(); + t_delta->mutable_data(t_latest.dims(), cpu_ctx.GetPlace()); -void GeoSgdCommunicator::RpcRecv(const std::string &var_name, - const std::string &splited_var_name, - const size_t &splited_var_index) { - auto train_id = recv_varname_to_ctx_[var_name].trainer_id; - auto endpoint = recv_varname_to_ctx_[var_name].epmap[splited_var_index]; - platform::DeviceContextPool &pool = platform::DeviceContextPool::Instance(); - auto &cpu_ctx_recv = *pool.Get(platform::CPUPlace()); - distributed::RPCClient *rpc_client = - distributed::RPCClient::GetInstance(train_id); - pserver_scope_->Var(splited_var_name); - auto handle = rpc_client->AsyncGetVar(endpoint, cpu_ctx_recv, - *pserver_scope_.get(), splited_var_name, - splited_var_name, splited_var_name); - handle->Wait(); -} + auto blas = math::GetBlas(cpu_ctx); + blas.VSUB(t_latest.numel(), t_latest.data(), + t_timestamp->data(), t_delta->data()); -void GeoSgdCommunicator::Recv() {} + float coefficient = 1.0 / static_cast(trainers_); + blas.SCAL(t_latest.numel(), coefficient, t_delta->data()); -void HalfAsyncCommunicator::InitImpl(const RpcCtxMap &send_varname_to_ctx, - const RpcCtxMap &recv_varname_to_ctx, - Scope *recv_scope) { - send_varname_to_ctx_ = std::move(send_varname_to_ctx); - recv_varname_to_ctx_ = std::move(recv_varname_to_ctx); - recv_scope_ = std::move(recv_scope); + blas.VADD(t_latest.numel(), t_timestamp->data(), + t_delta->data(), t_timestamp->data()); - if (send_varname_to_ctx.size() == 0) { - VLOG(0) << "nothing need to be send, will not start send_thread"; - } else { - send_scope_.reset(new Scope()); - for (auto &iter : send_varname_to_ctx_) { - send_varname_to_queue_[iter.first] = - std::make_shared>>( - send_queue_size_); - } + auto &ctx = send_varname_to_ctx_.at(varname); + auto send = distributed::ParameterSend(); + send(ctx, *delta_scope_, true, 1); +} - consume_threadpool_.reset(new ::ThreadPool(thread_pool_size_)); - } +void GeoCommunicator::RecvByCommunicator() { + std::vector> tasks; + tasks.reserve(recv_varname_to_ctx_.size()); - if (recv_varname_to_ctx.size() == 0) { - VLOG(0) << "nothing need to be received, will not start recv_thread"; - } else { - recv_threadpool_.reset(new ::ThreadPool(thread_pool_size_)); - } -} + for (auto &iter : recv_varname_to_ctx_) { + auto &var_name = iter.first; + auto &recv_ctx = iter.second; -void HalfAsyncCommunicator::InitImpl( - const paddle::framework::ProgramDesc &program, Scope *param_scope) { - RpcCtxMap send_varname_to_ctx; - RpcCtxMap recv_varname_to_ctx; - for (auto *op : program.Block(0).AllOps()) { - VLOG(3) << "node name " << op->Type(); - if (op->Type() == "send") { - auto send_var_name = op->Input("X")[0]; - auto send_varnames = BOOST_GET_CONST( - std::vector, op->GetNullableAttr("send_varnames")); - auto epmap = BOOST_GET_CONST(std::vector, - op->GetNullableAttr("epmap")); - auto height_section = BOOST_GET_CONST(std::vector, - op->GetNullableAttr("sections")); - auto trainer_id = BOOST_GET_CONST(int, op->GetNullableAttr("trainer_id")); - send_varname_to_ctx[send_var_name] = operators::distributed::RpcContext( - send_var_name, send_varnames, epmap, height_section, trainer_id); - VLOG(3) << "find and init an send op: " - << send_varname_to_ctx[send_var_name]; - } else if (op->Type() == "recv") { - auto do_not_run = BOOST_GET_CONST(int, op->GetNullableAttr("do_not_run")); - PADDLE_ENFORCE_GT(do_not_run, 0, - platform::errors::InvalidArgument( - "recv op's attr `do_not_run` must be True!")); - auto recv_var_name = op->Output("Out")[0]; - auto recv_varnames = BOOST_GET_CONST( - std::vector, op->GetNullableAttr("recv_varnames")); - auto epmap = BOOST_GET_CONST(std::vector, - op->GetNullableAttr("epmap")); - auto trainer_id = BOOST_GET_CONST(int, op->GetNullableAttr("trainer_id")); - recv_varname_to_ctx[recv_var_name] = operators::distributed::RpcContext( - recv_var_name, recv_varnames, epmap, {}, trainer_id); - VLOG(3) << "find and init an recv op: " - << recv_varname_to_ctx[recv_var_name]; - } + auto recv_task = [this, &var_name, &recv_ctx] { + if (recv_ctx.is_sparse) { + RecvSparse(var_name); + } else { + VLOG(1) << "recv dense " << var_name << " begin"; + RecvDense(var_name); + VLOG(1) << "recv dense " << var_name << " done"; + } + }; + tasks.emplace_back(send_threadpool_->enqueue(std::move(recv_task))); } - - // init communicator here - if (send_varname_to_ctx.size() == 0 && recv_varname_to_ctx.size() == 0) { - LOG(WARNING) << "no var need to send and recv!!"; + for (auto &task : tasks) { + task.wait(); } - - operators::distributed::HalfAsyncCommunicator::InitImpl( - send_varname_to_ctx, recv_varname_to_ctx, param_scope); } -HalfAsyncCommunicator::~HalfAsyncCommunicator() { - running_ = false; - if (consume_thread_) consume_thread_->join(); -} +void GeoCommunicator::RecvSparse(const std::string &varname) { + VLOG(1) << "RecvSparse receive var: " << varname; -void HalfAsyncCommunicator::Clean() { - for (auto &iter : send_varname_to_queue_) { - auto &var_name = iter.first; - auto &var_queue = iter.second; + auto *var_latest = recv_scope_->FindVar(varname); + auto *var_psrever = pserver_scope_->Var(varname); - while (var_queue->Size() > 0) { - var_queue->Pop(); - } + auto &ctx = recv_varname_to_ctx_.at(varname); + auto recv = distributed::ParameterRecv(); + recv(ctx, *pserver_scope_, true); - VLOG(3) << "clean var: " << var_name << " done"; - } -} + PADDLE_ENFORCE_EQ( + var_psrever->IsInitialized(), true, + platform::errors::Unavailable( + "%s in pserver scope is not initialized, please check", varname)); -void HalfAsyncCommunicator::ConsumeThread() { - VLOG(3) << "ConsumeThread start!"; - while (running_) { - while (running_) { - if (barrier_counter_.load() >= barrier_trigger_.load() && - barrier_trigger_.load() != 0) { - break; - } else { - std::this_thread::sleep_for(std::chrono::milliseconds(10)); - } - } + std::vector ids; + ids.assign(var_psrever->Get().rows().begin(), + var_psrever->Get().rows().end()); - std::vector> task_futures; - task_futures.reserve(send_varname_to_ctx_.size()); - VLOG(3) << "run send graph"; - auto before_run_send_graph = GetCurrentUS(); - for (auto &iter : send_varname_to_queue_) { - auto &var_name = iter.first; - auto &var_queue = iter.second; - if (var_queue->Size() > 0) { - auto send_task = [this, &var_name, &var_queue] { - VLOG(3) << var_name << " merge and send"; - std::vector> vars; - size_t merged_var_num = 0; - size_t wait_times = 0; - while (merged_var_num < static_cast(max_merge_var_num_)) { - if (var_queue->Size() == 0) { - VLOG(3) << "wait_times -> " << wait_times; - if (wait_times >= static_cast(send_wait_times_)) { - break; - } - std::this_thread::sleep_for(std::chrono::milliseconds(10)); - wait_times++; - continue; - } else { - wait_times = 0; - vars.push_back(var_queue->Pop()); - merged_var_num++; - } - } - auto before_merge = GetCurrentUS(); - - MergeVars(var_name, vars, send_scope_.get(), false); - - auto after_merge = GetCurrentUS(); - VLOG(3) << "merge " << merged_var_num << " " << var_name - << " use time " << after_merge - before_merge; - - auto send_functor = distributed::ParameterSend(); - auto &ctx = send_varname_to_ctx_.at(var_name); - send_functor(ctx, *send_scope_, true, 1); - - auto after_send = GetCurrentUS(); - VLOG(3) << "send " << var_name << " use time " - << after_send - after_merge; - }; - task_futures.emplace_back( - consume_threadpool_->enqueue(std::move(send_task))); - } else { - VLOG(4) << var_name << " queue empty"; - } - } - for (auto &task_f : task_futures) { - task_f.wait(); - } - auto after_run_send_graph = GetCurrentUS(); + VLOG(1) << "RecvSparse receive var: " << varname + << " ids Size: " << ids.size(); - VLOG(3) << "run send graph use time " - << after_run_send_graph - before_run_send_graph; + auto t_psrever = var_psrever->Get().value(); - BarrierSend(); - Recv(); - BarrierRecv(); - BarrierWeakUp(); - } + std::vector *>> old_values; - Clean(); + auto *ins = distributed::LargeScaleKV::GetInstance(); + ins->Get(varname)->Get(ids, {"Param"}, &old_values); - VLOG(1) << "communicator stopped, send thread exit"; -} + auto *t_latest = var_latest->GetMutable(); -void HalfAsyncCommunicator::Send(const std::vector &var_names, - const std::vector &var_tables, - const framework::Scope &scope) { - PADDLE_ENFORCE_EQ( - var_names.size(), 1, - platform::errors::InvalidArgument("var_names.size() == 1 is permitted")); - auto var_name = var_names[0]; - VLOG(3) << "communicator send " << var_name; - // push var into send queue by var_name - auto *grad_var = scope.FindVar(var_name); - PADDLE_ENFORCE_EQ( - grad_var->IsInitialized(), true, - platform::errors::InvalidArgument("grad var should is not initialized.")); - auto tmp_grad_var = std::make_shared(); - framework::CopyVariable(*grad_var, tmp_grad_var.get()); - auto &queue = send_varname_to_queue_.at(var_name); - VLOG(3) << "send " << var_name << " queue size " << queue->Size(); - queue->Push(tmp_grad_var); -} + auto dims1 = t_latest->dims()[1]; + auto numel = ids.size() * dims1; -void HalfAsyncCommunicator::Recv() { - VLOG(3) << "parallel run recv graph"; - if (!running_) return; - auto before_send = GetCurrentUS(); - std::vector> task_futures; - task_futures.reserve(recv_varname_to_ctx_.size()); - for (auto &iter : recv_varname_to_ctx_) { - auto recv_task = [this, &iter] { - auto &var_name = iter.first; - VLOG(4) << "recv var " << var_name; - auto recv_functor = distributed::ParameterRecv(); - recv_functor(iter.second, *recv_scope_); - }; - task_futures.emplace_back(recv_threadpool_->enqueue(std::move(recv_task))); - } - for (auto &task : task_futures) { - task.wait(); + std::vector v_delta; + v_delta.resize(numel); + + auto cpu_ctx = paddle::platform::CPUDeviceContext(); + auto blas = math::GetBlas(cpu_ctx); + + for (auto j = 0; j < static_cast(ids.size()); ++j) { + blas.VSUB(dims1, t_psrever.data() + j * dims1, + old_values[j][0]->data(), v_delta.data() + j * dims1); + blas.VADD(dims1, t_latest->data() + ids[j] * dims1, + v_delta.data() + j * dims1, + t_latest->data() + ids[j] * dims1); + blas.VCOPY(dims1, t_psrever.data() + j * dims1, + old_values[j][0]->data()); } - auto after_recv = GetCurrentUS(); - VLOG(3) << "run recv graph use time " << after_recv - before_send; } -void HalfAsyncCommunicator::Barrier() { - barrier_counter_++; +void GeoCommunicator::RecvDense(const std::string &varname) { + auto *var_latest = recv_scope_->FindVar(varname); + auto *var_timestamp = old_scope_->FindVar(varname); + auto *var_psrever = pserver_scope_->Var(varname); - if (!running_) { - VLOG(3) << "Communicator is not running, release barrier"; - return; - } + auto &ctx = recv_varname_to_ctx_.at(varname); + auto recv = distributed::ParameterRecv(); + recv(ctx, *pserver_scope_, true); - { - std::unique_lock lk(barrier_mutex_); - barrier_cond_.wait(lk, [this] { return (barrier_counter_ == 0); }); - } -} + PADDLE_ENFORCE_EQ( + var_psrever->IsInitialized(), true, + platform::errors::Unavailable( + "%s in pserver scope is not initialized, please check", varname)); -void HalfAsyncCommunicator::BarrierTriggerDecrement() { - barrier_trigger_--; - VLOG(3) << "BarrierTriggerDecrement decrement barrier trigger to " - << barrier_trigger_.load(); -} + auto t_psrever = var_psrever->Get(); + auto t_latest = var_latest->GetMutable(); + auto t_timestamp = var_timestamp->GetMutable(); -void HalfAsyncCommunicator::BarrierTriggerReset(int initial_val) { - barrier_trigger_.store(initial_val); + auto cpu_ctx = paddle::platform::CPUDeviceContext(); + auto *var_delta = delta_scope_->Var(varname); + auto *t_delta = var_delta->GetMutable(); + t_delta->mutable_data(t_latest->dims(), cpu_ctx.GetPlace()); - VLOG(3) << "BarrierTriggerReset reset barrier trigger to " - << barrier_trigger_.load(); + auto blas = math::GetBlas(cpu_ctx); + blas.VSUB(t_latest->numel(), t_psrever.data(), + t_timestamp->data(), t_delta->data()); + blas.VADD(t_latest->numel(), t_latest->data(), t_delta->data(), + t_latest->data()); + blas.VCOPY(t_latest->numel(), t_psrever.data(), + t_timestamp->data()); } -void HalfAsyncCommunicator::BarrierWeakUp() { - barrier_counter_.store(0); - barrier_cond_.notify_all(); -} +void GeoCommunicator::Init() { + std::vector> tasks; + tasks.reserve(recv_varname_to_ctx_.size()); -void HalfAsyncCommunicator::Start() { - VLOG(1) << "Communicator start"; - if (!communicator_) { - VLOG(0) << "Communicator is not inited, do nothing"; - } else { - VLOG(1) << "start send thread and recv thread"; + for (auto &iter : recv_varname_to_ctx_) { + auto &var_name = iter.first; + auto &recv_ctx = iter.second; - BarrierTriggerReset(max_merge_var_num_); - running_ = true; - consume_thread_.reset(new std::thread( - std::bind(&HalfAsyncCommunicator::ConsumeThread, this))); + auto recv_task = [this, &var_name, &recv_ctx] { + if (!recv_ctx.is_sparse) { + InitDense(var_name); + } + }; + tasks.emplace_back(send_threadpool_->enqueue(std::move(recv_task))); } -} -void HalfAsyncCommunicator::Stop() { - VLOG(1) << "Communicator stop"; - running_ = false; - if (!communicator_) { - VLOG(0) << "Communicator is not inited, do nothing"; - } else { - if (consume_thread_) { - VLOG(4) << "stop send thread"; - consume_thread_->join(); - consume_thread_.reset(nullptr); - } + for (auto &task : tasks) { + task.wait(); } - VLOG(1) << "Communicator stop done"; + InitSparse(); } -void SyncCommunicator::BarrierSend() { - if (!running_) return; +void GeoCommunicator::InitDense(const std::string varname) { + auto *var = old_scope_->Var(varname); + var->GetMutable(); - distributed::RPCClient *rpc_client = - distributed::RPCClient::GetInstance(trainer_id_); + auto &ctx = recv_varname_to_ctx_.at(varname); + auto recv = distributed::ParameterRecv(); + recv(ctx, *old_scope_); + VLOG(1) << "init dense variable " << varname << " done"; +} - std::vector rets; +void GeoCommunicator::InitSparse() { + auto sparse_metas = string::split_string(sparse_attrs_, "#"); - for (auto &ep : pserver_endpoints_) { - rets.push_back(rpc_client->AsyncSendBatchBarrier(ep)); - } + std::vector metas; + std::vector dicts; - for (size_t i = 0; i < rets.size(); i++) { - PADDLE_ENFORCE_NE(rets[i]->Wait(), 0U, platform::errors::External( - "internal error in RPCClient")); + for (auto &sparse_meta : sparse_metas) { + auto attrs = string::split_string(sparse_meta, ":"); + + auto meta = distributed::SparseMeta(); + meta.name = attrs[0]; + meta.value_names = {"Param"}; + + auto dic = string::split_string(attrs[1], ","); + dicts.push_back(std::stoi(dic[0])); + meta.value_dims = {std::stoi(dic[1])}; + meta.mode = distributed::Mode::training; + meta.grad_name = "none"; + meta.cached_varnames = {}; + meta.initializer_attrs = string::split_string(attrs[2]); + meta.entry = "none"; + + VLOG(3) << "add sparse meta: " << meta.ToString(); + metas.push_back(meta); } - VLOG(4) << "BarrierSend with SyncCommunicator"; -} + LargeScaleKV::Init(metas); -void SyncCommunicator::BarrierRecv() { - if (!running_) return; + for (size_t i = 0; i < metas.size(); i++) { + auto &varname = metas[i].name; + auto &dict = dicts[i]; - distributed::RPCClient *rpc_client = - distributed::RPCClient::GetInstance(trainer_id_); + std::vector ids; + ids.reserve(dict); - std::vector rets; - for (auto &ep : pserver_endpoints_) { - rets.push_back(rpc_client->AsyncSendFetchBarrier(ep)); - } + for (auto j = 0; j < dict; ++j) { + ids.push_back(j); + } - for (size_t i = 0; i < rets.size(); i++) { - PADDLE_ENFORCE_NE(rets[i]->Wait(), 0U, platform::errors::External( - "internal error in RPCClient")); + auto *ins = distributed::LargeScaleKV::GetInstance(); + ins->Get(varname)->Init(ids); + + VLOG(3) << "GeoCommunicator init sparse " << varname << " with size " + << ids.size(); } - VLOG(4) << "BarrierRecv with SyncCommunicator"; + VLOG(3) << "init sparse variable done"; } -SyncCommunicator::~SyncCommunicator() { - running_ = false; - if (consume_thread_) consume_thread_->join(); -} } // namespace distributed } // namespace operators } // namespace paddle diff --git a/paddle/fluid/operators/distributed/communicator.h b/paddle/fluid/operators/distributed/communicator.h index 2c504a27e570630137c0dbbe55b7aa819aaf9211..2f6da150d1e1375c332f7e55ea5b16c07f067a40 100644 --- a/paddle/fluid/operators/distributed/communicator.h +++ b/paddle/fluid/operators/distributed/communicator.h @@ -19,6 +19,7 @@ limitations under the License. */ #include #include #include +#include #include #include #include @@ -28,10 +29,12 @@ limitations under the License. */ #include "paddle/fluid/framework/scope.h" #include "paddle/fluid/framework/variable.h" +#include "paddle/fluid/operators/distributed/communicator_common.h" #include "paddle/fluid/operators/distributed/distributed.h" +#include "paddle/fluid/operators/distributed/large_scale_kv.h" #include "paddle/fluid/operators/distributed/rpc_client.h" -#include "paddle/fluid/operators/distributed/rpc_common.h" #include "paddle/fluid/operators/distributed_ops/send_recv_util.h" +#include "paddle/fluid/operators/math/blas.h" #include "paddle/fluid/operators/math/math_function.h" #include "paddle/fluid/operators/math/selected_rows_functor.h" #include "paddle/fluid/platform/device_context.h" @@ -55,7 +58,7 @@ class BlockingQueue { PADDLE_ENFORCE_GT(capacity_, 0, "The capacity must be greater than 0."); } - bool Push(const T& elem) { + bool Push(const T &elem) { { std::unique_lock lock(mutex_); cv_.wait(lock, [&] { return queue_.size() < capacity_; }); @@ -66,7 +69,7 @@ class BlockingQueue { return true; } - bool Push(T&& elem) { + bool Push(T &&elem) { { std::unique_lock lock(mutex_); cv_.wait(lock, [&] { return queue_.size() < capacity_; }); @@ -109,23 +112,23 @@ template ; template -inline void MergeVars(const std::string& var_name, - const std::vector>& vars, - Scope* scope, bool merge_add = true) { +inline void MergeVars(const std::string &var_name, + const std::vector> &vars, + Scope *scope, bool merge_add = true) { PADDLE_ENFORCE(!vars.empty(), "should have value to merge!"); auto cpu_place = platform::CPUPlace(); - auto& var0 = vars[0]; - auto* out_var = scope->Var(var_name); + auto &var0 = vars[0]; + auto *out_var = scope->Var(var_name); if (var0->IsType()) { auto dims = var0->Get().dims(); VLOG(3) << "merge " << var_name << " LoDTensor dims " << dims << "; merge add: " << merge_add; // init output tensor - auto* out_t = out_var->GetMutable(); + auto *out_t = out_var->GetMutable(); out_t->mutable_data(dims, cpu_place); // check the input dims - for (auto& var : vars) { - auto& var_t = var->Get(); + for (auto &var : vars) { + auto &var_t = var->Get(); PADDLE_ENFORCE_EQ(var_t.dims(), dims, "should have the same dims"); } @@ -135,8 +138,8 @@ inline void MergeVars(const std::string& var_name, constant_functor(cpu_ctx, out_t, static_cast(0)); // sum all vars to out auto result = EigenVector::Flatten(*out_t); - for (auto& var : vars) { - auto& in_t = var->Get(); + for (auto &var : vars) { + auto &in_t = var->Get(); auto in = EigenVector::Flatten(in_t); result.device(*cpu_ctx.eigen_device()) = result + in; } @@ -145,13 +148,13 @@ inline void MergeVars(const std::string& var_name, result / static_cast(vars.size()); } } else if (var0->IsType()) { - auto& slr0 = var0->Get(); - auto* out_slr = out_var->GetMutable(); + auto &slr0 = var0->Get(); + auto *out_slr = out_var->GetMutable(); out_slr->mutable_rows()->clear(); out_slr->mutable_value()->mutable_data({{}}, cpu_place); - std::vector inputs; + std::vector inputs; inputs.reserve(vars.size()); - for (auto& var : vars) { + for (auto &var : vars) { inputs.push_back(&var->Get()); } auto dev_ctx = paddle::platform::CPUDeviceContext(); @@ -171,190 +174,187 @@ inline void MergeVars(const std::string& var_name, } } -using RpcCtxMap = std::unordered_map; +using RpcCtxMap = std::unordered_map; +using SparseValue = std::unordered_map>; class Communicator { public: Communicator(); - explicit Communicator(const std::map& envs); + + explicit Communicator(const std::map &envs_) { + for (auto &iter : envs_) { + envs[iter.first] = iter.second; + } + } + virtual ~Communicator() {} virtual void Start() = 0; + virtual void Stop() = 0; + virtual bool IsRunning() { return running_; } virtual void Clean() {} - virtual void Send(const std::vector& var_names, - const std::vector& var_tables, - const framework::Scope& scope) = 0; + virtual void Send(const std::vector &var_names, + const std::vector &var_tables, + const framework::Scope &scope) = 0; - virtual void Recv() = 0; + virtual void RecvNoBarrier() {} virtual void Barrier() {} + virtual void BarrierTriggerDecrement() {} + virtual void BarrierTriggerReset(int init_counter) {} - virtual void InitImpl(const RpcCtxMap& send_varname_to_ctx, - const RpcCtxMap& recv_varname_to_ctx, - Scope* recv_scope) {} - virtual void InitImpl(const paddle::framework::ProgramDesc& program, - Scope* recv_scope) = 0; + virtual void InitEnvs() = 0; + + virtual void InitImpl(const RpcCtxMap &send_varname_to_ctx, + const RpcCtxMap &recv_varname_to_ctx, + Scope *recv_scope) {} + + static Communicator *GetInstance() { return communicator_.get(); } - static Communicator* GetInstance() { return communicator_.get(); } static std::shared_ptr GetInstantcePtr() { return communicator_; } + template - static Communicator* InitInstance( - const paddle::framework::ProgramDesc& program, Scope* recv_scope, - const std::map& envs) { - std::call_once(init_flag_, &Communicator::InitWithProgram, program, - recv_scope, std::ref(envs)); + static Communicator *InitInstance( + const RpcCtxMap &send_ctx, const RpcCtxMap &recv_ctx, Scope *recv_scope, + const std::map &envs) { + std::call_once(init_flag_, &Communicator::InitWithRpcCtx, send_ctx, + recv_ctx, recv_scope, std::ref(envs)); return communicator_.get(); } + // Init is called by InitInstance. template - static void InitWithProgram(const paddle::framework::ProgramDesc& program, - Scope* recv_scope, - const std::map& envs) { + static void InitWithRpcCtx(const RpcCtxMap &send_ctx, + const RpcCtxMap &recv_ctx, Scope *recv_scope, + const std::map &envs) { if (communicator_.get() == nullptr) { communicator_.reset(new T(std::ref(envs))); - communicator_->InitImpl(program, recv_scope); + communicator_->InitEnvs(); + communicator_->InitImpl(send_ctx, recv_ctx, recv_scope); } } protected: bool running_ = false; + bool waiting_ = true; static std::shared_ptr communicator_; static std::once_flag init_flag_; std::unordered_map envs; }; -using SparseIdsMap = - std::unordered_map>>; - class AsyncCommunicator : public Communicator { public: AsyncCommunicator() : Communicator() {} - explicit AsyncCommunicator(const std::map& envs) - : Communicator(envs) { - independent_recv_thread_ = static_cast( - std::stoi(envs.at("communicator_independent_recv_thread"))); + + explicit AsyncCommunicator(const std::map &envs) + : Communicator(envs) {} + + ~AsyncCommunicator(); + + void InitEnvs() { min_send_grad_num_before_recv_ = std::stoi(envs.at("communicator_min_send_grad_num_before_recv")); thread_pool_size_ = std::stoi(envs.at("communicator_thread_pool_size")); max_merge_var_num_ = std::stoi(envs.at("communicator_max_merge_var_num")); send_wait_times_ = std::stoi(envs.at("communicator_send_wait_times")); send_queue_size_ = std::stoi(envs.at("communicator_send_queue_size")); - is_sgd_optimizer_ = - static_cast(std::stoi(envs.at("communicator_is_sgd_optimizer"))); + need_global_step_ = + static_cast(std::stoi(envs.at("need_global_step"))); VLOG(0) << "AsyncCommunicator Initialized"; } - ~AsyncCommunicator(); + void Start() override; + void Stop() override; - void Recv() override; - void RecvAll(); + void InitImpl(const RpcCtxMap &send_varname_to_ctx, + const RpcCtxMap &recv_varname_to_ctx, + Scope *recv_scope) override; - void InitImpl(const RpcCtxMap& send_varname_to_ctx, - const RpcCtxMap& recv_varname_to_ctx, - Scope* recv_scope) override; + void MainThread(); - void InitImpl(const paddle::framework::ProgramDesc& program, - Scope* recv_scope) override; + void Send(const std::vector &var_names, + const std::vector &var_tables, + const framework::Scope &scope) override; - void SendThread(); - void RecvThread(); + virtual void SendByCommunicator(int batches); - void Send(const std::vector& var_names, - const std::vector& var_tables, - const framework::Scope& scope) override; + virtual void SendGlobalStep(int batches); - private: + virtual void RecvByCommunicator(); + + virtual void RecvNoBarrier(); + + virtual int Meet(); + + virtual void BarrierSend() {} + + virtual void BarrierRecv() {} + + virtual void BarrierWeakUp() {} + + protected: int min_send_grad_num_before_recv_; int thread_pool_size_; int max_merge_var_num_; int send_wait_times_; int send_queue_size_; - bool independent_recv_thread_; - bool is_sgd_optimizer_; + int trainer_id_ = 0; + bool need_global_step_ = false; - private: std::unordered_map>>> send_varname_to_queue_; RpcCtxMap send_varname_to_ctx_; RpcCtxMap recv_varname_to_ctx_; - std::unique_ptr send_thread_{nullptr}; - std::unique_ptr recv_thread_{nullptr}; - Scope* recv_scope_; // should be global scope + std::unique_ptr main_thread_{nullptr}; + Scope *recv_scope_; // should be global scope std::unique_ptr send_scope_; // an independent scope std::unique_ptr<::ThreadPool> send_threadpool_{nullptr}; std::unique_ptr<::ThreadPool> recv_threadpool_{nullptr}; std::atomic_uint grad_num_{0}; // the num of gradient sent since last recv }; -class HalfAsyncCommunicator : public Communicator { +class HalfAsyncCommunicator : public AsyncCommunicator { public: HalfAsyncCommunicator() {} - explicit HalfAsyncCommunicator(const std::map& envs) - : Communicator(envs) { + + explicit HalfAsyncCommunicator(const std::map &envs) + : AsyncCommunicator(envs) {} + + void InitEnvs() { + min_send_grad_num_before_recv_ = 0; + max_merge_var_num_ = std::stoi(envs.at("communicator_max_merge_var_num")); send_wait_times_ = std::stoi(envs.at("communicator_send_wait_times")); thread_pool_size_ = std::stoi(envs.at("communicator_thread_pool_size")); send_queue_size_ = std::stoi(envs.at("communicator_send_queue_size")); + need_global_step_ = + static_cast(std::stoi(envs.at("need_global_step"))); VLOG(0) << "HalfAsyncCommunicator Initialized"; } - ~HalfAsyncCommunicator(); - void Start() override; - void Stop() override; void Clean() override; - void Send(const std::vector& var_names, - const std::vector& var_tables, - const framework::Scope& scope) override; - - void Recv() override; - void Barrier() override; - void BarrierWeakUp(); void BarrierTriggerDecrement() override; - void BarrierTriggerReset(int initial_val) override; - - void InitImpl(const RpcCtxMap& send_varname_to_ctx, - const RpcCtxMap& recv_varname_to_ctx, - Scope* recv_scope) override; - void InitImpl(const paddle::framework::ProgramDesc& program, - Scope* recv_scope) override; + void BarrierTriggerReset(int initial_val) override; - void ConsumeThread(); - virtual void BarrierSend() {} - virtual void BarrierRecv() {} + int Meet(); - protected: - int max_merge_var_num_; - int send_wait_times_; - int thread_pool_size_; - int send_queue_size_; - int trainer_id_ = 0; + void BarrierWeakUp(); protected: - std::unordered_map>>> - send_varname_to_queue_; - RpcCtxMap send_varname_to_ctx_; - RpcCtxMap recv_varname_to_ctx_; - std::unique_ptr consume_thread_{nullptr}; - Scope* recv_scope_; // should be global scope - std::unique_ptr send_scope_; // an independent scope - std::unique_ptr<::ThreadPool> consume_threadpool_{nullptr}; - std::unique_ptr<::ThreadPool> recv_threadpool_{nullptr}; - // mutex for Wait for barrier std::mutex barrier_mutex_; std::condition_variable barrier_cond_; @@ -365,122 +365,85 @@ class HalfAsyncCommunicator : public Communicator { class SyncCommunicator : public HalfAsyncCommunicator { public: SyncCommunicator() : HalfAsyncCommunicator() {} - explicit SyncCommunicator(const std::map& envs) - : HalfAsyncCommunicator(envs) { + + explicit SyncCommunicator(const std::map &envs) + : HalfAsyncCommunicator(envs) {} + + void InitEnvs() { + min_send_grad_num_before_recv_ = 0; + + max_merge_var_num_ = std::stoi(envs.at("communicator_max_merge_var_num")); + send_wait_times_ = std::stoi(envs.at("communicator_send_wait_times")); + thread_pool_size_ = std::stoi(envs.at("communicator_thread_pool_size")); + send_queue_size_ = std::stoi(envs.at("communicator_send_queue_size")); + need_global_step_ = + static_cast(std::stoi(envs.at("need_global_step"))); + trainer_id_ = std::stoi(envs.at("trainer_id")); auto pserver_strings = envs.at("pserver_endpoints"); pserver_endpoints_ = paddle::string::Split(pserver_strings, ','); VLOG(0) << "SyncCommunicator Initialized"; } - ~SyncCommunicator(); + void BarrierSend(); + void BarrierRecv(); private: std::vector pserver_endpoints_{}; }; -class GeoSgdCommunicator : public Communicator { +class GeoCommunicator : public AsyncCommunicator { public: - GeoSgdCommunicator() : Communicator() {} - explicit GeoSgdCommunicator(const std::map& envs) - : Communicator(envs) { - geo_need_push_nums_ = std::stoi(envs.at("geo_need_push_nums")); - trainer_nums_ = std::stoi(envs.at("geo_trainer_nums")); - thread_pool_size_ = std::stoi(envs.at("communicator_thread_pool_size")); + GeoCommunicator() : AsyncCommunicator() {} + + explicit GeoCommunicator(const std::map &envs) + : AsyncCommunicator(envs) {} + + void InitImpl(const RpcCtxMap &send_varname_to_ctx, + const RpcCtxMap &recv_varname_to_ctx, + Scope *recv_scope) override; + + void InitEnvs() { + min_send_grad_num_before_recv_ = 0; + + max_merge_var_num_ = std::stoi(envs.at("communicator_max_merge_var_num")); send_wait_times_ = std::stoi(envs.at("communicator_send_wait_times")); - VLOG(0) << "GeoSgdCommunicator Initialized"; + thread_pool_size_ = std::stoi(envs.at("communicator_thread_pool_size")); + + send_queue_size_ = max_merge_var_num_; + trainers_ = std::stoi(envs.at("trainers")); + sparse_attrs_ = envs.at("sparse_attrs"); + VLOG(0) << "GeoCommunicator Initialized"; } - ~GeoSgdCommunicator(); + void Send(const std::vector &var_names, + const std::vector &var_tables, + const framework::Scope &scope) override; - void Start() override; - void Stop() override; + void SendByCommunicator(int batches) override; - void Send(const std::vector& var_names, - const std::vector& var_tables, - const framework::Scope& scope) override; + void SendSparse(const std::string &varname, int batches); - void Recv() override; + void SendDense(const std::string &varname); - void InitImpl(const paddle::framework::ProgramDesc& program, - Scope* recv_scope) override; + void SendGlobalStep(int batches) override {} - private: - void SendThread(); - std::unordered_set SparseIdsMerge( - const std::vector& ids_send_vec, - const std::string& var_name, const std::string& splited_var_name); - - void SendUpdateDenseVars(const std::string& var_name, - const std::string& splited_var_name); - - void SendUpdateSparseVars(const std::string& var_name, - const std::string& splited_var_name, - const std::unordered_set& ids_table); - - void RecvUpdateDenseVars(const std::string& var_name, - const std::string& splited_var_name); - void RecvUpdateSparseVars(const std::string& var_name, - const std::string& splited_var_name); - - void GeoSgdDenseParamInit(framework::Scope* scope_x, - framework::Scope* scope_y, - const std::string var_name); - - void GeoSgdSparseParamInit(framework::Scope* scope_x, - framework::Scope* scope_y, - const std::string var_name); - - void RpcSend(const std::string& origin_var_name, - const std::string& splited_var_name, - const size_t& splited_var_index); - - void RpcRecv(const std::string& origin_var_name, - const std::string& splited_var_name, - const size_t& splited_var_index); - - const std::string VarToDeltaVar(const std::string var_name) { - std::string delta_name = var_name; - const std::string send_name = delta_name.append(".delta"); - return send_name; - } + void RecvByCommunicator() override; - const std::string DeltaVarToVar(const std::string var_name) { - std::string origin_name = var_name; - origin_name.erase(origin_name.find(".delta"), 6); - const std::string param_name = origin_name; - return param_name; - } + void RecvSparse(const std::string &varname); - size_t GetSplitedVarIndex(const std::string var_name, - const std::string splited_var_name) { - size_t index = 0; - for (size_t i = 0; - i < send_varname_to_ctx_[var_name].splited_var_names.size(); i++) { - if (send_varname_to_ctx_[var_name].splited_var_names[i] == - splited_var_name) { - index = i; - break; - } - } - return index; - } + void RecvDense(const std::string &varname); - private: - int trainer_nums_ = 1; - int geo_need_push_nums_ = 100; - int thread_pool_size_; - int send_wait_times_; + void Init(); - private: - int send_var_nums_ = 0; + void InitSparse(); - RpcCtxMap send_varname_to_ctx_; - RpcCtxMap recv_varname_to_ctx_; + void InitDense(const std::string varname); - // parameter for local training - Scope* training_scope_; + private: + int trainers_; + std::string sparse_attrs_; // parameter for delta calc and send std::shared_ptr delta_scope_; @@ -491,20 +454,11 @@ class GeoSgdCommunicator : public Communicator { // parameter on pserver std::shared_ptr pserver_scope_; - // if var is sparse, using selected rows, bool=true - std::unordered_map var_list_; - - std::shared_ptr>> - need_push_queue_; - std::vector ids_send_vec_; - - std::unordered_map> absolute_section_; - std::unordered_map vars_first_dimension_; - - std::unique_ptr<::ThreadPool> send_threadpool_{nullptr}; - std::unique_ptr send_thread_{nullptr}; + std::unordered_map>>> + send_ids_to_queue_; - size_t need_thread_nums_{0}; + std::unordered_map> old_sparses_; }; } // namespace distributed diff --git a/paddle/fluid/operators/distributed/communicator_common.h b/paddle/fluid/operators/distributed/communicator_common.h new file mode 100644 index 0000000000000000000000000000000000000000..122d904eba27aa86fe333312340788dc0aef0d47 --- /dev/null +++ b/paddle/fluid/operators/distributed/communicator_common.h @@ -0,0 +1,91 @@ +/* Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +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. */ + +#pragma once + +#include +#include +#include + +namespace paddle { +namespace operators { +namespace distributed { + +struct CommContext { + CommContext() = default; + + CommContext(const std::string &name, const std::vector &names, + const std::vector &emap, + const std::vector §ions, + const std::vector &origin_names, int id, + bool merge_add_ = true, bool is_sparse_ = true, + bool is_distributed_ = false) + : var_name(name), + splited_varnames(names), + epmap(emap), + height_sections(sections), + origin_varnames(origin_names), + trainer_id(id), + merge_add(merge_add_), + is_sparse(is_sparse_), + is_distributed(is_distributed_) {} + + CommContext(const CommContext &ctx) { + var_name = ctx.var_name; + splited_varnames = ctx.splited_varnames; + epmap = ctx.epmap; + height_sections = ctx.height_sections; + trainer_id = ctx.trainer_id; + merge_add = ctx.merge_add; + is_sparse = ctx.is_sparse; + origin_varnames = ctx.origin_varnames; + is_distributed = ctx.is_distributed; + } + + std::string print() const { + std::stringstream ss; + + ss << "varname: " << var_name << " trainer_id: " << trainer_id << " "; + + for (size_t i = 0; i < splited_varnames.size(); i++) { + ss << "slice varname: " << splited_varnames[i] << " ep: " << epmap[i] + << " section: " << height_sections[i] << " "; + } + + ss << "origin varnames: "; + for (size_t i = 0; i < origin_varnames.size(); i++) { + ss << origin_varnames[i] << " "; + } + + ss << " aggregation->add: " << merge_add << " "; + ss << " is_sparse: " << is_sparse << "\n"; + ss << " is_distributed: " << is_distributed << "\n"; + + return ss.str(); + } + + std::string var_name; + std::vector splited_varnames; + std::vector epmap; + std::vector height_sections; + std::vector origin_varnames; + int trainer_id; + bool merge_add; + bool is_sparse; + bool is_distributed; +}; + +} // namespace distributed +} // namespace operators +} // namespace paddle diff --git a/paddle/fluid/operators/distributed/grpc/grpc_client.cc b/paddle/fluid/operators/distributed/grpc/grpc_client.cc index 0652f8691218dc688732bd4243315b188cd0b053..edbe945cd72bda15b506305dbfe80a3dbe085908 100644 --- a/paddle/fluid/operators/distributed/grpc/grpc_client.cc +++ b/paddle/fluid/operators/distributed/grpc/grpc_client.cc @@ -409,7 +409,8 @@ VarHandlePtr GRPCClient::AsyncSendComplete(const std::string& ep, } VarHandlePtr GRPCClient::AsyncCheckpointNotify(const std::string& ep, - const std::string& dir, + const std::string& dirname, + const std::string& varname, int64_t time_out) { const auto ch = GetChannel(ep); @@ -422,8 +423,8 @@ VarHandlePtr GRPCClient::AsyncCheckpointNotify(const std::string& ep, s->Prepare(h, time_out); sendrecv::VariableMessage req; - req.set_varname(CHECKPOINT_SAVE_MESSAGE); - req.set_out_varname(dir); + req.set_varname(varname); + req.set_out_varname(dirname); platform::RecordRPCEvent record_event(method); diff --git a/paddle/fluid/operators/distributed/grpc/grpc_client.h b/paddle/fluid/operators/distributed/grpc/grpc_client.h index 2e0599d885103b7cadaf0e93ef7828f1594dcc3e..bd9f25567dc07381ac8f9010b8a41bbe49c50017 100644 --- a/paddle/fluid/operators/distributed/grpc/grpc_client.h +++ b/paddle/fluid/operators/distributed/grpc/grpc_client.h @@ -222,7 +222,8 @@ class GRPCClient : public RPCClient { int64_t time_out = FLAGS_rpc_deadline) override; VarHandlePtr AsyncCheckpointNotify( - const std::string& ep, const std::string& dir, + const std::string& ep, const std::string& dirname, + const std::string& varname, int64_t time_out = FLAGS_rpc_deadline) override; VarHandlePtr AsyncDistributeNotify( diff --git a/paddle/fluid/operators/distributed/grpc/grpc_server.cc b/paddle/fluid/operators/distributed/grpc/grpc_server.cc index 784749bc910bbf38446fa8c08c289953fba097fb..e7effcc1805f83eb16f07ceb7db53ce08983ad60 100644 --- a/paddle/fluid/operators/distributed/grpc/grpc_server.cc +++ b/paddle/fluid/operators/distributed/grpc/grpc_server.cc @@ -103,11 +103,13 @@ class RequestSend final : public RequestBase { void Process() override { std::string varname = GetReqName(); - VLOG(4) << "RequestSend var_name:" << varname; auto scope = request_->GetMutableLocalScope(); auto invar = request_->GetVar(); int trainer_id = request_->GetTrainerId(); + + VLOG(4) << "RequestSend var_name:" << varname << " trainer: " << trainer_id; + framework::Variable* outvar = nullptr; request_handler_->Handle(varname, scope, invar, &outvar, trainer_id); Finish(reply_, &responder_); @@ -332,8 +334,9 @@ class RequestPrefetch final : public RequestBase { std::string out_var_name = request_->OutVarname(); std::string table_name = request_->TableName(); int trainer_id = request_->GetTrainerId(); + VLOG(4) << "RequestPrefetch, in_var_name: " << in_var_name - << " out_var_name: " << out_var_name; + << " out_var_name: " << out_var_name << " trainer: " << trainer_id; auto scope = request_->GetMutableLocalScope(); auto invar = scope->FindVar(in_var_name); diff --git a/paddle/fluid/operators/distributed/large_scale_kv.cc b/paddle/fluid/operators/distributed/large_scale_kv.cc new file mode 100644 index 0000000000000000000000000000000000000000..d2673ed6ffb3667eed2a4599ae462587c18431b0 --- /dev/null +++ b/paddle/fluid/operators/distributed/large_scale_kv.cc @@ -0,0 +1,26 @@ +// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// 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. + +#include "paddle/fluid/operators/distributed/large_scale_kv.h" + +namespace paddle { +namespace operators { +namespace distributed { + +std::once_flag LargeScaleKV::init_flag_; +std::shared_ptr LargeScaleKV::scale_kv_(nullptr); + +} // namespace distributed +} // namespace operators +} // namespace paddle diff --git a/paddle/fluid/operators/distributed/large_scale_kv.h b/paddle/fluid/operators/distributed/large_scale_kv.h new file mode 100644 index 0000000000000000000000000000000000000000..eb2433a1f068d03314fe54457a06cccefe839aad --- /dev/null +++ b/paddle/fluid/operators/distributed/large_scale_kv.h @@ -0,0 +1,844 @@ +// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// 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. + +#pragma once + +#include + +#include +#include // NOLINT +#include +#include +#include +#include +#include +#include + +#include // NOLINT + +#include + +#include "paddle/fluid/framework/lod_tensor.h" +#include "paddle/fluid/framework/rw_lock.h" +#include "paddle/fluid/framework/selected_rows.h" +#include "paddle/fluid/framework/tensor.h" +#include "paddle/fluid/framework/threadpool.h" +#include "paddle/fluid/framework/variable.h" +#include "paddle/fluid/platform/enforce.h" +#include "paddle/fluid/platform/place.h" +#include "paddle/fluid/platform/port.h" +#include "paddle/fluid/string/printf.h" +#include "paddle/fluid/string/string_helper.h" + +namespace paddle { +namespace operators { +namespace distributed { + +enum Mode { training, infer }; +enum InitType { uniform_random, fill_constant, gaussian_random }; + +inline std::vector bucket(const int v_size, const int b_size) { + int remainder = v_size % b_size; + int bucket = v_size / b_size; + std::vector ret_vec(b_size, bucket); + for (int i = 0; i < remainder; ++i) { + ret_vec[i] = ret_vec[i] + 1; + } + int cur_bucket = 0; + for (int &j : ret_vec) { + int tmp = j; + j = cur_bucket; + cur_bucket += tmp; + } + ret_vec.push_back(cur_bucket); + return ret_vec; +} + +class Initializer { + public: + Initializer() {} + + explicit Initializer(const std::vector &attrs) {} + + virtual float GetValue() = 0; + + virtual ~Initializer() {} + + protected: + std::string name_; + unsigned int seed_; +}; + +class UniformInitializer : public Initializer { + public: + explicit UniformInitializer(const std::vector &attrs) { + name_ = attrs[0]; + seed_ = static_cast(std::stoi(attrs[1])); + min_ = std::stof(attrs[2]); + max_ = std::stof(attrs[3]); + + if (seed_ == 0) { + seed_ = std::random_device()(); + } + + random_engine_.seed(seed_); + dist_ = std::uniform_real_distribution(min_, max_); + } + + float GetValue() override { return dist_(random_engine_); } + + private: + float min_; + float max_; + + std::minstd_rand random_engine_; + std::uniform_real_distribution dist_; +}; + +template +inline bool entry(const int count, const T threshold); + +template <> +inline bool entry(const int count, const std::string threshold) { + return true; +} + +template <> +inline bool entry(const int count, const int threshold) { + return count >= threshold; +} + +template <> +inline bool entry(const int count, const float threshold) { + UniformInitializer uniform = UniformInitializer({"0", "0", "1"}); + return uniform.GetValue() >= threshold; +} + +class GaussianInitializer : public Initializer { + public: + explicit GaussianInitializer(const std::vector &attrs) { + name_ = attrs[0]; + seed_ = static_cast(std::stoi(attrs[1])); + mean_ = std::stof(attrs[2]); + std_ = std::stof(attrs[3]); + + if (seed_ == 0) { + seed_ = std::random_device()(); + } + + random_engine_.seed(seed_); + dist_ = std::normal_distribution(mean_, std_); + } + + float GetValue() override { return dist_(random_engine_); } + + private: + float std_; + float mean_; + + std::minstd_rand random_engine_; + std::normal_distribution dist_; +}; + +class FillConstantInitializer : public Initializer { + public: + explicit FillConstantInitializer(const std::vector &attrs) { + name_ = attrs[0]; + value_ = std::stof(attrs[1]); + } + + float GetValue() override { return value_; } + + private: + float value_; +}; + +struct SparseMeta { + std::string name; + std::string grad_name; + std::vector value_names; + std::vector value_dims; + std::vector cached_varnames; + std::vector initializer_attrs; + std::string entry; + Mode mode; + + std::string ToString() { + std::stringstream ss; + ss << "name: " << name << " "; + ss << "mode: " << mode << " "; + + for (int i = 0; i < static_cast(value_names.size()); i++) { + ss << "value_name: " << value_names[i] << " dim: " << value_dims[i] + << " "; + } + + ss << " grad var: " << grad_name; + + ss << " cached varnames: "; + for (int i = 0; i < static_cast(cached_varnames.size()); i++) { + ss << cached_varnames[i] << " "; + } + + ss << " initializer attrs: "; + for (int i = 0; i < static_cast(initializer_attrs.size()); i++) { + ss << initializer_attrs[i] << " "; + } + + ss << " entry attrs: " << entry; + + return ss.str(); + } +}; + +struct VALUE { + explicit VALUE(const std::vector &names) + : names_(names), count_(0), unseen_days_(0) { + values_.resize(names.size()); + for (int i = 0; i < static_cast(names.size()); i++) { + places[names[i]] = i; + } + } + + void set(std::vector> *values) { + values_ = std::move(*values); + } + + void set(const std::vector &names, + const std::vector> &values) { + for (int i = 0; i < static_cast(names.size()); i++) { + auto idx = places[names[i]]; + auto value = values[i]; + values_[idx].assign(value.begin(), value.end()); + } + } + + std::vector *> get() { + auto pts = std::vector *>(); + pts.reserve(values_.size()); + + for (auto &value : values_) { + pts.push_back(&value); + } + return pts; + } + + int fetch_count() { return ++count_; } + void reset_unseen_days() { unseen_days_ = 0; } + + void set_entry(bool is_entry) { is_entry_ = is_entry; } + + bool get_entry() { return is_entry_; } + + std::vector *> get(const std::vector names) { + auto pts = std::vector *>(); + pts.reserve(values_.size()); + + for (int i = 0; i < static_cast(names.size()); i++) { + pts.push_back(&(values_[places[names[i]]])); + } + return pts; + } + + std::vector names_; + int count_; + int unseen_days_; + bool is_entry_; + std::vector> values_; + std::unordered_map places; +}; + +class ValueBlock { + public: + explicit ValueBlock(const std::vector value_names, + const std::vector value_dims, const Mode &mode, + const std::vector &init_attrs, + const std::string &entry_attr) + : value_names_(value_names), value_dims_(value_dims), mode_(mode) { + // for Initializer + for (size_t i = 0; i < value_names.size(); i++) { + auto name = value_names[i]; + auto slices = string::split_string(init_attrs[i], "&"); + + if (slices[0] == "gaussian_random") { + initializers_[name] = new GaussianInitializer(slices); + } else if (slices[0] == "fill_constant") { + initializers_[name] = new FillConstantInitializer(slices); + } else if (slices[0] == "uniform_random") { + initializers_[name] = new UniformInitializer(slices); + } else { + PADDLE_THROW( + platform::errors::InvalidArgument("%s can not be supported", name)); + } + } + + // for Entry + { + if (entry_attr == "none") { + entry_func_ = + std::bind(entry, std::placeholders::_1, "none"); + } else { + auto slices = string::split_string(entry_attr, "&"); + if (slices[0] == "count_filter") { + int threshold = std::stoi(slices[1]); + entry_func_ = std::bind(entry, std::placeholders::_1, threshold); + } else if (slices[0] == "probability") { + float threshold = std::stof(slices[1]); + entry_func_ = + std::bind(entry, std::placeholders::_1, threshold); + } + } + } + + rwlock_.reset(new framework::RWLock); + } + + ~ValueBlock() { + // for (auto init : initializers_) { + // delete init.second; + // initializers_.erase(init.first); + // } + // + // for (auto value : values_) { + // delete value.second; + // values_.erase(value.first); + // } + } + + void Init(const int64_t &id, std::vector> *values, + int count) { + if (Has(id)) { + PADDLE_THROW(platform::errors::AlreadyExists("id already exist, error")); + } + + if (values->size() != value_names_.size()) { + PADDLE_THROW( + platform::errors::AlreadyExists("values can not match, error")); + } + + auto value = new VALUE(value_names_); + value->set(values); + value->count_ = count; + values_[id] = value; + } + + std::vector *> Get( + const int64_t &id, const std::vector &value_names) { + rwlock_->RDLock(); + auto ret_values = values_.at(id)->get(value_names); + rwlock_->UNLock(); + return ret_values; + } + + void InitFromInitializer(const int64_t &id, + const std::vector &value_names) { + rwlock_->WRLock(); + + if (Has(id)) { + Update(id); + rwlock_->UNLock(); + return; + } + + auto rets = std::vector>(); + rets.resize(value_names_.size()); + + for (int i = 0; i < static_cast(value_names_.size()); i++) { + auto name = value_names_[i]; + auto *init = initializers_.at(name); + + auto dim = value_dims_[i]; + rets[i].resize(dim); + + for (int j = 0; j < static_cast(dim); j++) { + rets[i][j] = init->GetValue(); + } + } + + Init(id, &rets, 0); + Update(id); + rwlock_->UNLock(); + } + + bool GetEntry(const int64_t &id) { + rwlock_->RDLock(); + auto value = values_.at(id); + auto entry = value->get_entry(); + rwlock_->UNLock(); + return entry; + } + + void Set(const int64_t &id, const std::vector &value_names, + const std::vector> &values) { + rwlock_->WRLock(); + auto value = values_.at(id); + value->set(value_names, values); + rwlock_->UNLock(); + } + + void Update(const int64_t id) { + auto *value = values_.at(id); + value->reset_unseen_days(); + auto count = value->fetch_count(); + + if (!value->get_entry()) { + value->set_entry(entry_func_(count)); + } + } + + private: + bool Has(const int64_t id) { + auto got = values_.find(id); + if (got == values_.end()) { + return false; + } else { + return true; + } + } + + public: + std::unordered_map values_; + + private: + std::vector value_names_; + std::vector value_dims_; + Mode mode_; + std::function entry_func_; + std::unordered_map initializers_; + std::unique_ptr rwlock_{nullptr}; +}; + +class SparseVariable { + public: + explicit SparseVariable(const SparseMeta &meta) { + meta_.name = meta.name; + meta_.mode = meta.mode; + meta_.value_names = meta.value_names; + meta_.value_dims = meta.value_dims; + meta_.grad_name = meta.grad_name; + meta_.cached_varnames = meta.cached_varnames; + meta_.initializer_attrs = meta.initializer_attrs; + meta_.entry = meta.entry; + + for (int i = 0; i < static_cast(meta_.value_names.size()); i++) { + values_dims_[meta_.value_names[i]] = meta_.value_dims[i]; + } + + for (size_t i = 0; i < shard_num_; i++) { + auto block = std::make_shared( + meta.value_names, meta.value_dims, meta.mode, meta.initializer_attrs, + meta.entry); + shard_blocks_.emplace_back(block); + } + + rwlock_.reset(new framework::RWLock); + } + + void Init(const std::vector &ids) { + rwlock_->RDLock(); + for (auto &id : ids) { + auto *block = GetShard(id); + block->InitFromInitializer(id, meta_.value_names); + } + rwlock_->UNLock(); + } + + void Get(const std::vector &ids, + const std::vector &value_names, + std::vector *>> *values) { + values->resize(ids.size()); + + auto buckets = bucket(ids.size(), 8); + std::vector> fs; + + for (int j = 0; j < 8; ++j) { + auto begin = buckets[j]; + auto end = buckets[j + 1]; + + fs.push_back( + framework::Async([begin, end, &values, &ids, &value_names, this]() { + for (int x = begin; x < end; x++) { + auto id = ids[x]; + auto *block = GetShard(id); + auto id_values = block->Get(id, value_names); + (*values)[x] = id_values; + } + })); + } + + for (size_t i = 0; i < fs.size(); ++i) fs[i].wait(); + } + + void GetEntry(const std::vector &ids, std::vector *values) { + auto buckets = bucket(ids.size(), 8); + std::vector> fs; + + for (int j = 0; j < 8; ++j) { + auto begin = buckets[j]; + auto end = buckets[j + 1]; + + fs.push_back(framework::Async([begin, end, &values, &ids, this]() { + for (int x = begin; x < end; x++) { + auto id = ids[x]; + auto *block = GetShard(id); + auto is_entry = block->GetEntry(id); + + if (!is_entry) { + values->push_back(id); + } + } + })); + } + for (size_t i = 0; i < fs.size(); ++i) fs[i].wait(); + } + + void Set(const std::vector &ids, + const std::vector &value_names, + const std::vector>> &values) { + for (int i = 0; i < static_cast(ids.size()); i++) { + GetShard(ids[i])->Set(ids[i], value_names, values[i]); + } + } + + void Dims(std::vector value_names, std::vector *dims) { + for (auto &name : value_names) { + dims->push_back(values_dims_.at(name)); + } + } + + std::vector CachedVarnames() const { + return meta_.cached_varnames; + } + + void Load(const std::string &dirname) { + rwlock_->WRLock(); + VLOG(1) << "load " << meta_.name << " from dir: " << dirname << " begin"; + + std::vector filenames; + for (auto &value_name : meta_.value_names) { + auto filename = string::Sprintf("%s/%s", dirname, value_name); + filenames.push_back(filename); + } + + LoadFromSelectedRows(filenames, meta_.value_names); + VLOG(1) << "load " << meta_.name << " in dir: " << dirname << " done"; + rwlock_->UNLock(); + } + + void LoadFromSelectedRows(const std::vector &filenames, + const std::vector &valuenames) { + std::vector> variables; + auto place = platform::CPUPlace(); + + for (int i = 0; i < static_cast(filenames.size()); i++) { + auto var = std::make_shared(); + variables.push_back(var); + auto &filename = filenames[i]; + std::ifstream fin(filename, std::ios::binary); + auto *selectedRows = var->GetMutable(); + + platform::DeviceContextPool &pool = + platform::DeviceContextPool::Instance(); + auto &dev_ctx = *pool.Get(place); + + framework::DeserializeFromStream(fin, selectedRows, dev_ctx); + selectedRows->SyncIndex(); + } + + std::vector tensors; + + for (int i = 0; i < static_cast(filenames.size()); i++) { + auto &slr = variables[i]->Get(); + auto src_t = slr.value(); + const auto *value = src_t.data(); + tensors.push_back(value); + } + + for (int i = 1; i < static_cast(filenames.size()); i++) { + auto rows_0 = variables[0]->Get().rows(); + auto rows_i = variables[i]->Get().rows(); + + bool is_equal = std::equal(rows_0.begin(), rows_0.end(), rows_i.begin()); + + if (!is_equal) { + PADDLE_THROW(platform::errors::InvalidArgument( + "%s and %s are not equal, can not be load rightly", filenames[0], + filenames[i])); + } + } + + auto rows = variables[0]->Get().rows(); + + for (auto i = 0; i < static_cast(rows.size()); i++) { + auto id = rows[i]; + std::vector> values; + values.resize(filenames.size()); + + for (int j = 0; j < static_cast(filenames.size()); ++j) { + values[j].resize(meta_.value_dims[j]); + std::memcpy(values[j].data(), tensors[j] + i * meta_.value_dims[j], + sizeof(float) * meta_.value_dims[j]); + } + + auto *block = GetShard(id); + block->Init(id, &values, 0); + block->Update(id); + } + } + + void Save(const std::string &dirname) { + rwlock_->WRLock(); + VLOG(1) << "save " << meta_.name << " in dir: " << dirname << " begin"; + + MkDirRecursively(dirname.c_str()); + + std::vector filenames; + for (auto &value_name : meta_.value_names) { + auto filename = string::Sprintf("%s/%s", dirname, value_name); + filenames.push_back(filename); + } + SaveToSelectedRows(filenames, meta_.value_names); + + // // save sparse to text + // std::vector txt_filenames; + // for (auto &value_name : meta_.value_names) { + // auto filename = string::Sprintf("%s/%s.txt", dirname, value_name); + // txt_filenames.push_back(filename); + // } + // SaveToText(txt_filenames, meta_.value_names); + + VLOG(1) << "save " << meta_.name << " in dir: " << dirname << " done"; + rwlock_->UNLock(); + } + + void SaveToSelectedRows(const std::vector &filenames, + const std::vector &valuenames) { + for (auto &value_name : valuenames) { + auto it = std::find(meta_.value_names.begin(), meta_.value_names.end(), + value_name); + if (it == meta_.value_names.end()) { + PADDLE_THROW(platform::errors::InvalidArgument( + "[%s] is invalid param for [%s]", value_name, meta_.name)); + } + } + + auto place = platform::CPUPlace(); + platform::DeviceContextPool &pool = platform::DeviceContextPool::Instance(); + auto &dev_ctx = *pool.Get(place); + + int64_t ids_num = 0; + for (auto &block : shard_blocks_) { + ids_num += block->values_.size(); + } + + std::vector> variables; + std::vector tensors; + std::vector ids; + std::vector dims; + + for (int i = 0; i < static_cast(filenames.size()); i++) { + auto dim = values_dims_.at(valuenames[i]); + auto var = std::make_shared(); + auto *slr = var->GetMutable(); + auto *src_t = slr->mutable_value(); + + src_t->Resize({ids_num, dim}); + auto *value = src_t->mutable_data(place); + + dims.push_back(dim); + variables.push_back(var); + tensors.push_back(value); + } + + int64_t offset = 0; + for (auto &block : shard_blocks_) { + for (auto value : block->values_) { + ids.push_back(value.first); + std::vector *> vss = value.second->get(valuenames); + + for (int i = 0; i < static_cast(vss.size()); i++) { + auto &vs = vss[i]; + std::memcpy(tensors[i] + offset * dims[i], vs->data(), + sizeof(float) * dims[i]); + } + + offset += 1; + } + } + + for (auto &var : variables) { + auto *slr = var->GetMutable(); + slr->set_rows(ids); + slr->set_height(ids.size()); + } + + for (int i = 0; i < static_cast(filenames.size()); i++) { + auto &filename = filenames[i]; + auto &selectedRows = variables[i]->Get(); + + std::ofstream fout(filename, std::ios::binary); + PADDLE_ENFORCE_EQ(static_cast(fout), true, + platform::errors::Unavailable( + "Cannot open %s to save variables.", filename)); + + framework::SerializeToStream(fout, selectedRows, dev_ctx); + fout.close(); + } + } + + void SaveToText(const std::vector &filenames, + const std::vector &valuenames) { + for (auto &value_name : valuenames) { + auto it = std::find(meta_.value_names.begin(), meta_.value_names.end(), + value_name); + if (it == meta_.value_names.end()) { + PADDLE_THROW(platform::errors::InvalidArgument( + "[%s] is invalid param for [%s]", value_name, meta_.name)); + } + } + + std::vector> fouts; + + for (auto filename : filenames) { + std::unique_ptr fout(new std::ofstream(filename)); + fouts.push_back(std::move(fout)); + } + + for (auto &block : shard_blocks_) { + for (auto value : block->values_) { + std::vector *> vss = value.second->get(valuenames); + + auto id = value.first; + + for (int i = 0; i < static_cast(vss.size()); i++) { + auto &vs = vss[i]; + std::stringstream ss; + ss << id << "\t"; + ss << vs->size() << "\t"; + for (auto v : (*vs)) { + ss << v << " "; + } + ss << "\n"; + + fouts[i]->write(ss.str().c_str(), sizeof(char) * ss.str().size()); + } + } + } + + for (int i = 0; i < static_cast(fouts.size()); i++) { + fouts[i]->close(); + } + } + + int64_t Size() { + int64_t cnt = 0; + + for (auto &block : shard_blocks_) { + cnt += block->values_.size(); + } + return cnt; + } + + ValueBlock *GetShard(const int64_t id) { + return shard_blocks_[id & shard_mask_].get(); + } + + SparseMeta *GetMeta() { return &meta_; } + + private: + std::unique_ptr rwlock_{nullptr}; + + SparseMeta meta_; + std::unordered_map values_dims_; + const size_t shard_mask_ = 127; + const size_t shard_num_ = 128; + std::vector> shard_blocks_; +}; + +class LargeScaleKV { + public: + LargeScaleKV() {} + + explicit LargeScaleKV(const std::vector &table_metas) { + for (auto &sparse_meta : table_metas) { + auto table_name = sparse_meta.name; + auto meta = std::shared_ptr( + new SparseVariable(std::move(sparse_meta))); + sparse_variables[table_name] = meta; + grad_to_variables[sparse_meta.grad_name] = table_name; + grad_names_.push_back(sparse_meta.grad_name); + } + } + + ~LargeScaleKV() {} + + static std::shared_ptr GetInstantcePtr() { return scale_kv_; } + + static LargeScaleKV *GetInstance() { return scale_kv_.get(); } + + static LargeScaleKV *InitInstance( + const std::vector &table_metas) { + std::call_once(init_flag_, &LargeScaleKV::Init, table_metas); + return scale_kv_.get(); + } + + static void Init(const std::vector &table_metas) { + if (scale_kv_.get() == nullptr) { + scale_kv_.reset(new LargeScaleKV(table_metas)); + } + } + + SparseVariable *Get(const std::string &name) { + auto variable = sparse_variables.at(name); + return variable.get(); + } + + bool ParamInLargeScale(const std::string &name) { + auto got = sparse_variables.find(name); + + if (got == sparse_variables.end()) { + return false; + } + + return true; + } + + bool GradInLargeScale(const std::string &name) { + auto got = grad_to_variables.find(name); + + if (got == grad_to_variables.end()) { + return false; + } + + return true; + } + + SparseVariable *GetByGrad(const std::string &name) { + return Get(grad_to_variables[name]); + } + + const std::vector &GetAllGrads() { return grad_names_; } + + private: + std::unordered_map> + sparse_variables; + std::unordered_map grad_to_variables; + std::vector grad_names_; + static std::shared_ptr scale_kv_; + static std::once_flag init_flag_; +}; + +} // namespace distributed +} // namespace operators +} // namespace paddle diff --git a/paddle/fluid/operators/distributed/parameter_prefetch.cc b/paddle/fluid/operators/distributed/parameter_prefetch.cc index 428ee6ee1843deb46267e877e847f4b31df3e41f..5a67b358ddabb12566cd4ffe00cb12c65a185099 100644 --- a/paddle/fluid/operators/distributed/parameter_prefetch.cc +++ b/paddle/fluid/operators/distributed/parameter_prefetch.cc @@ -41,39 +41,55 @@ using LoDTensor = framework::LoDTensor; using SelectedRows = framework::SelectedRows; using DDim = framework::DDim; -static std::vector> SplitIds( - const std::vector& ids_vector, - const std::vector& height_section) { - std::set all_ids; - for (auto id : ids_vector) { - all_ids.insert(id); - } - - auto abs_sections = ToAbsoluteSection(height_section); - std::vector> splited_ids; - splited_ids.resize(height_section.size() + 1); - for (auto& id : all_ids) { - auto section_index = GetSectionIndex(id, abs_sections); - splited_ids[section_index].push_back(id - abs_sections[section_index]); - } - return splited_ids; -} - static void SplitIdsIntoMultipleVarsBySection( - const std::vector& in_var_names, - const std::vector& height_section, - const std::vector>& splited_ids, - framework::Scope* scope) { - PADDLE_ENFORCE_EQ(in_var_names.size(), height_section.size(), ""); + const std::vector &in_ids, + const std::vector &in_varnames, const int tables, + const int pservers, const bool is_distibuted, framework::Scope *scope, + std::vector> *splited_ids, + std::vector> *origin_ids) { + PADDLE_ENFORCE_EQ( + in_varnames.size(), tables, + platform::errors::OutOfRange( + "send varnames size: %d not equal table number: %d, internal error", + in_varnames.size(), tables)); + + PADDLE_ENFORCE_LE( + tables, pservers, + platform::errors::OutOfRange("table number %d not equal or less than " + "pserver number: %d, internal error", + tables, pservers)); auto place = platform::CPUPlace(); - for (size_t i = 0; i < in_var_names.size(); ++i) { - auto* id_tensor = - scope->Var(in_var_names[i])->GetMutable(); - auto& ids = splited_ids[i]; + std::set st(in_ids.begin(), in_ids.end()); + std::vector all_ids; + all_ids.assign(st.begin(), st.end()); + + splited_ids->resize(tables); + origin_ids->resize(tables); + + if (is_distibuted) { + for (auto &id : all_ids) { + auto pserver_id = id % pservers; + (*splited_ids)[pserver_id].push_back(id); + (*origin_ids)[pserver_id].push_back(id); + } + } else { + for (auto &id : all_ids) { + auto pserver_id = id % pservers; + (*origin_ids)[pserver_id].push_back(id); + id = id / pservers; + (*splited_ids)[pserver_id].push_back(id); + } + } + + for (size_t i = 0; i < in_varnames.size(); ++i) { + auto *id_tensor = + scope->Var(in_varnames[i])->GetMutable(); + + auto &ids = (*splited_ids)[i]; if (!ids.empty()) { - auto* id_tensor_data = id_tensor->mutable_data( + auto *id_tensor_data = id_tensor->mutable_data( framework::make_ddim({static_cast(ids.size()), 1}), place); memcpy(id_tensor_data, ids.data(), sizeof(int64_t) * ids.size()); } @@ -83,12 +99,18 @@ static void SplitIdsIntoMultipleVarsBySection( typedef std::vector> TableAndEndpoints; void prefetch_core( - const std::vector& ids, const TableAndEndpoints& tables, - const std::vector& height_sections, - const framework::ExecutionContext& context, const framework::Scope& scope, - std::unordered_map>* recved_vec_map) { - platform::DeviceContextPool& pool = platform::DeviceContextPool::Instance(); - auto& actual_ctx = *pool.Get(context.GetPlace()); + const std::vector &ids, const TableAndEndpoints &tables, + const framework::ExecutionContext &context, const framework::Scope &scope, + const bool is_distributed, + std::unordered_map> *recved_vec_map) { + distributed::RPCClient *rpc_client = + distributed::RPCClient::GetInstance( + context.Attr("trainer_id")); + + int pservers = context.Attr("pserver_num"); + + platform::DeviceContextPool &pool = platform::DeviceContextPool::Instance(); + auto &actual_ctx = *pool.Get(context.GetPlace()); std::unique_ptr local_scope = scope.NewTmpScope(); @@ -99,19 +121,17 @@ void prefetch_core( out_var_names.push_back("prefetch_recv@" + tables[i].second); } - auto splited_ids = SplitIds(ids, height_sections); - SplitIdsIntoMultipleVarsBySection(in_var_names, height_sections, splited_ids, - local_scope.get()); + std::vector> split_ids; + std::vector> origin_ids; + SplitIdsIntoMultipleVarsBySection(ids, in_var_names, tables.size(), pservers, + is_distributed, local_scope.get(), + &split_ids, &origin_ids); // create output var in local scope - for (auto& name : out_var_names) { + for (auto &name : out_var_names) { local_scope->Var(name)->GetMutable(); } - distributed::RPCClient* rpc_client = - distributed::RPCClient::GetInstance( - context.Attr("trainer_id")); - std::vector rets; for (size_t i = 0; i < in_var_names.size(); i++) { if (NeedSend(*local_scope.get(), in_var_names[i])) { @@ -126,20 +146,18 @@ void prefetch_core( } for (size_t i = 0; i < rets.size(); i++) { - PADDLE_ENFORCE(rets[i]->Wait(), "internal error in RPCClient"); + PADDLE_ENFORCE_NE(rets[i]->Wait(), 0U, platform::errors::ExecutionTimeout( + "internal error in RPCClient")); } - PADDLE_ENFORCE_EQ(out_var_names.size(), height_sections.size(), ""); + for (size_t o_idx = 0; o_idx < out_var_names.size(); ++o_idx) { + auto &ids_in_this_section = origin_ids[o_idx]; - auto abs_sections = ToAbsoluteSection(height_sections); - for (size_t section_idx = 0; section_idx < out_var_names.size(); - ++section_idx) { - auto& ids_in_this_section = splited_ids[section_idx]; if (!ids_in_this_section.empty()) { - auto& prefetch_out_var = local_scope->Var(out_var_names[section_idx]) - ->Get(); - const auto* out_var_data = prefetch_out_var.data(); - auto& dims = prefetch_out_var.dims(); + auto &prefetch_out_var = + local_scope->Var(out_var_names[o_idx])->Get(); + const auto *out_var_data = prefetch_out_var.data(); + auto &dims = prefetch_out_var.dims(); PADDLE_ENFORCE_EQ(dims.size(), 2, ""); PADDLE_ENFORCE_EQ(ids_in_this_section.size(), dims[0]); @@ -147,8 +165,7 @@ void prefetch_core( auto row_numel = dims[1]; for (int64_t i = 0; i < dims[0]; ++i) { - auto id = ids_in_this_section[i]; - auto origin_id = id + abs_sections[section_idx]; + auto origin_id = ids_in_this_section[i]; std::vector vecs(row_numel); std::copy_n(out_var_data + i * row_numel, row_numel, vecs.begin()); (*recved_vec_map)[origin_id] = vecs; @@ -159,38 +176,35 @@ void prefetch_core( } } -void prefetch(const std::string& id_name, const std::string& out_name, - const std::string& persistable_var_name, const bool backfill, - const std::vector& table_names, - const std::vector& endpoints, - const std::vector& height_sections, - const framework::ExecutionContext& context, - const framework::Scope& scope) { - prefetchs({id_name}, {out_name}, persistable_var_name, backfill, table_names, - endpoints, height_sections, context, scope); +void prefetch(const std::string &id_name, const std::string &out_name, + const std::string &persistable_var_name, + const bool is_distributed, + const std::vector &table_names, + const std::vector &endpoints, + const framework::ExecutionContext &context, + const framework::Scope &scope) { + prefetchs({id_name}, {out_name}, persistable_var_name, is_distributed, + table_names, endpoints, context, scope); } -void prefetchs(const std::vector& id_var_names, - const std::vector& out_var_names, - const std::string& persistable_var_name, const bool backfill, - const std::vector& table_names, - const std::vector& endpoints, - const std::vector& height_sections, - const framework::ExecutionContext& context, - const framework::Scope& scope) { - PADDLE_ENFORCE_GT(id_var_names.size(), 0, ""); - PADDLE_ENFORCE_EQ(id_var_names.size(), out_var_names.size(), ""); - PADDLE_ENFORCE_EQ(table_names.size(), endpoints.size(), ""); - PADDLE_ENFORCE_EQ(table_names.size(), height_sections.size(), ""); - +void prefetchs(const std::vector &id_var_names, + const std::vector &out_var_names, + const std::string &persistable_var_name, + const bool is_distributed, + const std::vector &table_names, + const std::vector &endpoints, + const framework::ExecutionContext &context, + const framework::Scope &scope) { auto vec_dim_1 = 0; - framework::Variable* var = scope.FindVar(persistable_var_name); - - PADDLE_ENFORCE_EQ(var->IsType(), true, - platform::errors::InvalidArgument( - "prefetch can only support LodTensor only")); - - vec_dim_1 = var->Get().dims()[1]; + auto vec_dim_0 = 0; + framework::Variable *var = scope.FindVar(persistable_var_name); + + if (var->IsType()) { + vec_dim_1 = var->Get().value().dims()[1]; + } else { + vec_dim_0 = var->Get().dims()[0]; + vec_dim_1 = var->Get().dims()[1]; + } PADDLE_ENFORCE_GT(vec_dim_1, 0, platform::errors::InvalidArgument( @@ -203,37 +217,38 @@ void prefetchs(const std::vector& id_var_names, PADDLE_THROW("multi prefetch only support CPU currently"); } - std::vector> ids_group; std::vector ids_union; - std::vector ids_lods; TableAndEndpoints tables; - for (auto& id_name : id_var_names) { - auto* id_tensor = - scope.FindVar(id_name)->GetMutable(); - auto id_dims = id_tensor->dims(); - id_tensor->Resize(framework::make_ddim( - {static_cast(id_dims[0] * id_dims[1]), 1})); - auto* id_data = id_tensor->data(); - std::vector ids; - - for (int64_t i = 0; i < id_tensor->numel(); ++i) { - ids.push_back(id_data[i]); - ids_union.push_back(id_data[i]); - } - ids_group.push_back(ids); - ids_lods.push_back(id_tensor->lod()); + for (auto &id_name : id_var_names) { + auto *in_var = scope.FindVar(id_name); + auto &id_tensor = in_var->Get(); + std::copy_n(id_tensor.data(), id_tensor.numel(), + back_inserter(ids_union)); } std::unordered_set s(ids_union.begin(), ids_union.end()); ids_union.assign(s.begin(), s.end()); + for (auto &i : ids_union) { + PADDLE_ENFORCE_GE( + i, 0, platform::errors::OutOfRange( + "each element in embedding should be larger or equal 0")); + if (!is_distributed) { + PADDLE_ENFORCE_LT( + i, vec_dim_0, + platform::errors::OutOfRange( + "embedding id must in [0, %d) when is_distributed False", + vec_dim_0)); + } + } + for (size_t i = 0; i < table_names.size(); i++) { tables.push_back(std::make_pair(table_names[i], endpoints[i])); } std::unordered_map> recved_vec_map; - prefetch_core(ids_union, tables, height_sections, context, scope, + prefetch_core(ids_union, tables, context, scope, is_distributed, &recved_vec_map); auto padding_idx = distributed::kNoPadding; @@ -242,20 +257,20 @@ void prefetchs(const std::vector& id_var_names, padding_idx = context.Attr("padding_idx"); } - // copy vectors to out vars for (size_t i = 0; i < out_var_names.size(); i++) { - auto& ids = ids_group[i]; - auto* out_t = - scope.FindVar(out_var_names[i])->GetMutable(); - out_t->Resize( - framework::make_ddim({static_cast(ids.size()), vec_dim_1})); - out_t->set_lod(ids_lods[i]); - - auto* out_d = out_t->mutable_data(place); + auto *in_var = scope.FindVar(id_var_names[i]); + auto &id_tensor = in_var->Get(); + auto ids_size = id_tensor.dims()[0]; + const auto *id_data = id_tensor.data(); - for (size_t idx = 0; idx < ids.size(); idx++) { - const auto& id = ids[idx]; + auto *out_t = + scope.FindVar(out_var_names[i])->GetMutable(); + out_t->set_lod(id_tensor.lod()); + out_t->Resize(framework::make_ddim({ids_size, vec_dim_1})); + auto *out_d = out_t->mutable_data(place); + for (auto idx = 0; idx < static_cast(ids_size); idx++) { + const auto &id = id_data[idx]; if (padding_idx != distributed::kNoPadding && id == padding_idx) { memset(out_d + idx * vec_dim_1, 0, sizeof(float) * vec_dim_1); } else { diff --git a/paddle/fluid/operators/distributed/parameter_prefetch.h b/paddle/fluid/operators/distributed/parameter_prefetch.h index a531c87f57ca19fe0fd55ea41e833c0d6ff161ae..8605bcdcd86759d5c5b45fdcbb1e68407621fc08 100644 --- a/paddle/fluid/operators/distributed/parameter_prefetch.h +++ b/paddle/fluid/operators/distributed/parameter_prefetch.h @@ -31,7 +31,6 @@ void prefetchs(const std::vector& id_var_names, const std::string& persistable_var_name, const bool backfill, const std::vector& table_names, const std::vector& endpoints, - const std::vector& height_sections, const framework::ExecutionContext& context, const framework::Scope& scope); @@ -39,7 +38,6 @@ void prefetch(const std::string& id_name, const std::string& out_name, const std::string& persistable_var_name, const bool backfill, const std::vector& table_names, const std::vector& endpoints, - const std::vector& height_sections, const framework::ExecutionContext& context, const framework::Scope& scope); diff --git a/paddle/fluid/operators/distributed/parameter_recv.cc b/paddle/fluid/operators/distributed/parameter_recv.cc index b79b496c5b163b342b91ad12eea3147938d91ccc..5409ec54987fbb7ad89f61cc1655a4c3ef302ac0 100644 --- a/paddle/fluid/operators/distributed/parameter_recv.cc +++ b/paddle/fluid/operators/distributed/parameter_recv.cc @@ -12,6 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include #include #include #include @@ -40,153 +41,131 @@ using SelectedRows = framework::SelectedRows; using DDim = framework::DDim; template -void ParameterRecv::operator()(const RpcContext &rpc_ctx, - const framework::Scope &scope) { - VLOG(2) << "ParameterRecv in " << rpc_ctx.var_name; +void RecvSelectedRows(const CommContext &rpc_ctx, + const framework::Scope &scope) { + platform::DeviceContextPool &pool = platform::DeviceContextPool::Instance(); + auto cpu_place = platform::CPUPlace(); + auto &cpu_ctx = *pool.Get(cpu_place); + + distributed::RPCClient *rpc_client = + distributed::RPCClient::GetInstance(rpc_ctx.trainer_id); + std::unique_ptr local_scope = scope.NewTmpScope(); + std::vector rets; + for (size_t i = 0; i < rpc_ctx.splited_varnames.size(); i++) { + auto &recv_var_name = rpc_ctx.splited_varnames[i]; + local_scope->Var(recv_var_name); + VLOG(4) << "recv " << recv_var_name << " from " << rpc_ctx.epmap[i]; + // sparse param in recv_scope is LoDTensor + rets.push_back(rpc_client->AsyncGetVar(rpc_ctx.epmap[i], cpu_ctx, + *local_scope.get(), recv_var_name, + recv_var_name, recv_var_name)); + } + + for (size_t i = 0; i < rets.size(); i++) { + PADDLE_ENFORCE_NE(rets[i]->Wait(), 0U, platform::errors::ExecutionTimeout( + "internal error in RPCClient")); + } + + int64_t height = 0; + int64_t ids_num = 0; + int64_t width = 0; + + std::vector all_ids; + auto pserver_num = rpc_ctx.splited_varnames.size(); + + for (size_t i = 0; i < rpc_ctx.splited_varnames.size(); i++) { + auto &recv_var_name = rpc_ctx.splited_varnames[i]; + auto *recv_var = local_scope->FindVar(recv_var_name); + auto &recv_t = recv_var->Get(); + + height += recv_t.height(); + ids_num += recv_t.rows().size(); + width = recv_t.value().dims()[1]; + + std::transform(recv_t.rows().begin(), recv_t.rows().end(), + std::back_inserter(all_ids), + [&](int64_t id) { return id * pserver_num + i; }); + } + + auto *var = scope.FindVar(rpc_ctx.var_name); + auto *t_ = var->GetMutable(); + T *out_data = + t_->mutable_value()->mutable_data({ids_num, width}, cpu_place); + t_->set_height(height); + t_->set_rows(all_ids); + + int64_t cnt = 0; + for (size_t i = 0; i < rpc_ctx.splited_varnames.size(); i++) { + auto &recv_var_name = rpc_ctx.splited_varnames[i]; + auto *recv_var = local_scope->FindVar(recv_var_name); + auto &recv_t = recv_var->Get(); + + auto rows = recv_t.rows().size(); + const T *in_data = recv_t.value().data(); + std::copy_n(in_data, rows * width, out_data + cnt); + cnt += rows * width; + } + t_->SyncIndex(); +} + +template +void RecvLodTensor(const CommContext &rpc_ctx, const framework::Scope &scope) { platform::DeviceContextPool &pool = platform::DeviceContextPool::Instance(); - auto &cpu_ctx = *pool.Get(platform::CPUPlace()); + auto cpu_place = platform::CPUPlace(); + auto &cpu_ctx = *pool.Get(cpu_place); distributed::RPCClient *rpc_client = distributed::RPCClient::GetInstance(rpc_ctx.trainer_id); - auto *recv_var = scope.FindVar(rpc_ctx.var_name); - - // recv all vars to local scope - if (recv_var->IsType() || - recv_var->IsType()) { - std::vector rets; - for (size_t i = 0; i < rpc_ctx.splited_var_names.size(); i++) { - auto &recv_var_name = rpc_ctx.splited_var_names[i]; - local_scope->Var(recv_var_name); - VLOG(4) << "recv " << recv_var_name << " from " << rpc_ctx.epmap[i]; - if (recv_var->IsType()) { - // sparse param in recv_scope is LoDTensor - rets.push_back(rpc_client->AsyncGetVar(rpc_ctx.epmap[i], cpu_ctx, - *local_scope.get(), - recv_var_name, recv_var_name)); - } else { - // sparse param in pserver_scope is SelectedRows - rets.push_back(rpc_client->AsyncGetVar( - rpc_ctx.epmap[i], cpu_ctx, *local_scope.get(), recv_var_name, - recv_var_name, recv_var_name)); - } - } + std::vector rets; + + // variable do not spilt + if (rpc_ctx.origin_varnames.size() == 1 && + rpc_ctx.splited_varnames.size() == 1) { + auto varname = rpc_ctx.origin_varnames[0]; + VLOG(4) << "recv " << varname << " from " << rpc_ctx.epmap[0]; + rets.push_back(rpc_client->AsyncGetVarNoBarrier(rpc_ctx.epmap[0], cpu_ctx, + scope, varname, varname)); + for (size_t i = 0; i < rets.size(); i++) { - PADDLE_ENFORCE(rets[i]->Wait(), "internal error in RPCClient"); + PADDLE_ENFORCE_NE( + rets[i]->Wait(), 0U, + platform::errors::ExecutionTimeout("internal error in RPCClient")); } + + VLOG(3) << "ParameterRecv out " << rpc_ctx.var_name; + return; } else { - PADDLE_THROW("unsupported var type to recv!"); + PADDLE_ENFORCE(false, platform::errors::Unimplemented( + "ParameterRecv can not recv dense with multi " + "parts now, add it soon.")); } +} - // concat recved tensor into one var - if (recv_var->IsType()) { - size_t output_offset = 0; - size_t row_offset = 0; - framework::Tensor *recv_tensor = - recv_var->GetMutable(); - auto dev_ctx = paddle::platform::CPUDeviceContext(); - int64_t recv_numel = 0; - for (auto &recv_var_name : rpc_ctx.splited_var_names) { - auto *recv_var = local_scope->FindVar(recv_var_name); - if (recv_var->IsType()) { - auto &in = recv_var->Get(); - recv_numel += in.numel(); - auto in_stride = framework::stride_numel(in.dims()); - auto out_stride = framework::stride_numel(recv_tensor->dims()); - StridedNumelCopyWithAxis( - dev_ctx, 0, recv_tensor->data() + output_offset, out_stride, - in.data(), in_stride, in_stride[0]); - output_offset += in_stride[0]; - } else if (recv_var->IsType()) { - auto &recv_slr = recv_var->Get(); - auto &recv_dims = recv_tensor->dims(); - int64_t width = recv_dims[1]; - recv_numel += recv_slr.height() * width; - PADDLE_ENFORCE_EQ(recv_slr.value().dims()[1], width); - PADDLE_ENFORCE_EQ(recv_slr.value().dims()[0], recv_slr.rows().size()); - VLOG(3) << "recv slr " << recv_var_name << " dims " - << recv_slr.value().dims(); - if (VLOG_IS_ON(3)) { - std::ostringstream sstream; - sstream << "["; - for (auto &row_id : recv_slr.rows()) { - sstream << row_id << ", "; - } - sstream << "]"; - VLOG(3) << "recv_slr size: " << recv_slr.rows().size() << " " - << sstream.str(); - } - - for (size_t i = 0; i < recv_slr.rows().size(); ++i) { - auto row_id = recv_slr.rows()[i] + row_offset; - PADDLE_ENFORCE_LT(row_id, recv_dims[0]); - memcpy(recv_tensor->data() + row_id * width, - recv_slr.value().data() + i * width, sizeof(T) * width); - } - row_offset += recv_slr.height(); - } else { - PADDLE_THROW("unsupported recieved var type"); - } - } - auto numel = recv_tensor->numel(); - PADDLE_ENFORCE_EQ( - recv_numel, numel, - platform::errors::InvalidArgument( - "The number of receive tensor's elements are not valid. The " - "recevie tensor numel is %d, the actual tensor numel is %d.", - recv_numel, numel)); - } else if (recv_var->IsType()) { - auto cpu_place = platform::CPUPlace(); - auto *slr = recv_var->GetMutable(); - slr->mutable_rows()->clear(); - slr->mutable_value()->mutable_data({{}}, cpu_place); - int64_t width = 0; - int64_t height = 0; - std::vector new_rows{}; - - // trans sparse ids from local to global - std::vector abs_sections = - ToAbsoluteSection(rpc_ctx.height_sections); - - for (size_t i = 0; i < rpc_ctx.splited_var_names.size(); i++) { - auto &recv_var_name = rpc_ctx.splited_var_names[i]; - auto *var = local_scope->FindVar(recv_var_name); - auto *var_slr = var->GetMutable(); - auto *var_slr_row = var_slr->mutable_rows(); - width = var_slr->mutable_value()->dims()[1]; - height += var_slr->height(); - auto row_offset = abs_sections[i]; - VLOG(4) << "Recv split_var " << recv_var_name << " Row size " - << var_slr_row->size(); - for (size_t j = 0; j < var_slr_row->size(); j++) { - new_rows.push_back(row_offset + (*var_slr_row)[j]); - } - } - slr->set_rows(new_rows); - slr->set_height(height); - slr->mutable_value()->mutable_data( - framework::make_ddim( - {static_cast(slr->mutable_rows()->size()), width}), - cpu_place); - auto *slr_data = slr->mutable_value()->data(); - - size_t row_offset = 0; - for (auto &recv_var_name : rpc_ctx.splited_var_names) { - auto *var = local_scope->FindVar(recv_var_name); - auto *var_slr = var->GetMutable(); - auto *var_slr_row = var_slr->mutable_rows(); - auto var_slr_row_size = var_slr_row->size(); - auto *var_slr_data = var_slr->mutable_value()->data(); - - memcpy(slr_data + row_offset * width, var_slr_data, - sizeof(float) * width * var_slr_row_size); - row_offset += var_slr_row_size; - } +template +void ParameterRecv::operator()(const CommContext &rpc_ctx, + const framework::Scope &scope, bool barrier) { + VLOG(3) << "ParameterRecv in " << rpc_ctx.var_name; + + PADDLE_ENFORCE_GE(rpc_ctx.origin_varnames.size(), 1, + platform::errors::InvalidArgument( + "origin_varnames.size() >= 1 is permitted")); + + if (rpc_ctx.is_sparse) { + RecvSelectedRows(rpc_ctx, scope); + } else { + RecvLodTensor(rpc_ctx, scope); } - VLOG(2) << "ParameterRecv out " << rpc_ctx.var_name; + VLOG(3) << "ParameterRecv out " << rpc_ctx.var_name; +} + +template +void ParameterRecv::operator()(const CommContext &rpc_ctx, + const framework::Scope &scope) { + this->operator()(rpc_ctx, scope, true); } template struct ParameterRecv; diff --git a/paddle/fluid/operators/distributed/parameter_recv.h b/paddle/fluid/operators/distributed/parameter_recv.h index e955fca7250ecc88f3b1a08611f380da50df788d..c30d21aa791e23cdebfb35135a292ad846c2576c 100644 --- a/paddle/fluid/operators/distributed/parameter_recv.h +++ b/paddle/fluid/operators/distributed/parameter_recv.h @@ -18,7 +18,7 @@ #include #include "paddle/fluid/framework/operator.h" -#include "paddle/fluid/operators/distributed/rpc_common.h" +#include "paddle/fluid/operators/distributed/communicator_common.h" namespace paddle { namespace operators { @@ -26,7 +26,10 @@ namespace distributed { template struct ParameterRecv { - void operator()(const RpcContext &rpc_ctx, const framework::Scope &scope); + void operator()(const CommContext &rpc_ctx, const framework::Scope &scope, + bool barrier); + + void operator()(const CommContext &rpc_ctx, const framework::Scope &scope); }; }; // namespace distributed diff --git a/paddle/fluid/operators/distributed/parameter_send.cc b/paddle/fluid/operators/distributed/parameter_send.cc index 962d85e918cd5b0a6749a7fa806c1a156115c69e..545b1f5e803c60f8c68005849336e1d3e4893df7 100644 --- a/paddle/fluid/operators/distributed/parameter_send.cc +++ b/paddle/fluid/operators/distributed/parameter_send.cc @@ -41,42 +41,67 @@ using DDim = framework::DDim; typedef std::vector> EP_SPLIT_TABLE_PAIRS; -inline EP_SPLIT_TABLE_PAIRS GetMultiFieldRpcContext( - const RpcContext &rpc_ctx, const framework::Scope &scope, int multi_parts) { +inline EP_SPLIT_TABLE_PAIRS GetMultiFieldCommContext( + const CommContext &rpc_ctx, const framework::Scope &scope, + int multi_parts) { EP_SPLIT_TABLE_PAIRS table_pairs; auto *send_var = scope.FindVar(rpc_ctx.var_name); if (send_var->IsType()) { - PADDLE_ENFORCE_GT(multi_parts, 0, "multi_parts must >=1"); - - if (multi_parts == 1) { - for (size_t i = 0; i < rpc_ctx.splited_var_names.size(); i++) { - table_pairs.push_back( - std::make_pair(rpc_ctx.epmap[i], rpc_ctx.splited_var_names[i])); - } - } else { - for (size_t i = 0; i < rpc_ctx.splited_var_names.size(); i++) { - for (int x = 0; x < multi_parts; x++) { - auto table = - string::Sprintf("%s@%d@PIECE", rpc_ctx.splited_var_names[i], x); - table_pairs.push_back(std::make_pair(rpc_ctx.epmap[i], table)); - } - } + PADDLE_ENFORCE_GE(multi_parts, 1, + platform::errors::InvalidArgument( + "multi_parts must == 1 in parameter send, now is: %d", + multi_parts)); + + for (size_t i = 0; i < rpc_ctx.splited_varnames.size(); i++) { + table_pairs.push_back( + std::make_pair(rpc_ctx.epmap[i], rpc_ctx.splited_varnames[i])); } - } else if (send_var->IsType()) { - PADDLE_THROW("GetMultiFieldRpcContext can not support LoDTensor current!"); } else { - PADDLE_THROW("GetMultiFieldRpcContext unsupported var type!"); + PADDLE_THROW(platform::errors::InvalidArgument( + "GetMultiFieldCommContext unsupported LoDTensor current!")); } return table_pairs; } // namespace distributed +void SendByNotifyRPC(const CommContext &rpc_ctx, + const framework::Scope &scope) { + auto cpu_ctx = paddle::platform::CPUDeviceContext(); + auto &send_var_name = rpc_ctx.var_name; + std::vector rets; + + distributed::RPCClient *rpc_client = + distributed::RPCClient::GetInstance(rpc_ctx.trainer_id); + + if (NeedSend(scope, send_var_name)) { + for (size_t j = 0; j < rpc_ctx.epmap.size(); j++) { + auto &endpoint = rpc_ctx.epmap[j]; + VLOG(4) << "sending " << send_var_name << " to " << endpoint; + rets.push_back(rpc_client->AsyncDistributeNotify(endpoint, cpu_ctx, scope, + send_var_name)); + VLOG(4) << "send var " << send_var_name << " by notify RPC done"; + } + } else { + VLOG(3) << "don't send non-initialized variable: " << rpc_ctx.var_name; + } + + for (auto &handle : rets) { + PADDLE_ENFORCE_NE(handle->Wait(), 0U, platform::errors::ExecutionTimeout( + "internal error in RPCClient")); + } +} + template -void ParameterSend::operator()(const RpcContext &rpc_ctx, +void ParameterSend::operator()(const CommContext &rpc_ctx, const framework::Scope &scope, bool sync, int multi_parts) { + if (rpc_ctx.var_name == STEP_COUNTER) { + SendByNotifyRPC(rpc_ctx, scope); + return; + } + std::unique_ptr local_scope = scope.NewTmpScope(); platform::DeviceContextPool &pool = platform::DeviceContextPool::Instance(); @@ -86,11 +111,10 @@ void ParameterSend::operator()(const RpcContext &rpc_ctx, distributed::RPCClient::GetInstance(rpc_ctx.trainer_id); std::vector rets; - auto *send_var = scope.FindVar(rpc_ctx.var_name); if (send_var->IsType()) { - size_t out_num = rpc_ctx.splited_var_names.size(); + size_t out_num = rpc_ctx.splited_varnames.size(); if (out_num > 1) { auto &send_tensor = send_var->Get(); auto &send_tensor_dims = send_tensor.dims(); @@ -110,72 +134,49 @@ void ParameterSend::operator()(const RpcContext &rpc_ctx, // create output var in local scope size_t row_offset = 0; for (size_t i = 0; i < out_num; ++i) { - framework::Tensor *out = local_scope->Var(rpc_ctx.splited_var_names[i]) + framework::Tensor *out = local_scope->Var(rpc_ctx.splited_varnames[i]) ->GetMutable(); *out = send_tensor.Slice(row_offset, row_offset + outs_dims[i][0]); row_offset += outs_dims[i][0]; } } else { auto &send_tensor = send_var->Get(); - framework::Tensor *out = local_scope->Var(rpc_ctx.splited_var_names[0]) + framework::Tensor *out = local_scope->Var(rpc_ctx.splited_varnames[0]) ->GetMutable(); out->ShareDataWith(send_tensor); } - if (rpc_ctx.use_send_handler) { - for (size_t i = 0; i < rpc_ctx.splited_var_names.size(); i++) { - auto &send_var_name = rpc_ctx.splited_var_names[i]; - VLOG(4) << "send var name: " << send_var_name; - auto &endpoint = rpc_ctx.epmap[i]; - VLOG(4) << "send var endpoint: " << endpoint; - VLOG(4) << "need send: " << NeedSend(*local_scope.get(), send_var_name); - if (NeedSend(*local_scope.get(), send_var_name)) { - VLOG(3) << "sending " << send_var_name << " to " << endpoint; - rets.push_back(rpc_client->AsyncSendVar( - endpoint, cpu_ctx, *local_scope.get(), send_var_name)); - VLOG(4) << "send var " << send_var_name << " async handle done"; - } else { - VLOG(3) << "don't send non-initialized variable: " - << rpc_ctx.splited_var_names[i]; - } - } - } else { - for (size_t i = 0; i < rpc_ctx.splited_var_names.size(); i++) { - for (size_t j = 0; j < rpc_ctx.epmap.size(); j++) { - auto &send_var_name = rpc_ctx.splited_var_names[i]; - VLOG(4) << "send var name: " << send_var_name; - auto &endpoint = rpc_ctx.epmap[j]; - VLOG(4) << "send var endpoint: " << endpoint; - VLOG(4) << "need send: " - << NeedSend(*local_scope.get(), send_var_name); - if (NeedSend(*local_scope.get(), send_var_name)) { - VLOG(3) << "sending " << send_var_name << " to " << endpoint; - rets.push_back(rpc_client->AsyncDistributeNotify( - endpoint, cpu_ctx, *local_scope.get(), send_var_name)); - VLOG(4) << "send var " << send_var_name << " async handle done"; - } else { - VLOG(3) << "don't send non-initialized variable: " - << rpc_ctx.splited_var_names[i]; - } - } + + for (size_t i = 0; i < rpc_ctx.splited_varnames.size(); i++) { + auto &send_var_name = rpc_ctx.splited_varnames[i]; + auto &endpoint = rpc_ctx.epmap[i]; + VLOG(4) << " send var name: " << send_var_name + << "endpoint: " << endpoint; + if (NeedSend(*local_scope.get(), send_var_name)) { + VLOG(3) << "sending " << send_var_name << " to " << endpoint; + rets.push_back(rpc_client->AsyncSendVar( + endpoint, cpu_ctx, *local_scope.get(), send_var_name)); + VLOG(4) << "send var " << send_var_name << " async handle done"; + } else { + VLOG(3) << "don't send non-initialized variable: " + << rpc_ctx.splited_varnames[i]; } } } else if (send_var->IsType()) { auto &send_slr = send_var->Get(); - auto abs_sections = ToAbsoluteSection(rpc_ctx.height_sections); auto &send_rows = send_slr.rows(); if (send_rows.size() == 0) { - LOG(WARNING) << "WARNING: The variable sent to pserver is empty, which " - "may cause an unknown error. Please check the state of " - "use_double_buffer in pyreader async mode, you need to " - "turn it false."; + LOG(WARNING) + << "WARNING: The variable sent to pserver is empty, which " + "may cause an unknown error. Please check the state of " + "use_double_buffer in pyreader/dataloader async mode, you need to " + "turn it false."; } std::vector> outs_rows_idx; std::vector> outs_dense_idx; - auto table_pairs = GetMultiFieldRpcContext(rpc_ctx, scope, multi_parts); - + auto table_pairs = GetMultiFieldCommContext(rpc_ctx, scope, 1); outs_rows_idx.resize(table_pairs.size()); outs_dense_idx.resize(table_pairs.size()); @@ -190,32 +191,77 @@ void ParameterSend::operator()(const RpcContext &rpc_ctx, outs.push_back(out); } - // split rows index into output sparse vars - for (size_t i = 0; i < send_rows.size(); ++i) { - auto ep_idx = GetSectionIndex(send_rows[i], abs_sections); - auto table_idx = send_rows[i] % multi_parts; - auto out_idx = ep_idx * multi_parts + table_idx; - outs_rows_idx[out_idx].push_back(send_rows[i]); - outs_dense_idx[out_idx].push_back(i); - } + if (!rpc_ctx.is_distributed) { + auto pserver_num = rpc_ctx.epmap.size(); + + // split rows index into output sparse vars + for (size_t i = 0; i < send_rows.size(); ++i) { + auto ep_idx = send_rows[i] % pserver_num; + auto id = send_rows[i] / pserver_num; + outs_rows_idx[ep_idx].push_back(id); + outs_dense_idx[ep_idx].push_back(i); + } + + auto place = platform::CPUPlace(); + + for (size_t out_idx = 0; out_idx < rpc_ctx.splited_varnames.size(); + out_idx++) { + auto rows_idx = outs_rows_idx[out_idx]; + + auto dims = send_slr.GetCompleteDims(); + dims[0] = rows_idx.size(); + outs[out_idx]->set_height(rpc_ctx.height_sections[out_idx]); + outs[out_idx]->mutable_rows()->clear(); + outs[out_idx]->mutable_value()->mutable_data(dims, send_slr.place()); + + if (rows_idx.size() > 0) { + for (auto idx : rows_idx) { + outs[out_idx]->mutable_rows()->push_back(idx); + } + auto dst = outs[out_idx]->mutable_value()->mutable_data(place); + for (size_t j = 0; j < rows_idx.size(); j++) { + if (platform::is_cpu_place(place)) { + memory::Copy(platform::CPUPlace(), dst + j * row_numel, + platform::CPUPlace(), + src + outs_dense_idx[out_idx][j] * row_numel, + sizeof(T) * row_numel); + } else { + PADDLE_THROW( + platform::errors::Unimplemented("do not support GPU now")); + } + } + } + PADDLE_ENFORCE_EQ( + rows_idx.size(), outs[out_idx]->rows().size(), + platform::errors::InvalidArgument( + "rows should has the same size with tensor dim 0")); + } + } else { + auto pserver_num = rpc_ctx.epmap.size(); + + // split rows index into output sparse vars + for (size_t i = 0; i < send_rows.size(); ++i) { + auto out_idx = send_rows[i] % pserver_num; + outs_rows_idx[out_idx].push_back(send_rows[i]); + outs_dense_idx[out_idx].push_back(i); + } - auto place = platform::CPUPlace(); + auto place = platform::CPUPlace(); - for (size_t ctx = 0; ctx < rpc_ctx.splited_var_names.size(); ctx++) { - for (int part = 0; part < multi_parts; part++) { - auto out_idx = ctx * multi_parts + part; + for (size_t out_idx = 0; out_idx < rpc_ctx.splited_varnames.size(); + out_idx++) { auto rows_idx = outs_rows_idx[out_idx]; auto dims = send_slr.GetCompleteDims(); dims[0] = rows_idx.size(); - outs[out_idx]->set_height(rpc_ctx.height_sections[ctx]); + outs[out_idx]->set_height(rpc_ctx.height_sections[out_idx]); outs[out_idx]->mutable_rows()->clear(); outs[out_idx]->mutable_value()->mutable_data(dims, send_slr.place()); if (rows_idx.size() > 0) { for (auto idx : rows_idx) { - outs[out_idx]->mutable_rows()->push_back(idx - abs_sections[ctx]); + outs[out_idx]->mutable_rows()->push_back(idx); } auto dst = outs[out_idx]->mutable_value()->mutable_data(place); for (size_t j = 0; j < rows_idx.size(); j++) { @@ -225,12 +271,15 @@ void ParameterSend::operator()(const RpcContext &rpc_ctx, src + outs_dense_idx[out_idx][j] * row_numel, sizeof(T) * row_numel); } else { - PADDLE_THROW("do not support GPU now"); + PADDLE_THROW( + platform::errors::Unimplemented("do not support GPU now")); } } } - PADDLE_ENFORCE_EQ(rows_idx.size(), outs[out_idx]->rows().size(), - "rows should has the same size with tensor dim 0"); + PADDLE_ENFORCE_EQ( + rows_idx.size(), outs[out_idx]->rows().size(), + platform::errors::InvalidArgument( + "rows should has the same size with tensor dim 0")); } } @@ -240,8 +289,8 @@ void ParameterSend::operator()(const RpcContext &rpc_ctx, auto need_send = NeedSend(*local_scope.get(), send_var_name); VLOG(4) << "send var name: " << send_var_name - << "send var endpoint: " << endpoint - << "need send: " << need_send; + << " send var endpoint: " << endpoint + << " need send: " << need_send; if (need_send) { VLOG(4) << "sending " << send_var_name << " to " << endpoint; @@ -251,7 +300,7 @@ void ParameterSend::operator()(const RpcContext &rpc_ctx, VLOG(4) << "send var " << send_var_name << " async handle done"; } else { VLOG(4) << "don't send non-initialized variable: " - << rpc_ctx.splited_var_names[i]; + << rpc_ctx.splited_varnames[i]; } } } else { @@ -262,7 +311,8 @@ void ParameterSend::operator()(const RpcContext &rpc_ctx, if (sync) { for (auto &handle : rets) { VLOG(4) << "Wait send var to pserver handle: " << handle; - PADDLE_ENFORCE(handle->Wait(), "internal error in RPCClient"); + PADDLE_ENFORCE_NE(handle->Wait(), 0U, platform::errors::ExecutionTimeout( + "internal error in RPCClient")); } } } diff --git a/paddle/fluid/operators/distributed/parameter_send.h b/paddle/fluid/operators/distributed/parameter_send.h index 556ec581f6c12d39f19f1b67b6aa58e8f396e272..4335ef8c73cc0a3f4d019cbfe9be078a88914217 100644 --- a/paddle/fluid/operators/distributed/parameter_send.h +++ b/paddle/fluid/operators/distributed/parameter_send.h @@ -18,7 +18,7 @@ #include #include "paddle/fluid/framework/operator.h" -#include "paddle/fluid/operators/distributed/rpc_common.h" +#include "paddle/fluid/operators/distributed/communicator_common.h" namespace paddle { namespace operators { @@ -26,7 +26,7 @@ namespace distributed { template struct ParameterSend { - void operator()(const RpcContext &rpc_ctx, const framework::Scope &scope, + void operator()(const CommContext &rpc_ctx, const framework::Scope &scope, bool sync, int multi_parts); }; diff --git a/paddle/fluid/operators/distributed/request_handler.h b/paddle/fluid/operators/distributed/request_handler.h index 7cccf259b596f2116d14b23d19dba6df229d3cd7..59531c0ec78ed8f0ec60a94d48069685e5b8c1a2 100644 --- a/paddle/fluid/operators/distributed/request_handler.h +++ b/paddle/fluid/operators/distributed/request_handler.h @@ -65,6 +65,7 @@ constexpr int64_t kPrefetchTimeout = 60000; #define COMPLETE_MESSAGE "COMPLETE@RECV" #define WITHOUT_BARRIER_MESSAGE "@WITHOUT_BARRIER@RECV" #define LEARNING_RATE_DECAY_COUNTER "@LR_DECAY_COUNTER@" +#define STEP_COUNTER "@PS_STEP_COUNTER@" #define CHECKPOINT_SAVE_MESSAGE "SAVE@CHECKPOINTNOTIFY" #define CHECKPOINT_LOAD_MESSAGE "LOAD@CHECKPOINTNOTIFY" diff --git a/paddle/fluid/operators/distributed/request_handler_impl.cc b/paddle/fluid/operators/distributed/request_handler_impl.cc index 0205bab0504d75df4e2b8bf15326a8aec9127544..e99b0ed4072645fcbc3ef4ce8728fc0f9cd912a3 100644 --- a/paddle/fluid/operators/distributed/request_handler_impl.cc +++ b/paddle/fluid/operators/distributed/request_handler_impl.cc @@ -29,6 +29,7 @@ #include "paddle/fluid/operators/distributed/async_sparse_param_update_recorder.h" #include "paddle/fluid/operators/distributed/heart_beat_monitor.h" +#include "paddle/fluid/operators/distributed/large_scale_kv.h" namespace paddle { namespace operators { @@ -38,13 +39,13 @@ namespace distributed { // to directory specified. constexpr char LOOKUP_TABLE_PATH[] = "kLookupTablePath"; -bool RequestSendHandler::Handle(const std::string& varname, - framework::Scope* scope, - framework::Variable* invar, - framework::Variable** outvar, +bool RequestSendHandler::Handle(const std::string &varname, + framework::Scope *scope, + framework::Variable *invar, + framework::Variable **outvar, const int trainer_id, - const std::string& out_var_name, - const std::string& table_name) { + const std::string &out_var_name, + const std::string &table_name) { VLOG(4) << "RequestSendHandler:" << varname; // Sync @@ -82,16 +83,34 @@ bool RequestSendHandler::Handle(const std::string& varname, scope->Rename(varname, run_varname); } - if (distributed_mode_ == DistributedMode::kGeo && - AsyncSparseParamUpdateRecorder::GetInstance()->HasGrad(run_varname)) { - auto& grad_slr = - scope->FindVar(run_varname)->Get(); - AsyncSparseParamUpdateRecorder::GetInstance()->Update(run_varname, - grad_slr.rows()); + auto *var = scope->FindVar(run_varname); + + // for sparse ids + if (var->IsType()) { + if (distributed_mode_ == DistributedMode::kAsync || + distributed_mode_ == DistributedMode::kHalfAsync) { + auto *ins = distributed::LargeScaleKV::GetInstance(); + if (ins->GradInLargeScale(run_varname)) { + auto *large_scale_var = ins->GetByGrad(run_varname); + + for (auto name : large_scale_var->CachedVarnames()) { + scope->Var(name); + } + } + } + if (distributed_mode_ == DistributedMode::kGeo) { + if (AsyncSparseParamUpdateRecorder::GetInstance()->HasGrad( + run_varname)) { + auto &grad_slr = + scope->FindVar(run_varname)->Get(); + AsyncSparseParamUpdateRecorder::GetInstance()->Update( + run_varname, grad_slr.rows()); + } + } } + executor_->RunPreparedContext((*grad_to_prepared_ctx_)[run_varname].get(), scope); - return true; } else { // sync rpc_server_->WaitCond(kRequestSend); @@ -104,13 +123,13 @@ bool RequestSendHandler::Handle(const std::string& varname, return true; } -bool RequestGetHandler::Handle(const std::string& varname, - framework::Scope* scope, - framework::Variable* invar, - framework::Variable** outvar, +bool RequestGetHandler::Handle(const std::string &varname, + framework::Scope *scope, + framework::Variable *invar, + framework::Variable **outvar, const int trainer_id, - const std::string& out_var_name, - const std::string& table_name) { + const std::string &out_var_name, + const std::string &table_name) { VLOG(3) << "RequestGetHandler:" << varname << " out_var_name: " << out_var_name << " trainer_id: " << trainer_id << " table_name: " << table_name; @@ -138,39 +157,38 @@ bool RequestGetHandler::Handle(const std::string& varname, VLOG(3) << "copying " << varname << " to " << param_bak_name; framework::TensorCopy(t_orig, dev_ctx_->GetPlace(), t); } - VLOG(1) << "Table name empty? " << table_name.empty(); - if (distributed_mode_ == DistributedMode::kGeo) { - VLOG(1) << "AsyncSparseParamUpdateRecorder " << varname << " exist " - << AsyncSparseParamUpdateRecorder::GetInstance()->HasParam( - varname); - } + if (distributed_mode_ == DistributedMode::kGeo && AsyncSparseParamUpdateRecorder::GetInstance()->HasParam(varname) && !table_name.empty()) { + VLOG(3) << "AsyncSparseParamUpdateRecorder " << varname << " exist "; + std::vector updated_rows; AsyncSparseParamUpdateRecorder::GetInstance()->GetAndClear( varname, trainer_id, &updated_rows); + if (VLOG_IS_ON(3)) { std::ostringstream sstream; sstream << "["; - for (auto& row_id : updated_rows) { + for (auto &row_id : updated_rows) { sstream << row_id << ", "; } sstream << "]"; VLOG(3) << "updated_rows size: " << updated_rows.size() << " " << sstream.str(); } - auto& origin_tensor = + + auto &origin_tensor = scope_->FindVar(varname)->Get(); - auto* origin_tensor_data = origin_tensor.data(); - auto& dims = origin_tensor.dims(); + auto *origin_tensor_data = origin_tensor.data(); + auto &dims = origin_tensor.dims(); *outvar = scope->Var(); - auto* out_slr = (*outvar)->GetMutable(); + auto *out_slr = (*outvar)->GetMutable(); out_slr->set_rows(updated_rows); out_slr->set_height(dims[0]); auto out_dims = framework::make_ddim( {static_cast(updated_rows.size()), dims[1]}); - auto* data = out_slr->mutable_value()->mutable_data( + auto *data = out_slr->mutable_value()->mutable_data( out_dims, origin_tensor.place()); auto width = dims[1]; for (size_t i = 0; i < updated_rows.size(); ++i) { @@ -186,13 +204,13 @@ bool RequestGetHandler::Handle(const std::string& varname, return true; } -bool RequestGetNoBarrierHandler::Handle(const std::string& varname, - framework::Scope* scope, - framework::Variable* invar, - framework::Variable** outvar, +bool RequestGetNoBarrierHandler::Handle(const std::string &varname, + framework::Scope *scope, + framework::Variable *invar, + framework::Variable **outvar, const int trainer_id, - const std::string& out_var_name, - const std::string& table_name) { + const std::string &out_var_name, + const std::string &table_name) { VLOG(4) << "RequestGetNoBarrierHandler:" << varname << " out_var_name: " << out_var_name; @@ -212,77 +230,96 @@ bool RequestGetNoBarrierHandler::Handle(const std::string& varname, return true; } -bool RequestPrefetchHandler::Handle(const std::string& varname, - framework::Scope* scope, - framework::Variable* invar, - framework::Variable** outvar, +bool RequestPrefetchHandler::Handle(const std::string &varname, + framework::Scope *scope, + framework::Variable *invar, + framework::Variable **outvar, const int trainer_id, - const std::string& out_var_name, - const std::string& table_name) { + const std::string &out_var_name, + const std::string &table_name) { VLOG(4) << "RequestPrefetchHandler " << varname; - if (table_name.empty()) { - auto var_desc = program_->Block(0).FindVar(out_var_name); - InitializeVariable(*outvar, var_desc->GetType()); - executor_->RunPreparedContext( - (*prefetch_var_name_to_prepared_ctx_)[varname].get(), scope); + (*outvar)->GetMutable(); + + VLOG(1) << "Prefetch " + << "tablename: " << table_name << " ids:" << varname + << " out: " << out_var_name; + paddle::platform::CPUPlace cpu_place; + auto *ins = distributed::LargeScaleKV::GetInstance(); + + if (ins->ParamInLargeScale(table_name)) { + auto lookup_table_op = PullLargeScaleOp(table_name, varname, out_var_name); + lookup_table_op->Run(*scope, cpu_place); } else { - (*outvar)->GetMutable(); auto lookup_table_op = BuildLookupTableOp(table_name, varname, out_var_name); - paddle::platform::CPUPlace cpu_place; lookup_table_op->Run(*scope, cpu_place); } + return true; } -bool RequestCheckpointHandler::Handle(const std::string& varname, - framework::Scope* scope, - framework::Variable* invar, - framework::Variable** outvar, +bool RequestCheckpointHandler::Handle(const std::string &varname, + framework::Scope *scope, + framework::Variable *invar, + framework::Variable **outvar, const int trainer_id, - const std::string& out_var_name, - const std::string& table_name) { - PADDLE_ENFORCE( - checkpoint_notify_id != -1, - "when checkpoint_notify_id = -1, there should be no RPC invoke."); - - // TODO(tangwei12): find out why scope will be error. - auto* lt_var = scope_->FindVar(LOOKUP_TABLE_PATH)->GetMutable(); - lt_var->clear(); - lt_var->append(out_var_name); - VLOG(4) << "RequestCheckpointHandler update var kLookupTablePath to: " - << out_var_name; - executor_->RunPreparedContext(checkpoint_prepared_ctx_.get(), scope_); + const std::string &out_var_name, + const std::string &table_name) { + VLOG(4) << "receive save var " << varname << " with path " << out_var_name; + + auto *ins = distributed::LargeScaleKV::GetInstance(); + ins->Get(varname)->Save(out_var_name); + // auto checkpoint_op = BuildCheckpointOp(varname, out_var_name); + // paddle::platform::CPUPlace cpu_place; + // checkpoint_op->Run(*scope_, cpu_place); return true; } -bool RequestNotifyHandler::Handle(const std::string& varname, - framework::Scope* scope, - framework::Variable* invar, - framework::Variable** outvar, +bool RequestNotifyHandler::Handle(const std::string &varname, + framework::Scope *scope, + framework::Variable *invar, + framework::Variable **outvar, const int trainer_id, - const std::string& out_var_name, - const std::string& table_name) { - VLOG(4) << "RequestNotifyHandler: " << varname; - VLOG(3) << "async process var: " << varname << ", trainer_id: " << trainer_id; + const std::string &out_var_name, + const std::string &table_name) { + VLOG(3) << "RequestNotifyHandler: " << varname + << ", trainer_id: " << trainer_id; - string::Piece decay_piece(LEARNING_RATE_DECAY_COUNTER); + string::Piece decay_piece(STEP_COUNTER); string::Piece var_name_piece = string::Piece(varname); if (string::Contains(var_name_piece, decay_piece)) { VLOG(3) << "LearningRate Decay Counter Update"; - PADDLE_ENFORCE_NE( - lr_decay_block_id, -1, - "when lr_decay_block_id = -1, there should be no RPC invoke."); - auto* origin_var = scope_->FindVar(varname); - auto origin_var_tensor = origin_var->Get(); - auto* send_var = scope->FindVar(varname); + + auto *send_var = scope->FindVar(varname); auto send_var_tensor = send_var->Get(); - int64_t* origin_value = - origin_var_tensor.mutable_data(origin_var_tensor.place()); - int64_t* send_value = + auto *send_value = send_var_tensor.mutable_data(send_var_tensor.place()); - origin_value[0] += send_value[0]; + + auto counter = decay_counters.at(trainer_id); + counter += send_value[0]; + decay_counters.at(trainer_id) = counter; + + auto *global_step_var = this->scope()->FindVar(LEARNING_RATE_DECAY_COUNTER); + if (global_step_var == nullptr) { + PADDLE_THROW(platform::errors::InvalidArgument( + "can not find LEARNING_RATE_DECAY_COUNTER ")); + } + + auto *tensor = global_step_var->GetMutable(); + auto *value = tensor->mutable_data(platform::CPUPlace()); + + auto global_counter = 0; + for (auto &trainer_counter : decay_counters) { + global_counter += trainer_counter.second; + } + value[0] = global_counter; + + if (lr_decay_prepared_ctx_.get() == nullptr) { + PADDLE_THROW(platform::errors::InvalidArgument( + "can not find decay block for executor")); + } + executor_->RunPreparedContext(lr_decay_prepared_ctx_.get(), scope_); } return true; diff --git a/paddle/fluid/operators/distributed/request_handler_impl.h b/paddle/fluid/operators/distributed/request_handler_impl.h index 56e89f0201d7ae070dfe42c611112841870daf48..f22a133c2d5b1196a672f978d76d1c362f616bf6 100644 --- a/paddle/fluid/operators/distributed/request_handler_impl.h +++ b/paddle/fluid/operators/distributed/request_handler_impl.h @@ -19,6 +19,7 @@ #include #include #include +#include #include #include @@ -98,6 +99,21 @@ class RequestPrefetchHandler final : public RequestHandler { const std::string& table_name = "") override; private: + std::unique_ptr PullLargeScaleOp( + const std::string& table_name, const std::string& id_name, + const std::string& out_name) { + framework::OpDesc desc; + desc.SetType("lookup_sparse_table_read"); + desc.SetInput("Ids", {id_name}); + desc.SetOutput("Out", std::vector({out_name})); + desc.SetAttr("tablename", {table_name}); + desc.SetAttr("init", true); + desc.SetAttr("value_names", std::vector({"Param"})); + + auto op = paddle::framework::OpRegistry::CreateOp(desc); + return op; + } + std::unique_ptr BuildLookupTableOp( const std::string& table_name, const std::string& id_name, const std::string& out_name) { @@ -114,11 +130,9 @@ class RequestPrefetchHandler final : public RequestHandler { class RequestCheckpointHandler final : public RequestHandler { public: - explicit RequestCheckpointHandler(int distributed_mode, - int checkpoint_notify_id) - : RequestHandler(distributed_mode) { - this->checkpoint_notify_id = checkpoint_notify_id; - } + explicit RequestCheckpointHandler(int distributed_mode) + : RequestHandler(distributed_mode) {} + virtual ~RequestCheckpointHandler() {} bool Handle(const std::string& varname, framework::Scope* scope, framework::Variable* var, framework::Variable** outvar, @@ -126,14 +140,30 @@ class RequestCheckpointHandler final : public RequestHandler { const std::string& table_name = "") override; private: - int checkpoint_notify_id; + std::unique_ptr BuildCheckpointOp( + const std::string& varname, const std::string& file_path) { + paddle::framework::proto::OpDesc op_desc; + op_desc.set_type("save"); + BuildVar("X", {varname.data()}, op_desc.add_inputs()); + + auto attr = op_desc.mutable_attrs()->Add(); + attr->set_name("file_path"); + attr->set_type(paddle::framework::proto::AttrType::STRING); + attr->set_s(file_path); + + auto op = paddle::framework::OpRegistry::CreateOp(op_desc); + return op; + } }; class RequestNotifyHandler final : public RequestHandler { public: - explicit RequestNotifyHandler(int distributed_mode, int lr_decay_block_id) + explicit RequestNotifyHandler(int distributed_mode, int trainers) : RequestHandler(distributed_mode) { - this->lr_decay_block_id = lr_decay_block_id; + this->trainers = trainers; + for (int i = 0; i < trainers; i++) { + decay_counters[i] = 0; + } } virtual ~RequestNotifyHandler() {} bool Handle(const std::string& varname, framework::Scope* scope, @@ -142,7 +172,8 @@ class RequestNotifyHandler final : public RequestHandler { const std::string& table_name = "") override; private: - int lr_decay_block_id; + int trainers; + std::unordered_map decay_counters; }; } // namespace distributed diff --git a/paddle/fluid/operators/distributed/rpc_client.h b/paddle/fluid/operators/distributed/rpc_client.h index 9f06b168f8044b1790eac4ca56aef523aece4e1f..62313222775c662b78bfab5827cd5b418a2a0997 100644 --- a/paddle/fluid/operators/distributed/rpc_client.h +++ b/paddle/fluid/operators/distributed/rpc_client.h @@ -77,8 +77,8 @@ class RPCClient { int64_t time_out = FLAGS_rpc_deadline) = 0; virtual VarHandlePtr AsyncCheckpointNotify( - const std::string& ep, const std::string& dir, - int64_t time_out = FLAGS_rpc_deadline) = 0; + const std::string& ep, const std::string& dirname, + const std::string& varname, int64_t time_out = FLAGS_rpc_deadline) = 0; virtual VarHandlePtr AsyncDistributeNotify( const std::string& ep, const platform::DeviceContext& ctx, diff --git a/paddle/fluid/operators/distributed/rpc_common.h b/paddle/fluid/operators/distributed/rpc_common.h deleted file mode 100644 index 2f0cc61f2d855690b9228313fd471258d859244a..0000000000000000000000000000000000000000 --- a/paddle/fluid/operators/distributed/rpc_common.h +++ /dev/null @@ -1,89 +0,0 @@ -/* Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -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. */ - -#pragma once - -#include -#include -#include - -namespace paddle { -namespace operators { -namespace distributed { - -struct RpcContext { - RpcContext() = default; - - RpcContext(const std::string &name, const std::vector &names, - const std::vector &emap, - const std::vector §ions, int id, - bool merge_add_ = true, bool use_send_handler_ = true) - : var_name(name), - splited_var_names(names), - epmap(emap), - height_sections(sections), - trainer_id(id), - merge_add(merge_add_), - use_send_handler(use_send_handler_) {} - - RpcContext(const RpcContext &ctx) { - var_name = ctx.var_name; - splited_var_names = ctx.splited_var_names; - epmap = ctx.epmap; - height_sections = ctx.height_sections; - trainer_id = ctx.trainer_id; - merge_add = ctx.merge_add; - use_send_handler = ctx.use_send_handler; - } - - std::string var_name; - std::vector splited_var_names; - std::vector epmap; - std::vector height_sections; - int trainer_id; - bool merge_add; - bool use_send_handler; -}; - -inline std::ostream &operator<<(std::ostream &os, const RpcContext &rpc_ctx) { - os << "{"; - os << "var_name: " << rpc_ctx.var_name << "\n"; - - os << "splited_var_names: ["; - for (auto &name : rpc_ctx.splited_var_names) { - os << name << ", "; - } - os << "]\n"; - - os << "epmap: ["; - for (auto &ep : rpc_ctx.epmap) { - os << ep << ", "; - } - os << "]\n"; - - os << "height_sections: ["; - for (auto §ion : rpc_ctx.height_sections) { - os << section << ", "; - } - os << "]\n"; - - os << "merge add: " << rpc_ctx.merge_add; - os << "; send handler: " << rpc_ctx.use_send_handler << "\n"; - os << "}"; - return os; -} - -} // namespace distributed -} // namespace operators -} // namespace paddle diff --git a/paddle/fluid/operators/distributed/rpc_server_test.cc b/paddle/fluid/operators/distributed/rpc_server_test.cc index d36a433db7dda89b5a9edb6fb8db8552ecce7854..67e11120b808e26df590440389c71f3340738082 100644 --- a/paddle/fluid/operators/distributed/rpc_server_test.cc +++ b/paddle/fluid/operators/distributed/rpc_server_test.cc @@ -34,7 +34,7 @@ namespace framework = paddle::framework; namespace platform = paddle::platform; namespace distributed = paddle::operators::distributed; -USE_NO_KERNEL_OP(lookup_sparse_table); +USE_NO_KERNEL_OP(lookup_sparse_table_read); std::unique_ptr g_rpc_service; std::unique_ptr g_req_handler; @@ -46,10 +46,12 @@ framework::BlockDesc* AppendPrefetchBlcok(framework::ProgramDesc* program) { framework::VariableNameMap input({{"W", {"w"}}, {"Ids", {"ids"}}}); framework::VariableNameMap output({{"Output", {"out"}}}); auto op = block->AppendOp(); - op->SetType("lookup_sparse_table"); + op->SetType("lookup_sparse_table_read"); op->SetInput("W", {"w"}); op->SetInput("Ids", {"ids"}); op->SetOutput("Out", {"out"}); + op->SetAttr("tablename", {"w"}); + op->SetAttr("value_names", {"Param"}); auto& out = *root_block->Var("out"); out.SetType(framework::proto::VarType::LOD_TENSOR); @@ -99,16 +101,10 @@ void StartServer(const std::string& rpc_name) { platform::CPUPlace place; framework::Executor exe(place); platform::CPUDeviceContext ctx(place); - auto* block = AppendPrefetchBlcok(&program); - std::string in_var_name("ids"); - std::vector prefetch_block_ids{block->ID()}; - auto prepared = exe.Prepare(program, prefetch_block_ids); - InitTensorsOnServer(&scope, &place, 10); std::unordered_map> prefetch_var_name_to_prepared; - prefetch_var_name_to_prepared[in_var_name] = prepared[0]; g_req_handler->SetProgram(&program); g_req_handler->SetPrefetchPreparedCtx(&prefetch_var_name_to_prepared); @@ -128,49 +124,6 @@ void StartServer(const std::string& rpc_name) { server_thread.join(); } -TEST(PREFETCH, CPU) { - setenv("http_proxy", "", 1); - setenv("https_proxy", "", 1); - g_req_handler.reset(new distributed::RequestPrefetchHandler( - distributed::DistributedMode::kSync)); - g_rpc_service.reset(new RPCSERVER_T("127.0.0.1:0", 1)); - distributed::RPCClient* client = - distributed::RPCClient::GetInstance(0); - - std::thread server_thread(StartServer, distributed::kRequestPrefetch); - g_rpc_service->WaitServerReady(); - - int port = g_rpc_service->GetSelectedPort(); - std::string ep = paddle::string::Sprintf("127.0.0.1:%d", port); - - framework::Scope scope; - platform::CPUPlace place; - platform::CPUDeviceContext ctx(place); - { - // create var on local scope - int64_t rows_numel = 5; - InitTensorsOnClient(&scope, &place, rows_numel); - std::string in_var_name("ids"); - std::string out_var_name("out"); - - client->AsyncPrefetchVar(ep, ctx, scope, in_var_name, out_var_name); - client->Wait(); - auto var = scope.Var(out_var_name); - auto value = var->GetMutable(); - auto ptr = value->mutable_data(place); - - for (int64_t i = 0; i < rows_numel; ++i) { - EXPECT_EQ(ptr[0 + i * value->dims()[1]], static_cast(i * 2)); - } - } - - g_rpc_service->ShutDown(); - server_thread.join(); - LOG(INFO) << "begin reset"; - g_rpc_service.reset(nullptr); - g_req_handler.reset(nullptr); -} - TEST(COMPLETE, CPU) { setenv("http_proxy", "", 1); setenv("https_proxy", "", 1); diff --git a/paddle/fluid/operators/distributed_ops/checkpoint_notify_op.cc b/paddle/fluid/operators/distributed_ops/checkpoint_notify_op.cc index f0cc2cdcdac20393ba17a7b3824dfd6d3afe7973..2ed2acb96dc842b6a60bf31701d39ac94dab9804 100644 --- a/paddle/fluid/operators/distributed_ops/checkpoint_notify_op.cc +++ b/paddle/fluid/operators/distributed_ops/checkpoint_notify_op.cc @@ -1,11 +1,8 @@ /* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. - Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at - http://www.apache.org/licenses/LICENSE-2.0 - 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. @@ -35,19 +32,31 @@ class CheckpointNotifyOp : public framework::OperatorBase { void RunImpl(const framework::Scope& scope, const platform::Place& place) const override { - std::vector epmap = Attr>("epmap"); - std::string dir = Attr("dir"); - std::string lookup_table_name = Attr("lookup_table"); - int trainer_id = Attr("trainer_id"); + std::vector epmap = + Attr>("endpoints"); + std::string dirname = Attr("dirname"); + std::string varname = Attr("varname"); + auto is_slice = Attr("is_slice"); + VLOG(1) << "is_slice: " << is_slice; + + std::vector slice_varnames = + Attr>("slice_varnames"); + + std::vector remote_varnames = + Attr>("remote_varnames"); distributed::RPCClient* rpc_client = - distributed::RPCClient::GetInstance(trainer_id); + distributed::RPCClient::GetInstance(0); + for (size_t i = 0; i < epmap.size(); i++) { - auto lookup_table_save_dir = - string::Sprintf("%s/%s_%d", dir, lookup_table_name, i); - rpc_client->AsyncCheckpointNotify(epmap[i], lookup_table_save_dir); - VLOG(3) << "checkpoint notify sending lookup table: " << lookup_table_name - << " and dir:" << dir << " to " << epmap[i]; + auto save_path = + string::Sprintf("%s/%s/%s", dirname, varname, slice_varnames[i]); + + rpc_client->AsyncCheckpointNotify(epmap[i], save_path, + remote_varnames[i]); + + VLOG(3) << "checkpoint notify sending with path: " << save_path + << " and var:" << slice_varnames[i] << " to " << epmap[i]; } PADDLE_ENFORCE_EQ( rpc_client->Wait(), true, @@ -59,18 +68,22 @@ class CheckpointNotifyOp : public framework::OperatorBase { class CheckpointNotifyOpMaker : public framework::OpProtoAndCheckerMaker { public: void Make() { - AddAttr>("epmap", - "(string vector, default 127.0.0.1:6164)" - "Parameter Server endpoints in the order") - .SetDefault({"127.0.0.1:6164"}); - AddAttr( - "dir", "(string, default '') indicate the folder checkpoint will use"); - AddAttr("lookup_table", - "(string, default '') the lookup table name"); - AddAttr("trainer_id", "trainer id from 0 ~ worker_num.").SetDefault(0); + AddAttr>( + "endpoints", + "(string vector)" + "Parameter Server endpoints in the order"); + AddAttr("dirname", + "(string) indicate the folder checkpoint will use"); + AddAttr("varname", "(string) the var need to be saved"); + AddAttr>( + "slice_varnames", "(string vector) the slice vars need to be saved"); + AddAttr>( + "remote_varnames", "(string vector) the slice vars need to be saved"); + AddAttr( + "is_slice", + "is_slice=True means the var has been slice by parameter server"); AddComment(R"DOC( CheckpointNotify operator - This operator will send lookup table and it's checkpoint direcoty to listen_and_serve op at the parameter server. )DOC"); diff --git a/paddle/fluid/operators/distributed_ops/distributed_lookup_table_op.cc b/paddle/fluid/operators/distributed_ops/distributed_lookup_table_op.cc index 77150c4e48ea26e457c234b19193008a019f67b8..3037a63b0d7b4e8812e67fdfb776f89ea43eb546 100644 --- a/paddle/fluid/operators/distributed_ops/distributed_lookup_table_op.cc +++ b/paddle/fluid/operators/distributed_ops/distributed_lookup_table_op.cc @@ -26,7 +26,7 @@ class DistributedLookupTableOp : public framework::OperatorWithKernel { public: using framework::OperatorWithKernel::OperatorWithKernel; - void InferShape(framework::InferShapeContext* ctx) const override { + void InferShape(framework::InferShapeContext *ctx) const override { PADDLE_ENFORCE(ctx->HasInputs("Ids"), "Input(Ids) of LookupTableOp should not be null."); PADDLE_ENFORCE(ctx->HasInput("W"), @@ -40,28 +40,18 @@ class DistributedLookupTableOp : public framework::OperatorWithKernel { PADDLE_ENFORCE_EQ(table_dims.size(), 2, "Only 2 dimensions of the 'Embedding' is supported."); - for (auto& ids_dim : ids_dims) { + for (auto &ids_dim : ids_dims) { PADDLE_ENFORCE_EQ(ids_dim.size(), 2, "The dimension of the 'Ids' tensor must be 2."); } - auto lookup_tables = - ctx->Attrs().Get>("table_names"); - auto height_sections = - ctx->Attrs().Get>("height_sections"); auto endpoints = ctx->Attrs().Get>("endpoints"); auto lookup_table_version = ctx->Attrs().Get("lookup_table_version"); - PADDLE_ENFORCE(lookup_tables.size() == height_sections.size() && - lookup_tables.size() == endpoints.size() && - lookup_tables.size() != 0, - "Attrs lookup_tables/height_sections/endpoints must have " - "save size and can not be 0."); - auto outputs_dims = std::vector(); - for (auto& ids_dim : ids_dims) { + for (auto &ids_dim : ids_dims) { if (lookup_table_version == "lookup_table") { outputs_dims.push_back( framework::make_ddim({ids_dim[0], table_dims[1]})); @@ -78,7 +68,7 @@ class DistributedLookupTableOp : public framework::OperatorWithKernel { protected: framework::OpKernelType GetExpectedKernelType( - const framework::ExecutionContext& ctx) const override { + const framework::ExecutionContext &ctx) const override { return framework::OpKernelType( framework::proto::VarType::Type(ctx.Attr("dtype")), ctx.GetPlace()); @@ -88,35 +78,34 @@ class DistributedLookupTableOp : public framework::OperatorWithKernel { template class DistributedLookupTableKernel : public framework::OpKernel { public: - void Compute(const framework::ExecutionContext& context) const override { + void Compute(const framework::ExecutionContext &context) const override { auto ids_vars = context.MultiInputVar("Ids"); auto emb_vars = context.MultiOutput("Embeddings"); auto id_names = context.InputNames("Ids"); auto embedding_name = context.InputNames("W").front(); auto out_names = context.OutputNames("Outputs"); - auto lookup_tables = context.Attr>("table_names"); - auto height_sections = - context.Attr>("height_sections"); auto endpoints = context.Attr>("endpoints"); + auto is_distributed = context.Attr("is_distributed"); + auto lookup_table_version = context.Attr("lookup_table_version"); - operators::distributed::prefetchs( - id_names, out_names, embedding_name, false, lookup_tables, endpoints, - height_sections, context, context.scope()); + operators::distributed::prefetchs(id_names, out_names, embedding_name, + is_distributed, lookup_tables, endpoints, + context, context.scope()); if (lookup_table_version == "lookup_table_v2") { - auto& scope = context.scope(); + auto &scope = context.scope(); auto emb_dim = scope.FindVar(embedding_name)->Get().dims()[1]; for (size_t i = 0; i < id_names.size(); ++i) { - auto* id_var = scope.FindVar(id_names[i]); - auto* out_var = scope.FindVar(out_names[i]); - auto* id_tensor = id_var->GetMutable(); - auto* out_tensor = out_var->GetMutable(); + auto *id_var = scope.FindVar(id_names[i]); + auto *out_var = scope.FindVar(out_names[i]); + auto *id_tensor = id_var->GetMutable(); + auto *out_tensor = out_var->GetMutable(); auto id_dims = id_tensor->dims(); out_tensor->Resize(framework::make_ddim( @@ -148,17 +137,18 @@ class DistributedLookupTableOpMaker : public framework::OpProtoAndCheckerMaker { "(string vector, such as emb_block0, emb_block1)" "Server endpoints in the order of input variables for mapping") .SetDefault({""}); - - AddAttr>("height_sections", - "Height for each output SelectedRows.") - .SetDefault(std::vector({})); - AddAttr>( "endpoints", "(string vector, default 127.0.0.1:6164)" "Server endpoints in the order of input variables for mapping") .SetDefault({"127.0.0.1:6164"}); + AddAttr("pserver_num", "the number of pserver").SetDefault(0); + + AddAttr("is_distributed", + "(boolean, default false) distributed lookup table.") + .SetDefault(false); + AddAttr("trainer_id", "trainer id from 0 ~ worker_num.").SetDefault(0); AddAttr( diff --git a/paddle/fluid/operators/distributed_ops/listen_and_serv_op.cc b/paddle/fluid/operators/distributed_ops/listen_and_serv_op.cc index d40df6f9de0c1e22ea892993d66a2cdfa808b1c7..5869407be5a5750d3948f87fe8743adf0a425422 100644 --- a/paddle/fluid/operators/distributed_ops/listen_and_serv_op.cc +++ b/paddle/fluid/operators/distributed_ops/listen_and_serv_op.cc @@ -26,6 +26,7 @@ limitations under the License. */ #include "paddle/fluid/operators/distributed/async_sparse_param_update_recorder.h" #include "paddle/fluid/operators/distributed/heart_beat_monitor.h" +#include "paddle/fluid/operators/distributed/large_scale_kv.h" #include "paddle/fluid/operators/distributed/request_handler_impl.h" #include "paddle/fluid/operators/distributed_ops/listen_and_serv_op.h" @@ -42,6 +43,7 @@ void RunServer(std::shared_ptr service) { service->StartServer(); VLOG(4) << "RunServer thread end"; } + static void split(const std::string &str, char sep, std::vector *pieces) { pieces->clear(); @@ -109,6 +111,19 @@ static int64_t GetTimestamp() { return tp.tv_sec * 1000 + tp.tv_usec / 1000; } +// For sync, sparse variables need recover grad type from LodTensor to +// SelectedRows +void ResetSparseVarsType(framework::Scope *recv_scope) { + auto *ins = distributed::LargeScaleKV::GetInstance(); + auto grads = ins->GetAllGrads(); + + for (auto &grad : grads) { + auto *v = recv_scope->FindVar(grad); + v->Clear(); + v->GetMutable(); + } +} + void ListenAndServOp::RunSyncLoop( framework::Executor *executor, framework::ProgramDesc *program, framework::Scope *recv_scope, platform::DeviceContext *dev_ctx, @@ -179,6 +194,7 @@ void ListenAndServOp::RunSyncLoop( VLOG(3) << "ResetReceivedVars"; ResetReceivedVars(recv_scope, dev_ctx, rpc_service_->NeedResetAllVars()); + ResetSparseVarsType(recv_scope); VLOG(3) << "wait all clients to get parameters back"; rpc_service_->SetCond(distributed::kRequestGet); @@ -372,12 +388,12 @@ void ListenAndServOp::RunImpl(const framework::Scope &scope, new distributed::RequestGetHandler(distributed_mode, dc_sgd)); request_prefetch_handler_.reset( new distributed::RequestPrefetchHandler(distributed_mode)); - request_checkpoint_handler_.reset(new distributed::RequestCheckpointHandler( - distributed_mode, checkpoint_block_id)); + request_checkpoint_handler_.reset( + new distributed::RequestCheckpointHandler(distributed_mode)); request_get_no_barrier_handler_.reset( new distributed::RequestGetNoBarrierHandler()); - request_notify_handler_.reset(new distributed::RequestNotifyHandler( - distributed_mode, lr_decay_block_id)); + request_notify_handler_.reset( + new distributed::RequestNotifyHandler(distributed_mode, fan_in)); rpc_service_->RegisterRPC(distributed::kRequestSend, request_send_handler_.get(), rpc_send_thread_num); diff --git a/paddle/fluid/operators/distributed_ops/lookup_sparse_table_grad_split_op.cc b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_grad_split_op.cc new file mode 100644 index 0000000000000000000000000000000000000000..9ff2e78d8652d929bf0205009872379d5b14df19 --- /dev/null +++ b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_grad_split_op.cc @@ -0,0 +1,79 @@ +/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +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. */ + +#include "paddle/fluid/operators/distributed_ops/lookup_sparse_table_grad_split_op.h" +#include "paddle/fluid/operators/math/math_function.h" + +namespace paddle { +namespace operators { + +class LookupSparseTableGradSplitOp : public framework::OperatorWithKernel { + public: + using framework::OperatorWithKernel::OperatorWithKernel; + + void InferShape(framework::InferShapeContext *ctx) const override {} +}; + +class LookupSparseTableGradSplitOpMaker + : public framework::OpProtoAndCheckerMaker { + public: + void Make() override { + AddInput("Grad", + "(SelectedRows) Ids's type should be SelectedRows" + "THe ids to be looked up in W."); + + AddAttr("is_entry", + "(bool)" + "sparse table need entry"); + + AddAttr("tablename", + "(string)" + "sparse table name"); + + AddOutput("Row", + "(LoDTensor) The lookup results, which have the " + "same type as W."); + AddOutput("Value", + "(LoDTensor) The lookup results, which have the " + "same type as W."); + AddComment(R"DOC( +Lookup Sprase Tablel Operator. + +This operator is used to perform lookup on parameter W, +then concatenated into a sparse tensor. + +The type of Ids(Input) is SelectedRows, the rows of Ids contains +the ids to be looked up in W; +if the Id is not in the sparse table, this operator will return a +random value and set the value into the table for the next looking up. + +)DOC"); + } +}; +} // namespace operators +} // namespace paddle + +namespace ops = paddle::operators; +REGISTER_OPERATOR( + lookup_sparse_table_grad_split, ops::LookupSparseTableGradSplitOp, + ops::LookupSparseTableGradSplitOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); + +REGISTER_OP_CPU_KERNEL( + lookup_sparse_table_grad_split, + ops::LookupSparseTableGradSplitKernel, + ops::LookupSparseTableGradSplitKernel); diff --git a/paddle/fluid/operators/distributed_ops/lookup_sparse_table_grad_split_op.h b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_grad_split_op.h new file mode 100644 index 0000000000000000000000000000000000000000..b3077efda6de3efaa004152b4f35ab6b618f1b1e --- /dev/null +++ b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_grad_split_op.h @@ -0,0 +1,97 @@ +/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +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. */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +#include "paddle/fluid/framework/op_registry.h" +#include "paddle/fluid/operators/distributed/large_scale_kv.h" +#include "paddle/fluid/operators/math/selected_rows_functor.h" + +namespace paddle { +namespace operators { + +using Tensor = framework::Tensor; +using SelectedRows = framework::SelectedRows; + +template +class LookupSparseTableGradSplitKernel : public framework::OpKernel { + public: + void Compute(const framework::ExecutionContext& context) const override { + const SelectedRows* in_grad = context.Input("Grad"); + + // merge duplicated rows if any. + // The rows of grad_merge_ptr have been sorted inside MergeAdd functor + framework::SelectedRows tmp_grad_merge; + const framework::SelectedRows* grad_merge_ptr; + math::scatter::MergeAdd merge_func; + merge_func(context.template device_context(), *in_grad, + &tmp_grad_merge, true); + grad_merge_ptr = &tmp_grad_merge; + + std::vector in_rows; + in_rows.reserve(grad_merge_ptr->rows().size()); + std::copy(grad_merge_ptr->rows().begin(), grad_merge_ptr->rows().end(), + std::back_inserter(in_rows)); + + auto* out_row = context.Output("Row"); + out_row->Resize( + framework::make_ddim({static_cast(in_rows.size()), 1})); + out_row->mutable_data(context.GetPlace()); + framework::TensorFromVector(in_rows, context.device_context(), out_row); + + auto in_value = grad_merge_ptr->value(); + std::vector ins_vector; + framework::TensorToVector(in_value, context.device_context(), &ins_vector); + auto dims = in_value.dims(); + + auto is_entry = context.Attr("is_entry"); + auto tablename = context.Attr("tablename"); + + if (is_entry) { + auto* ins = distributed::LargeScaleKV::GetInstance(); + std::vector ids; + ins->Get(tablename)->GetEntry(in_rows, &ids); + + for (auto& id : ids) { + auto it = std::find(in_rows.begin(), in_rows.end(), id); + if (it == in_rows.end()) { + PADDLE_THROW(platform::errors::OutOfRange( + "the input key should be exists. But received %d.", id)); + } + + auto distance = + static_cast(std::distance(in_rows.begin(), it)); + std::fill(ins_vector.data() + distance * dims[1], + ins_vector.data() + dims[1], 0.0); + } + } + + auto* out_v = context.OutputVar("Value"); + out_v->Clear(); + auto* out_t = out_v->GetMutable(); + out_t->mutable_data(context.GetPlace()); + framework::TensorFromVector(ins_vector, context.device_context(), out_t); + out_t->Resize(dims); + } +}; +} // namespace operators +} // namespace paddle diff --git a/paddle/fluid/operators/distributed_ops/lookup_sparse_table_init_op.cc b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_init_op.cc new file mode 100644 index 0000000000000000000000000000000000000000..96ec6a85d6eab5ccc24d0c3a2a0e120810c4015d --- /dev/null +++ b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_init_op.cc @@ -0,0 +1,147 @@ +/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +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. */ + +#include + +#include "paddle/fluid/framework/data_type.h" +#include "paddle/fluid/framework/op_registry.h" +#include "paddle/fluid/operators/distributed/large_scale_kv.h" +#include "paddle/fluid/operators/math/math_function.h" + +namespace paddle { +namespace operators { + +// examples: embedding:Param,Moment1,Moment2:64,64,64:0 +constexpr char kLargeScaleKV[] = "large_scale_metas"; +constexpr int64_t kNoPadding = -1; + +static void split(const std::string &str, char sep, + std::vector *pieces) { + pieces->clear(); + if (str.empty()) { + return; + } + size_t pos = 0; + size_t next = str.find(sep, pos); + while (next != std::string::npos) { + pieces->push_back(str.substr(pos, next - pos)); + pos = next + 1; + next = str.find(sep, pos); + } + if (!str.substr(pos).empty()) { + pieces->push_back(str.substr(pos)); + } +} + +class LookupSparseTableInitInferShape : public framework::InferShapeBase { + public: + void operator()(framework::InferShapeContext *ctx) const override {} +}; + +void InitLargeScaleKV(std::vector kv_attrs) { + std::vector metas; + + for (auto attrs : kv_attrs) { + std::vector pieces; + split(attrs, ':', &pieces); + PADDLE_ENFORCE_EQ( + pieces.size(), 8, + platform::errors::InvalidArgument( + "param, names, dims, mode, grad, cached_var, init_attrs")); + + std::string name; + std::string grad_name; + std::vector value_names; + std::vector value_dims; + distributed::Mode mode; + std::vector cached_names; + std::vector init_attrs; + std::string entry_attr; + + name = pieces[0]; + split(pieces[1], ',', &value_names); + + std::vector value_dims_str; + split(pieces[2], ',', &value_dims_str); + for (auto &str : value_dims_str) { + value_dims.push_back(std::stoi(str)); + } + + mode = pieces[3] == "0" ? distributed::Mode::training + : distributed::Mode::infer; + + grad_name = pieces[4]; + split(pieces[5], ',', &cached_names); + split(pieces[6], ',', &init_attrs); + entry_attr = pieces[7]; + + auto meta = distributed::SparseMeta(); + meta.name = name; + meta.value_names = value_names; + meta.value_dims = value_dims; + meta.mode = mode; + meta.grad_name = grad_name; + meta.cached_varnames = cached_names; + meta.initializer_attrs = init_attrs; + meta.entry = entry_attr; + + VLOG(3) << "add sparse meta: " << meta.ToString(); + metas.push_back(meta); + } + + distributed::LargeScaleKV::Init(metas); + VLOG(3) << "init large scale kv with " << metas.size() << " params"; +} + +class LookupSparseTableInitOp : public framework::OperatorBase { + public: + using framework::OperatorBase::OperatorBase; + + private: + void RunImpl(const framework::Scope &scope, + const platform::Place &dev_place) const override { + auto kv_attrs = Attr>(kLargeScaleKV); + InitLargeScaleKV(kv_attrs); + } +}; + +class LookupSparseTableInitOpMaker : public framework::OpProtoAndCheckerMaker { + public: + void Make() override { + AddAttr>(kLargeScaleKV, + "(string)" + "sparse table name"); + AddComment(R"DOC( +Lookup Sprase Tablel Operator. + +This operator is used to perform lookup on parameter W, +then concatenated into a sparse tensor. + +The type of Ids(Input) is SelectedRows, the rows of Ids contains +the ids to be looked up in W; +if the Id is not in the sparse table, this operator will return a +random value and set the value into the table for the next looking up. + +)DOC"); + } +}; +} // namespace operators +} // namespace paddle + +namespace ops = paddle::operators; +REGISTER_OPERATOR( + lookup_sparse_table_init, ops::LookupSparseTableInitOp, + ops::LookupSparseTableInitInferShape, ops::LookupSparseTableInitOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/distributed_ops/lookup_sparse_table_merge_op.cc b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_merge_op.cc new file mode 100644 index 0000000000000000000000000000000000000000..79dc206f040cc5e1bcefb006f10de510eb53270f --- /dev/null +++ b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_merge_op.cc @@ -0,0 +1,84 @@ +/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +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. */ + +#include "paddle/fluid/operators/distributed_ops/lookup_sparse_table_merge_op.h" + +namespace paddle { +namespace operators { + +class LookupSparseTableMergeOp : public framework::OperatorWithKernel { + public: + using framework::OperatorWithKernel::OperatorWithKernel; + + void InferShape(framework::InferShapeContext* ctx) const override { + PADDLE_ENFORCE_EQ( + ctx->HasInputs("X"), true, + platform::errors::InvalidArgument("Input(X) should not be null.")); + PADDLE_ENFORCE_EQ( + ctx->HasOutput("Out"), true, + platform::errors::InvalidArgument("Output(Out) should not be null.")); + + PADDLE_ENFORCE_EQ(ctx->GetInputsVarType("X").front(), + framework::proto::VarType::SELECTED_ROWS, + platform::errors::InvalidArgument( + "Input X only should be SelectedRows.")); + PADDLE_ENFORCE_EQ(ctx->GetOutputsVarType("Out").front(), + framework::proto::VarType::SELECTED_ROWS, + platform::errors::InvalidArgument( + "Output Y only should be SelectedRows.")); + + ctx->ShareDim("X", /*->*/ "Out"); + } +}; + +class LookupSparseTableMergeMaker : public framework::OpProtoAndCheckerMaker { + public: + void Make() override { + AddInput("X", + "The input type is SelectedRows, and the selected rows may be " + "duplicated.") + .AsDuplicable(); + AddOutput("Out", + "The output type is SelectedRows, and the selected rows are not " + "duplicated."); + AddComment( + R"DOC( +Merge sparse lookup table(selected rows as parameter). +)DOC"); + } +}; + +class LookupSparseTableMergeOpInferVarType + : public framework::PassInDtypeAndVarTypeToOutput { + protected: + std::unordered_map& GetInputOutputWithSameType() + const override { + static std::unordered_map m{{"X", /*->*/ "Out"}}; + return m; + } +}; + +} // namespace operators +} // namespace paddle + +namespace ops = paddle::operators; +namespace plat = paddle::platform; +REGISTER_OPERATOR(lookup_sparse_table_merge, ops::LookupSparseTableMergeOp, + ops::LookupSparseTableMergeMaker, + ops::LookupSparseTableMergeOpInferVarType); + +REGISTER_OP_CPU_KERNEL( + lookup_sparse_table_merge, + ops::LookupSparseTableMergeKernel, + ops::LookupSparseTableMergeKernel); diff --git a/paddle/fluid/operators/distributed_ops/lookup_sparse_table_merge_op.h b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_merge_op.h new file mode 100644 index 0000000000000000000000000000000000000000..0efd5cada1c93e129da1b608046d355693fad6fd --- /dev/null +++ b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_merge_op.h @@ -0,0 +1,78 @@ +/* Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * 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. */ + +#pragma once + +#include +#include +#include +#include + +#include "paddle/fluid/framework/op_registry.h" + +namespace paddle { +namespace operators { + +int64_t GetDelimiterForShard(const std::vector& rows, int start_idx, + int shard_id, int shard_num) { + int64_t rows_num = rows.size() / 2; + for (int64_t i = start_idx; i < rows_num; ++i) { + if (rows[i] % shard_num != shard_id) { + return i; + } + } + return rows_num; +} + +template +class LookupSparseTableMergeKernel : public framework::OpKernel { + public: + void Compute(const framework::ExecutionContext& ctx) const override { + auto inputs = ctx.MultiInput("X"); + auto* out = ctx.Output("Out"); + + int64_t height = 0; + int64_t ids_num = 0; + int64_t width = 0; + + height = inputs[0]->height(); + width = inputs[0]->value().dims()[1]; + + for (auto& in : inputs) { + ids_num += in->rows().size(); + height += in->height(); + } + + T* out_data = out->mutable_value()->mutable_data({ids_num, width}, + platform::CPUPlace()); + + out->set_height(height); + std::vector all_ids; + all_ids.reserve(ids_num); + for (auto& in : inputs) { + all_ids.insert(all_ids.end(), in->rows().begin(), in->rows().end()); + } + out->set_rows(all_ids); + + int64_t cnt = 0; + + for (auto& in : inputs) { + auto rows = in->rows().size(); + const T* in_data = in->value().data(); + std::copy_n(in_data, rows * width, out_data + cnt); + cnt += rows * width; + } + out->SyncIndex(); + } +}; + +} // namespace operators +} // namespace paddle diff --git a/paddle/fluid/operators/distributed_ops/lookup_sparse_table_read_op.cc b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_read_op.cc new file mode 100644 index 0000000000000000000000000000000000000000..87a37c5bfdefaae36d4f28549af7cd92d52d3584 --- /dev/null +++ b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_read_op.cc @@ -0,0 +1,133 @@ +/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +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. */ + +#include + +#include "paddle/fluid/framework/data_type.h" +#include "paddle/fluid/framework/op_registry.h" +#include "paddle/fluid/operators/distributed/large_scale_kv.h" +#include "paddle/fluid/operators/math/math_function.h" + +namespace paddle { +namespace operators { + +constexpr int64_t kNoPadding = -1; + +class LookupSparseTableReadInferShape : public framework::InferShapeBase { + public: + void operator()(framework::InferShapeContext *ctx) const override {} +}; + +class LookupSparseTableReadOp : public framework::OperatorBase { + public: + using framework::OperatorBase::OperatorBase; + + private: + void RunImpl(const framework::Scope &scope, + const platform::Place &dev_place) const override { + auto init = Attr("init"); + + auto &id_tensor = scope.FindVar(Input("Ids"))->Get(); + auto *id_data = id_tensor.data(); + auto tablename = Attr("tablename"); + auto value_names = Attr>("value_names"); + auto out_names = Outputs("Out"); + + std::vector ids; + for (int64_t i = 0; i < id_tensor.numel(); ++i) { + ids.push_back(id_data[i]); + } + + std::vector *>> values; + std::vector dims; + + auto *ins = distributed::LargeScaleKV::GetInstance(); + + if (init) { + ins->Get(tablename)->Init(ids); + ins->Get(tablename)->Get(ids, value_names, &values); + } else { + ins->Get(tablename)->Get(ids, value_names, &values); + } + + ins->Get(tablename)->Dims(value_names, &dims); + + platform::CPUPlace cpu; + std::vector tensors; + + for (int i = 0; i < static_cast(value_names.size()); i++) { + auto out_var = scope.FindVar(out_names[i]); + auto out_t = out_var->GetMutable(); + + std::vector o_dims; + o_dims.push_back(static_cast(ids.size())); + o_dims.push_back(dims[i]); + out_t->Resize(framework::make_ddim(o_dims)); + auto *out_d = out_t->mutable_data(cpu); + tensors.push_back(out_d); + } + + for (int i = 0; i < static_cast(values.size()); i++) { + for (int j = 0; j < static_cast(tensors.size()); j++) { + std::memcpy(tensors[j] + i * dims[j], values[i][j]->data(), + sizeof(float) * dims[j]); + } + } + } +}; + +class LookupSparseTableReadOpMaker : public framework::OpProtoAndCheckerMaker { + public: + void Make() override { + AddInput("Ids", + "(LoDTensor) Ids's type should be LoDTensor" + "THe ids to be looked up in W."); + AddOutput("Out", + "(LoDTensor) The lookup results, which have the " + "same type as W.") + .AsDuplicable(); + + AddAttr("tablename", + "(string)" + "sparse table name"); + + AddAttr>("value_names", + "(strings)" + "sparse table name"); + + AddAttr("init", " for test init large scale kv").SetDefault(false); + + AddComment(R"DOC( +Lookup Sprase Tablel Operator. + +This operator is used to perform lookup on parameter W, +then concatenated into a sparse tensor. + +The type of Ids(Input) is SelectedRows, the rows of Ids contains +the ids to be looked up in W; +if the Id is not in the sparse table, this operator will return a +random value and set the value into the table for the next looking up. + +)DOC"); + } +}; +} // namespace operators +} // namespace paddle + +namespace ops = paddle::operators; +REGISTER_OPERATOR( + lookup_sparse_table_read, ops::LookupSparseTableReadOp, + ops::LookupSparseTableReadInferShape, ops::LookupSparseTableReadOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/distributed_ops/lookup_sparse_table_write_op.cc b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_write_op.cc new file mode 100644 index 0000000000000000000000000000000000000000..afe79cd1c316c637a1d2f63c8284683e6e10393c --- /dev/null +++ b/paddle/fluid/operators/distributed_ops/lookup_sparse_table_write_op.cc @@ -0,0 +1,116 @@ +/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +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. */ + +#include + +#include "paddle/fluid/framework/data_type.h" +#include "paddle/fluid/framework/op_registry.h" +#include "paddle/fluid/operators/distributed/large_scale_kv.h" +#include "paddle/fluid/operators/math/math_function.h" + +namespace paddle { +namespace operators { + +constexpr int64_t kNoPadding = -1; + +class LookupSparseTableWriteInferShape : public framework::InferShapeBase { + public: + void operator()(framework::InferShapeContext *ctx) const override {} +}; + +class LookupSparseTableWriteOp : public framework::OperatorBase { + public: + using framework::OperatorBase::OperatorBase; + + private: + void RunImpl(const framework::Scope &scope, + const platform::Place &dev_place) const override { + auto &id_tensor = scope.FindVar(Input("Ids"))->Get(); + auto *id_data = id_tensor.data(); + + std::vector ids; + for (int64_t i = 0; i < id_tensor.numel(); ++i) { + ids.push_back(id_data[i]); + } + + auto tablename = Attr("tablename"); + auto value_names = Attr>("value_names"); + + std::vector tensors; + std::vector dims; + std::vector>> values; + values.resize(ids.size()); + + auto in_names = Inputs("In"); + for (int i = 0; i < static_cast(in_names.size()); i++) { + auto *in = scope.FindVar(in_names[i]); + auto in_t = in->Get(); + dims.push_back(in_t.dims()[1]); + tensors.push_back(in_t.data()); + } + + for (int i = 0; i < static_cast(ids.size()); i++) { + values[i].resize(tensors.size()); + for (int j = 0; j < static_cast(tensors.size()); j++) { + values[i][j].resize(dims[j]); + std::memcpy(values[i][j].data(), tensors[j] + i * dims[j], + sizeof(float) * dims[j]); + } + } + + auto *ins = distributed::LargeScaleKV::GetInstance(); + ins->Get(tablename)->Set(ids, value_names, values); + } +}; + +class LookupSparseTableWriteOpMaker : public framework::OpProtoAndCheckerMaker { + public: + void Make() override { + AddInput("Ids", + "(LoDTensor) Ids's type should be LoDTensor" + "THe ids to be looked up in W."); + AddInput("In", + "(LoDTensor) The lookup results, which have the " + "same type as W.") + .AsDuplicable(); + + AddAttr("tablename", + "(string)" + "sparse table name"); + AddAttr>("value_names", + "(strings)" + "sparse table name"); + AddComment(R"DOC( +Lookup Sprase Tablel Operator. + +This operator is used to perform lookup on parameter W, +then concatenated into a sparse tensor. + +The type of Ids(Input) is SelectedRows, the rows of Ids contains +the ids to be looked up in W; +if the Id is not in the sparse table, this operator will return a +random value and set the value into the table for the next looking up. + +)DOC"); + } +}; +} // namespace operators +} // namespace paddle + +namespace ops = paddle::operators; +REGISTER_OPERATOR( + lookup_sparse_table_write, ops::LookupSparseTableWriteOp, + ops::LookupSparseTableWriteInferShape, ops::LookupSparseTableWriteOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/distributed_ops/recv_op.cc b/paddle/fluid/operators/distributed_ops/recv_op.cc index aad9aefed4ecc4aa4241ae48f7743ec6ad7ce024..15b36baeada300e1ab472737b4e35538f9882cb7 100644 --- a/paddle/fluid/operators/distributed_ops/recv_op.cc +++ b/paddle/fluid/operators/distributed_ops/recv_op.cc @@ -19,9 +19,10 @@ limitations under the License. */ #include "paddle/fluid/framework/framework.pb.h" #include "paddle/fluid/framework/lod_tensor.h" #include "paddle/fluid/framework/op_registry.h" +#include "paddle/fluid/operators/distributed/communicator.h" +#include "paddle/fluid/operators/distributed/communicator_common.h" #include "paddle/fluid/operators/distributed/distributed.h" #include "paddle/fluid/operators/distributed/parameter_recv.h" -#include "paddle/fluid/operators/distributed/rpc_common.h" #include "paddle/fluid/platform/profiler.h" namespace paddle { @@ -41,6 +42,7 @@ class RecvOp : public framework::OperatorBase { VLOG(3) << "recv do not run!"; return; } + std::vector epmap = Attr>("epmap"); std::vector varnames = Attr>("varnames"); @@ -59,10 +61,13 @@ class RecvOp : public framework::OperatorBase { Attr>("recv_varnames"); if (recv_varnames.size() > 0) { - auto recv_functor = distributed::ParameterRecv(); - auto rpc_ctx = distributed::RpcContext(outs[0], recv_varnames, epmap, {}, - trainer_id); - recv_functor(rpc_ctx, scope); + auto *communicator = distributed::Communicator::GetInstance(); + + if (communicator == nullptr) { + PADDLE_THROW(platform::errors::InvalidArgument( + "need run fleet.init_worker first")); + } + communicator->RecvNoBarrier(); } else { std::vector rets; if (with_barrier) { diff --git a/paddle/fluid/operators/distributed_ops/recv_save_op.cc b/paddle/fluid/operators/distributed_ops/recv_save_op.cc index 565e9f9886e5872e540d08484f22761d31ff7643..ccc30d1ea082a6f69b71059631247144c931116e 100644 --- a/paddle/fluid/operators/distributed_ops/recv_save_op.cc +++ b/paddle/fluid/operators/distributed_ops/recv_save_op.cc @@ -26,9 +26,9 @@ limitations under the License. */ #include "paddle/fluid/framework/selected_rows.h" #include "paddle/fluid/framework/variable.h" #include "paddle/fluid/framework/version.h" +#include "paddle/fluid/operators/distributed/communicator_common.h" #include "paddle/fluid/operators/distributed/distributed.h" #include "paddle/fluid/operators/distributed/parameter_recv.h" -#include "paddle/fluid/operators/distributed/rpc_common.h" #include "paddle/fluid/string/string_helper.h" namespace paddle { @@ -105,6 +105,10 @@ This operator will serialize and write LoDTensor variable to file on disk. .SetDefault({}); AddAttr("trainer_id", "trainer id from 0 ~ worker_num.").SetDefault(0); + AddAttr("is_sparse", "sparse or dense param"); + AddAttr("pserver_num", "the number of pserver").SetDefault(0); + AddAttr("is_distributed", "sparse id range [0, N) or [0, INT64]") + .SetDefault(false); } }; @@ -159,8 +163,6 @@ class RecvSaveOpKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext &ctx) const override { - auto place = ctx.GetPlace(); - auto filename = ctx.Attr("file_path"); auto overwrite = ctx.Attr("overwrite"); @@ -178,6 +180,11 @@ class RecvSaveOpKernel : public framework::OpKernel { ctx.Attr>("remote_varnames"); auto endpoints = ctx.Attr>("endpoints"); + auto trainer_id = ctx.Attr("trainer_id"); + auto is_sparse = ctx.Attr("is_sparse"); + auto pserver_num = ctx.Attr("pserver_num"); + // auto is_distributed = ctx.Attr("is_distributed"); + PADDLE_ENFORCE_EQ(slice_shapes.size(), slice_varnames.size(), platform::errors::InvalidArgument( "Expected attr len(slice_shapes) must be equal to " @@ -202,44 +209,105 @@ class RecvSaveOpKernel : public framework::OpKernel { framework::make_ddim(origin_shape)); framework::Scope &local_scope = ctx.scope().NewScope(); - - auto trainer_id = ctx.Attr("trainer_id"); - platform::DeviceContextPool &pool = platform::DeviceContextPool::Instance(); + auto place = ctx.GetPlace(); auto &device_ctx = *pool.Get(place); distributed::RPCClient *rpc_client = distributed::RPCClient::GetInstance(trainer_id); - for (size_t i = 0; i < slice_varnames.size(); i++) { - auto &varname = slice_varnames[i]; - auto *var = local_scope.Var(varname); - auto *tensor = var->GetMutable(); + if (!is_sparse) { + for (size_t i = 0; i < slice_varnames.size(); i++) { + auto &varname = slice_varnames[i]; + auto *var = local_scope.Var(varname); + auto *tensor = var->GetMutable(); + + auto slice_string = + string::split_string(slice_shapes[i], ","); + std::vector slice_shape; + + for (auto &dim : slice_string) { + slice_shape.push_back(static_cast(std::stoull(dim))); + } + + tensor->Resize(framework::make_ddim(slice_shape)); + + distributed::VarHandlePtr ret; + + ret = rpc_client->AsyncGetVarNoBarrier( + endpoints[i], device_ctx, local_scope, remote_varnames[i], varname); - auto slice_string = - string::split_string(slice_shapes[i], ","); - std::vector slice_shape; + PADDLE_ENFORCE_NE( + ret->Wait(), 0U, + platform::errors::ExecutionTimeout( + "rpc error when communication with %s", endpoints[i])); - for (auto &dim : slice_string) { - slice_shape.push_back(static_cast(std::stoull(dim))); + auto &c_tensor = var->Get(); + + SerializeTensorAppendToStream(fout, c_tensor); + local_scope.EraseVars({varname}); + } + } else { + PADDLE_ENFORCE_GT( + pserver_num, 0, + platform::errors::InvalidArgument( + "Expected attr len(pserver_num) must gather than 0")); + + std::vector varnames; + auto *var = local_scope.Var("tmp_for_sparse_merge"); + auto *o_t = var->GetMutable(); + o_t->Resize(framework::make_ddim(origin_shape)); + auto *out_d = o_t->mutable_data(place); + + varnames.push_back("tmp_for_sparse_merge"); + for (size_t i = 0; i < slice_varnames.size(); i++) { + varnames.push_back(slice_varnames[i]); } - tensor->Resize(framework::make_ddim(slice_shape)); + std::vector tensors; - distributed::VarHandlePtr ret; + for (size_t i = 0; i < slice_varnames.size(); i++) { + auto &varname = slice_varnames[i]; + auto *local_var = local_scope.Var(varname); + auto *tensor = local_var->GetMutable(); - ret = rpc_client->AsyncGetVarNoBarrier( - endpoints[i], device_ctx, local_scope, remote_varnames[i], varname); + auto slice_string = + string::split_string(slice_shapes[i], ","); + std::vector slice_shape; - PADDLE_ENFORCE_NE( - ret->Wait(), 0U, - platform::errors::ExecutionTimeout( - "rpc error when communication with %s", endpoints[i])); + for (auto &dim : slice_string) { + slice_shape.push_back(static_cast(std::stoull(dim))); + } - auto &c_tensor = var->Get(); + tensor->Resize(framework::make_ddim(slice_shape)); + + distributed::VarHandlePtr ret; + + ret = rpc_client->AsyncGetVarNoBarrier( + endpoints[i], device_ctx, local_scope, remote_varnames[i], varname); + + PADDLE_ENFORCE_NE( + ret->Wait(), 0U, + platform::errors::ExecutionTimeout( + "rpc error when communication with %s", endpoints[i])); + const auto *value = + local_var->Get().data(); + tensors.push_back(value); + } + + auto dims1 = origin_shape[1]; + for (int j = 0; j < origin_shape[0]; ++j) { + auto id = j % pserver_num; + auto idx = j / pserver_num; + std::memcpy(out_d + j * dims1, tensors[id] + idx * dims1, + sizeof(float) * dims1); + } + + auto &c_tensor = var->Get(); SerializeTensorAppendToStream(fout, c_tensor); - local_scope.EraseVars({varname}); + + local_scope.EraseVars(varnames); } fout.close(); diff --git a/paddle/fluid/operators/distributed_ops/send_op.cc b/paddle/fluid/operators/distributed_ops/send_op.cc index 6d129a2140f45b104a797551159a0623df3fdc33..53e3d70f960938bed77cba4112e22692dd7ed87b 100644 --- a/paddle/fluid/operators/distributed_ops/send_op.cc +++ b/paddle/fluid/operators/distributed_ops/send_op.cc @@ -20,9 +20,9 @@ limitations under the License. */ #include "paddle/fluid/framework/lod_tensor.h" #include "paddle/fluid/framework/op_registry.h" #include "paddle/fluid/operators/distributed/communicator.h" +#include "paddle/fluid/operators/distributed/communicator_common.h" #include "paddle/fluid/operators/distributed/distributed.h" #include "paddle/fluid/operators/distributed/parameter_send.h" -#include "paddle/fluid/operators/distributed/rpc_common.h" #include "paddle/fluid/operators/distributed_ops/send_recv_util.h" #include "paddle/fluid/platform/profiler.h" @@ -40,7 +40,7 @@ class SendOp : public framework::OperatorBase { const platform::Place& place) const override { auto ins = Inputs("X"); - auto epmap = Attr>("epmap"); + auto epmap = Attr>("endpoints"); auto trainer_id = Attr("trainer_id"); auto send_varnames = Attr>("send_varnames"); @@ -105,7 +105,7 @@ Send operator This operator will send variables to listen_and_serve op at the parameter server. )DOC"); AddAttr("trainer_id", "trainer id from 0 ~ worker_num.").SetDefault(0); - AddAttr>("epmap", + AddAttr>("endpoints", "(string vector, default 127.0.0.1:6164)" "Server endpoints in the order of input " "variables for mapping") diff --git a/paddle/fluid/operators/lookup_sparse_table_op.cc b/paddle/fluid/operators/lookup_sparse_table_op.cc deleted file mode 100644 index e40575110e7354785b5e9eea1af0363eea3b7af9..0000000000000000000000000000000000000000 --- a/paddle/fluid/operators/lookup_sparse_table_op.cc +++ /dev/null @@ -1,124 +0,0 @@ -/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -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. */ - -#include - -#include "paddle/fluid/framework/data_type.h" -#include "paddle/fluid/framework/op_registry.h" -#include "paddle/fluid/operators/math/math_function.h" - -namespace paddle { -namespace operators { - -constexpr int64_t kNoPadding = -1; - -class LookupSparseTableInferShape : public framework::InferShapeBase { - public: - void operator()(framework::InferShapeContext *ctx) const override { - OP_INOUT_CHECK(ctx->HasOutput("Out"), "Output", "Out", "LookupSparseTable"); - auto shape_w = ctx->GetInputDim("W"); - auto shape_ids = ctx->GetInputDim("Ids"); - shape_w[0] = shape_ids.size(); - ctx->SetOutputDim("Out", shape_w); - } -}; - -class LookupSparseTableOp : public framework::OperatorBase { - public: - using framework::OperatorBase::OperatorBase; - - private: - void RunImpl(const framework::Scope &scope, - const platform::Place &dev_place) const override { - auto out_var = scope.FindVar(Output("Out")); - auto w_var = scope.FindVar(Input("W")); - auto ids_var = scope.FindVar(Input("Ids")); - auto is_test = Attr("is_test"); - - PADDLE_ENFORCE_EQ(out_var->IsType(), true, - platform::errors::InvalidArgument( - "The type of Out var should be LodTensor.")); - PADDLE_ENFORCE_EQ(w_var->IsType(), true, - platform::errors::InvalidArgument( - "The type of W var should be SelectedRows.")); - PADDLE_ENFORCE_EQ(ids_var->IsType(), true, - platform::errors::InvalidArgument( - "The type of Ids var should be LoDTensor.")); - auto &ids_t = ids_var->Get(); - auto out_t = out_var->GetMutable(); - auto w_t = w_var->GetMutable(); - - // TODO(Yancey1989): support CUDA Place for the sparse table - platform::CPUPlace cpu; - auto out_shape = w_t->value().dims(); - out_shape[0] = ids_t.numel(); - out_t->Resize(out_shape); - out_t->mutable_data(cpu, w_t->value().type()); - PADDLE_ENFORCE_EQ(w_t->value().type(), framework::proto::VarType::FP32, - platform::errors::InvalidArgument( - "The sparse table only support FP32")); - w_t->Get(ids_t, out_t, true, is_test); - out_t->set_lod(ids_t.lod()); - } -}; - -class LookupSparseTableOpMaker : public framework::OpProtoAndCheckerMaker { - public: - void Make() override { - AddInput("W", - "(SelectedRows) The input represents embedding table, " - "which is a learnable parameter."); - AddInput("Ids", - "(LoDTensor) Ids's type should be LoDTensor" - "THe ids to be looked up in W."); - AddOutput("Out", - "(LoDTensor) The lookup results, which have the " - "same type as W."); - AddAttr("padding_idx", - "(int64, default -1) " - "If the value is -1, it makes no effect to lookup. " - "Otherwise the given value indicates padding the output " - "with zeros whenever lookup encounters it in Ids.") - .SetDefault(kNoPadding); - AddAttr("auto_grown_table", - "(bool default false)" - "Whether create new value if for nonexistent key.") - .SetDefault(true); - AddAttr("is_test", - "In test mode, lookup_sparse_table will " - "return a 0 for unknown id") - .SetDefault(false); - AddComment(R"DOC( -Lookup Sprase Tablel Operator. - -This operator is used to perform lookup on parameter W, -then concatenated into a sparse tensor. - -The type of Ids(Input) is SelectedRows, the rows of Ids contains -the ids to be looked up in W; -if the Id is not in the sparse table, this operator will return a -random value and set the value into the table for the next looking up. - -)DOC"); - } -}; -} // namespace operators -} // namespace paddle - -namespace ops = paddle::operators; -REGISTER_OPERATOR( - lookup_sparse_table, ops::LookupSparseTableOp, - ops::LookupSparseTableInferShape, ops::LookupSparseTableOpMaker, - paddle::framework::EmptyGradOpMaker, - paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/lookup_table_op.cc b/paddle/fluid/operators/lookup_table_op.cc index 9b1519b54696c8ecd90c98f46d3826d31526894a..57425fe26218ba25f84cd3b78d7e9342677a3771 100644 --- a/paddle/fluid/operators/lookup_table_op.cc +++ b/paddle/fluid/operators/lookup_table_op.cc @@ -92,31 +92,49 @@ class LookupTableOpMaker : public framework::OpProtoAndCheckerMaker { "Otherwise the given value indicates padding the output " "with zeros whenever lookup encounters it in Ids.") .SetDefault(kNoPadding); - // NOTE(minqiyang): grad_inplace is an temporal attribute, - // please do NOT set this attribute in python layer. + + // for parameter training config + AddAttr("remote_prefetch", + "pull sparse params from parameters, this can only be used " + "in distributed training") + .SetDefault(false); + + AddAttr("entry_config", + "embedding sparse feature entry config, " + " probability entry / counting " + " this can only be used in distributed training" + "entry") + .SetDefault(""); + + AddAttr("is_test", + "(bool, default false) Set to true for inference only, false " + "for training.") + .SetDefault(false); + + AddAttr("entry", + "(std::string, default " + ") for entry attribute.") + .SetDefault("none"); + + AddAttr>( + "table_names", + "(string vector, the split table names that will be fetched from " + "parameter server)" + "in the order of input variables for mapping") + .SetDefault({}); + AddAttr("trainer_id", "trainer id from 0 ~ worker_num.").SetDefault(0); AddAttr("grad_inplace", "(boolean, default false) " "If the grad op reuse the input's variable.") .SetDefault(false); - - // for parameter prefetch - AddAttr("remote_prefetch", "").SetDefault(false); - AddAttr("trainer_id", "trainer id from 0 ~ worker_num.").SetDefault(0); - AddAttr>("height_sections", - "Height for each output SelectedRows.") - .SetDefault(std::vector({})); AddAttr>( "epmap", "(string vector, default 127.0.0.1:6164)" "Server endpoints in the order of input variables for mapping") .SetDefault({}); - AddAttr>( - "table_names", - "(string vector, the split table names that will be fetched from " - "parameter server)" - "in the order of input variables for mapping") - .SetDefault({}); - + AddAttr>("height_sections", + "Height for each output SelectedRows.") + .SetDefault(std::vector({})); AddComment(R"DOC( Lookup Table Operator. diff --git a/paddle/fluid/operators/lookup_table_op.h b/paddle/fluid/operators/lookup_table_op.h index 1a8c18f158cd947f8446b9a70da8fdef649b02bc..526631bc82880e8b0a4191e30adfd1c6d4b30bf0 100644 --- a/paddle/fluid/operators/lookup_table_op.h +++ b/paddle/fluid/operators/lookup_table_op.h @@ -49,83 +49,89 @@ class LookupTableKernel : public framework::OpKernel { auto embedding_name = context.InputNames("W").front(); auto out_name = context.OutputNames("Out").front(); - // for remote prefetch - auto epmap = context.Attr>("epmap"); - auto remote_prefetch = context.Attr("remote_prefetch"); - auto height_sections = - context.Attr>("height_sections"); - auto table_names = context.Attr>("table_names"); - - if (remote_prefetch && !epmap.empty()) { -// if epmap is not empty, then the parameter will be fetched from remote -// parameter server + int64_t padding_idx = context.Attr("padding_idx"); + bool is_test = context.Attr("is_test"); -#ifdef PADDLE_WITH_DISTRIBUTE - operators::distributed::prefetch(id_name, out_name, embedding_name, false, - table_names, epmap, height_sections, - context, context.scope()); -#else - PADDLE_THROW( - "paddle is not compiled with distribute support, can not do " - "parameter prefetch!"); -#endif - } else { - int64_t padding_idx = context.Attr("padding_idx"); - int64_t *ids = const_cast(ids_t->data()); - int64_t ids_numel = ids_t->numel(); + int64_t *ids = const_cast(ids_t->data()); + int64_t ids_numel = ids_t->numel(); - if (table_var->IsType()) { - auto *table_t = context.Input("W"); - int64_t row_number = table_t->dims()[0]; - int64_t row_width = table_t->dims()[1]; + if (table_var->IsType()) { + auto *table_t = context.Input("W"); + int64_t row_number = table_t->dims()[0]; + int64_t row_width = table_t->dims()[1]; - auto *table = table_t->data(); - auto *output = output_t->mutable_data(context.GetPlace()); + auto *table = table_t->data(); + auto *output = output_t->mutable_data(context.GetPlace()); - for (int64_t i = 0; i < ids_numel; ++i) { - if (padding_idx != kNoPadding && ids[i] == padding_idx) { - memset(output + i * row_width, 0, row_width * sizeof(T)); - } else { - PADDLE_ENFORCE_LT( - ids[i], row_number, - platform::errors::InvalidArgument( - "Variable value (input) of OP(fluid.layers.embedding) " - "expected >= 0 and < %ld, but got %ld. Please check input " - "value.", - row_number, ids[i])); - PADDLE_ENFORCE_GE( - ids[i], 0, - platform::errors::InvalidArgument( - "Variable value (input) of OP(fluid.layers.embedding) " - "expected >= 0 and < %ld, but got %ld. Please check input " - "value.", - row_number, ids[i])); - memcpy(output + i * row_width, table + ids[i] * row_width, - row_width * sizeof(T)); - } + for (int64_t i = 0; i < ids_numel; ++i) { + if (padding_idx != kNoPadding && ids[i] == padding_idx) { + memset(output + i * row_width, 0, row_width * sizeof(T)); + } else { + PADDLE_ENFORCE_LT( + ids[i], row_number, + platform::errors::InvalidArgument( + "Variable value (input) of OP(fluid.layers.embedding) " + "expected >= 0 and < %ld, but got %ld. Please check input " + "value.", + row_number, ids[i])); + PADDLE_ENFORCE_GE( + ids[i], 0, + platform::errors::InvalidArgument( + "Variable value (input) of OP(fluid.layers.embedding) " + "expected >= 0 and < %ld, but got %ld. Please check input " + "value.", + row_number, ids[i])); + memcpy(output + i * row_width, table + ids[i] * row_width, + row_width * sizeof(T)); } - } else if (table_var->IsType()) { - const auto &table_t = table_var->Get(); - int64_t row_width = table_t.value().dims()[1]; - const auto *table = table_t.value().data(); - auto *output = output_t->mutable_data(context.GetPlace()); - auto input_data_type = table_t.value().type(); - for (int64_t i = 0; i < ids_numel; ++i) { - if (padding_idx != kNoPadding && ids[i] == padding_idx) { - memset(output + i * row_width, 0, row_width * sizeof(T)); + } + + } else if (table_var->IsType()) { + const auto &table_t = table_var->Get(); + int64_t row_width = table_t.value().dims()[1]; + const auto *table = table_t.value().data(); + auto *output = output_t->mutable_data(context.GetPlace()); + auto input_data_type = table_t.value().type(); + for (int64_t i = 0; i < ids_numel; ++i) { + if (padding_idx != kNoPadding && ids[i] == padding_idx) { + memset(output + i * row_width, 0, row_width * sizeof(T)); + } else { + PADDLE_ENFORCE_GE( + ids[i], 0, + platform::errors::InvalidArgument( + "Variable value (input) of OP(fluid.layers.embedding) " + "expected >= 0. But received %ld", + ids[i])); + if (is_test) { + auto id_index = table_t.GetIndexFromId(ids[i]); + + if (id_index != -1) { + if (input_data_type == framework::proto::VarType::INT8) { + memcpy(output + i * row_width, table + id_index * row_width, + row_width * sizeof(T)); + } else { + auto blas = + math::GetBlas(context); + blas.VCOPY(row_width, table + id_index * row_width, + output + i * row_width); + } + } else { + memset(output + i * row_width, 0, row_width * sizeof(T)); + } } else { + auto id_index = table_t.Index(ids[i]); PADDLE_ENFORCE_GE( ids[i], 0, platform::errors::InvalidArgument( "Variable value (input) of OP(fluid.layers.embedding) " "expected >= 0. But received %ld", ids[i])); - auto id_index = table_t.Index(ids[i]); PADDLE_ENFORCE_GE( id_index, 0, platform::errors::InvalidArgument( "the input key should be exists. But received %d.", id_index)); + if (input_data_type == framework::proto::VarType::INT8) { memcpy(output + i * row_width, table + id_index * row_width, row_width * sizeof(T)); @@ -177,36 +183,23 @@ class LookupTableGradKernel : public framework::OpKernel { auto *d_table_value = d_table->mutable_value(); d_table_value->Resize({ids_num, table_dim[1]}); - // FIXME(minqiyang): - // memory optimization will NOT reuse Tensor with SelectedRows - // so we could just share the tensor here directly. - // However, the InferVarType method will infer the output SelectedRows - // to Tensor sometimes, which is a bug, so we will add an attribute - // here to indicate the inplace and remove this attribute after - // the InferVarType's bug was fixed - bool grad_inplace = context.Attr("grad_inplace"); - if (grad_inplace) { - d_table_value->ShareDataWith(*d_output); - } else { - d_table_value->mutable_data(context.GetPlace()); - - d_table->set_height(table_dim[0]); - - auto *d_output_data = d_output->data(); - auto *d_table_data = d_table_value->data(); - - auto d_output_dims = d_output->dims(); - auto d_output_dims_2d = - framework::flatten_to_2d(d_output_dims, d_output_dims.size() - 1); - PADDLE_ENFORCE_EQ(d_table_value->dims(), d_output_dims_2d, - platform::errors::InvalidArgument( - "ShapeError: The shape of lookup_table@Grad and " - "output@Grad should be same. " - "But received lookup_table@Grad's shape = [%s], " - "output@Grad's shape = [%s].", - d_table_value->dims(), d_output_dims_2d)); - memcpy(d_table_data, d_output_data, sizeof(T) * d_output->numel()); - } + d_table_value->mutable_data(context.GetPlace()); + d_table->set_height(table_dim[0]); + + auto *d_output_data = d_output->data(); + auto *d_table_data = d_table_value->data(); + + auto d_output_dims = d_output->dims(); + auto d_output_dims_2d = + framework::flatten_to_2d(d_output_dims, d_output_dims.size() - 1); + PADDLE_ENFORCE_EQ(d_table_value->dims(), d_output_dims_2d, + platform::errors::InvalidArgument( + "ShapeError: The shape of lookup_table@Grad and " + "output@Grad should be same. " + "But received lookup_table@Grad's shape = [%s], " + "output@Grad's shape = [%s].", + d_table_value->dims(), d_output_dims_2d)); + memcpy(d_table_data, d_output_data, sizeof(T) * d_output->numel()); } else { auto *ids = context.Input("Ids"); auto *d_output = context.Input(framework::GradVarName("Out")); diff --git a/paddle/fluid/operators/lookup_table_v2_op.h b/paddle/fluid/operators/lookup_table_v2_op.h index 19838ceeae8aa788645c658bcd745f3f7325a1d8..9aab90d84796ca5c7f37a818595ce87fb3a554b5 100644 --- a/paddle/fluid/operators/lookup_table_v2_op.h +++ b/paddle/fluid/operators/lookup_table_v2_op.h @@ -52,8 +52,6 @@ class LookupTableV2Kernel : public framework::OpKernel { // for remote prefetch auto epmap = context.Attr>("epmap"); auto remote_prefetch = context.Attr("remote_prefetch"); - auto height_sections = - context.Attr>("height_sections"); auto table_names = context.Attr>("table_names"); if (remote_prefetch && !epmap.empty()) { @@ -62,8 +60,8 @@ class LookupTableV2Kernel : public framework::OpKernel { #ifdef PADDLE_WITH_DISTRIBUTE operators::distributed::prefetch(id_name, out_name, embedding_name, false, - table_names, epmap, height_sections, - context, context.scope()); + table_names, epmap, context, + context.scope()); #else PADDLE_THROW( "paddle is not compiled with distribute support, can not do " diff --git a/paddle/fluid/operators/nce_op.h b/paddle/fluid/operators/nce_op.h index f6f00c1583af439fb2bbbb43c4dd34c05325f531..1c75424fae7ef3efe3720de7d8e0303661d805ca 100644 --- a/paddle/fluid/operators/nce_op.h +++ b/paddle/fluid/operators/nce_op.h @@ -195,8 +195,6 @@ class NCEKernel : public framework::OpKernel { framework::Scope &local_scope = context.scope().NewScope(); - auto height_sections = - context.Attr>("height_sections"); auto table_names = context.Attr>("table_names"); auto *ids = local_scope.Var("Ids@Prefetch"); @@ -220,7 +218,7 @@ class NCEKernel : public framework::OpKernel { auto weight = context.InputNames("Weight").front(); operators::distributed::prefetch("Ids@Prefetch", "Weight@Prefetch", weight, false, table_names, epmap, - height_sections, context, local_scope); + context, local_scope); #else PADDLE_THROW( "paddle is not compiled with distribute support, can not do " diff --git a/paddle/fluid/operators/save_op.h b/paddle/fluid/operators/save_op.h index 62ccf0c17d352e270a90bc1ca16f8104cec1084c..fbde722a425bc3ad39d7070d6ba399f04bd7a746 100644 --- a/paddle/fluid/operators/save_op.h +++ b/paddle/fluid/operators/save_op.h @@ -1,11 +1,8 @@ /* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved. - Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at - http://www.apache.org/licenses/LICENSE-2.0 - 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. @@ -45,10 +42,23 @@ class SaveOpKernel : public framework::OpKernel { input_var, platform::errors::InvalidArgument( "The variable %s to be saved cannot be found.", iname)); + auto filename = ctx.Attr("file_path"); + auto overwrite = ctx.Attr("overwrite"); + + VLOG(4) << "save output file_path: " << filename; + + PADDLE_ENFORCE_EQ( + FileExists(filename) && !overwrite, false, + platform::errors::PreconditionNotMet( + "%s exists!, cannot save to it when overwrite is set to false.", + filename, overwrite)); + + MkDirRecursively(DirName(filename).c_str()); + if (input_var->IsType()) { - SaveLodTensor(ctx, place, input_var); + SaveLodTensor(ctx, place, input_var, filename); } else if (input_var->IsType()) { - SaveSelectedRows(ctx, place, input_var); + SaveSelectedRows(ctx, place, input_var, filename); } else { PADDLE_THROW(platform::errors::InvalidArgument( "Save operator only supports saving LoDTensor and SelectedRows " @@ -59,18 +69,8 @@ class SaveOpKernel : public framework::OpKernel { void SaveLodTensor(const framework::ExecutionContext &ctx, const platform::Place &place, - const framework::Variable *var) const { - auto filename = ctx.Attr("file_path"); - auto overwrite = ctx.Attr("overwrite"); - - PADDLE_ENFORCE_EQ( - FileExists(filename) && !overwrite, false, - platform::errors::PreconditionNotMet( - "%s exists!, cannot save to it when overwrite is set to false.", - filename, overwrite)); - - MkDirRecursively(DirName(filename).c_str()); - + const framework::Variable *var, + const std::string &filename) const { auto &tensor = var->Get(); // get device context from pool @@ -104,32 +104,8 @@ class SaveOpKernel : public framework::OpKernel { void SaveSelectedRows(const framework::ExecutionContext &ctx, const platform::Place &place, - const framework::Variable *var) const { - auto file_path = ctx.Attr("file_path"); - auto overwrite = ctx.Attr("overwrite"); - - std::string filename = file_path; - VLOG(4) << "SaveSelectedRows output file_path: " << file_path; - - framework::Variable *out_put_var = ctx.scope().FindVar(LOOKUP_TABLE_PATH); - if (out_put_var != nullptr) { - auto *lt_var = out_put_var->GetMutable(); - if (lt_var->length() > 0) { - VLOG(4) << "SaveSelectedRows output var name: " << *lt_var; - filename = *lt_var; - } - } - - PADDLE_ENFORCE_EQ( - FileExists(filename) && !overwrite, false, - platform::errors::PreconditionNotMet( - "%s exists!, cannot save to it when overwrite is set to false.", - filename, overwrite)); - - VLOG(4) << "SaveSelectedRows get File name: " << filename; - - MkDirRecursively(DirName(filename).c_str()); - + const framework::Variable *var, + const std::string &filename) const { auto &selectedRows = var->Get(); // get device context from pool diff --git a/paddle/fluid/pybind/communicator_py.cc b/paddle/fluid/pybind/communicator_py.cc index b2947321da2928c5667e67086f07e7d48d8c751a..6ac37a85c282280701f0aa232e94180eddaa7219 100644 --- a/paddle/fluid/pybind/communicator_py.cc +++ b/paddle/fluid/pybind/communicator_py.cc @@ -23,6 +23,8 @@ limitations under the License. */ #include "pybind11/pybind11.h" #include "paddle/fluid/operators/distributed/communicator.h" +#include "paddle/fluid/operators/distributed/communicator_common.h" +#include "paddle/fluid/operators/distributed/large_scale_kv.h" namespace py = pybind11; @@ -30,41 +32,88 @@ using paddle::framework::ProgramDesc; using paddle::framework::Scope; using paddle::operators::distributed::AsyncCommunicator; using paddle::operators::distributed::Communicator; -using paddle::operators::distributed::GeoSgdCommunicator; +using paddle::operators::distributed::GeoCommunicator; using paddle::operators::distributed::HalfAsyncCommunicator; using paddle::operators::distributed::SyncCommunicator; +using paddle::operators::distributed::CommContext; +using paddle::operators::distributed::RpcCtxMap; + +using paddle::operators::distributed::LargeScaleKV; + namespace paddle { namespace pybind { +void BindCommunicatorContext(py::module* m) { + py::class_(*m, "CommContext") + .def( + py::init&, + const std::vector&, const std::vector&, + const std::vector&, int, bool, bool, bool>()) + .def("var_name", [](const CommContext& self) { return self.var_name; }) + .def("trainer_id", + [](const CommContext& self) { return self.trainer_id; }) + .def("split_varnames", + [](const CommContext& self) { return self.splited_varnames; }) + .def("split_endpoints", + [](const CommContext& self) { return self.epmap; }) + .def("sections", + [](const CommContext& self) { return self.height_sections; }) + .def("aggregate", [](const CommContext& self) { return self.merge_add; }) + .def("is_sparse", [](const CommContext& self) { return self.is_sparse; }) + .def("is_distributed", + [](const CommContext& self) { return self.is_distributed; }) + .def("origin_varnames", + [](const CommContext& self) { return self.origin_varnames; }) + .def("__str__", [](const CommContext& self) { return self.print(); }); +} + void BindCommunicator(py::module* m) { // Communicator is already used by nccl, change to DistCommunicator py::class_>(*m, "DistCommunicator") - .def(py::init([](const std::string& mode, const ProgramDesc& program, - Scope* param_scope, + .def(py::init([](const std::string& mode, const RpcCtxMap& send_ctx, + const RpcCtxMap& recv_ctx, Scope* param_scope, std::map& envs) { if (mode == "HALF_ASYNC") { - Communicator::InitInstance(program, + Communicator::InitInstance(send_ctx, recv_ctx, param_scope, envs); } else if (mode == "ASYNC") { - Communicator::InitInstance(program, param_scope, - envs); - } else if (mode == "GEO") { - Communicator::InitInstance(program, param_scope, - envs); + Communicator::InitInstance(send_ctx, recv_ctx, + param_scope, envs); } else if (mode == "SYNC") { - Communicator::InitInstance(program, param_scope, - envs); + Communicator::InitInstance(send_ctx, recv_ctx, + param_scope, envs); + } else if (mode == "GEO") { + Communicator::InitInstance(send_ctx, recv_ctx, + param_scope, envs); } else { PADDLE_THROW(platform::errors::InvalidArgument( "unsuported communicator MODE")); } + return Communicator::GetInstantcePtr(); })) .def("stop", &Communicator::Stop) .def("start", &Communicator::Start) - .def("is_running", &Communicator::IsRunning); + .def("is_running", &Communicator::IsRunning) + .def("recv", &Communicator::RecvNoBarrier); +} + +void BindLargeScaleKV(py::module* m) { + py::class_>(*m, "LargeScaleKV") + .def(py::init([]() { return LargeScaleKV::GetInstantcePtr(); })) + .def("load", + [](LargeScaleKV& self, const std::string& table_name, + const std::string& dir) { + auto* sparse_variable = self.Get(table_name); + sparse_variable->Load(dir); + }) + .def("save", [](LargeScaleKV& self, const std::string& table_name, + const std::string& dir) { + auto* sparse_variable = self.Get(table_name); + sparse_variable->Save(dir); + }); } } // namespace pybind } // namespace paddle diff --git a/paddle/fluid/pybind/communicator_py.h b/paddle/fluid/pybind/communicator_py.h index 0250341db4f575a9b471715b51405306103b5c43..7fee6e745269bc22b095bf15711d9ddc40a73b5e 100644 --- a/paddle/fluid/pybind/communicator_py.h +++ b/paddle/fluid/pybind/communicator_py.h @@ -26,6 +26,8 @@ namespace paddle { namespace pybind { void BindCommunicator(pybind11::module* m); +void BindCommunicatorContext(pybind11::module* m); +void BindLargeScaleKV(pybind11::module* m); } // namespace pybind } // namespace paddle diff --git a/paddle/fluid/pybind/pybind.cc b/paddle/fluid/pybind/pybind.cc index 79ee871ee882d864fd41363c733b2bc09d4cebf9..d58c36dd8f20e35fe4a564bd7e119c17f1296ba2 100644 --- a/paddle/fluid/pybind/pybind.cc +++ b/paddle/fluid/pybind/pybind.cc @@ -2496,6 +2496,8 @@ All parameter, weight, gradient are variables in Paddle. #endif #ifdef PADDLE_WITH_DISTRIBUTE BindCommunicator(&m); + BindCommunicatorContext(&m); + BindLargeScaleKV(&m); #endif } } // namespace pybind diff --git a/python/paddle/fleet/meta_optimizers/graph_execution_optimizer.py b/python/paddle/fleet/meta_optimizers/graph_execution_optimizer.py index 7a943b6531fd2d8a1802e6552a7f255297e51765..fc6c8e287d4703213db0139b2b22442a79bbd4a6 100644 --- a/python/paddle/fleet/meta_optimizers/graph_execution_optimizer.py +++ b/python/paddle/fleet/meta_optimizers/graph_execution_optimizer.py @@ -50,6 +50,7 @@ class GraphExecutionOptimizer(MetaOptimizerBase): # should fix the variable def _setup_nccl_op(self, startup_program, main_program, build_strategy): trainer_endpoints = self.role_maker.get_trainer_endpoints() + trainers = trainer_endpoints trainer_id = self.role_maker.worker_index() current_endpoint = self.role_maker.get_trainer_endpoints()[trainer_id] trainer_endpoints_env = ",".join(trainer_endpoints) diff --git a/python/paddle/fleet/metrics/metric.py b/python/paddle/fleet/metrics/metric.py index 83e0dd2e541c3222a25504f906eb15cf2708aae2..152ee21c147b01e549257bf8821c5c656ee81d0d 100644 --- a/python/paddle/fleet/metrics/metric.py +++ b/python/paddle/fleet/metrics/metric.py @@ -17,7 +17,7 @@ import paddle.fluid as fluid import math import numpy as np from paddle.fluid.framework import Variable -from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet as fleet +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet def sum(input, scope=None): diff --git a/python/paddle/fluid/communicator.py b/python/paddle/fluid/communicator.py index 279107db97021a442b96383b2c2c73754f6437b2..814a70a10e06cf5867a9ed9b736a895f50f24a49 100644 --- a/python/paddle/fluid/communicator.py +++ b/python/paddle/fluid/communicator.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. +# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -12,20 +12,34 @@ # See the License for the specific language governing permissions and # limitations under the License. +# Copyright(c) 2019 PaddlePaddle Authors.All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0(the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http: // www.apache.org/licenses/LICENSE-2.0 +# +# 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 .executor import global_scope """ Communicator is used for async distribute training in distribute_transpiler mode. It's a wrapper of a cpp class Communicator and should be used inside fleet API. """ from . import core -from .framework import Program -from .transpiler.distribute_transpiler import DistributedMode +from paddle.fluid.framework import Program +from paddle.fluid.incubate.fleet.parameter_server.mode import DistributedMode -__all__ = ['Communicator'] +__all__ = ['Communicator', 'LargeScaleKV'] class Communicator(object): - def __init__(self, program, mode, kwargs=None, envs={}): + def __init__(self, mode, kwargs=None, envs=None): """ Communicator is used for async distribute training in distribute_transpiler mode. It's a wrapper of a cpp class Communicator and should be used inside fleet API. @@ -48,32 +62,17 @@ class Communicator(object): comm.stop() """ # set all recv op to not_run mode - assert isinstance(program, Program) - for op in program.block(0).ops: - if op.type == "recv": - op._set_attr('do_not_run', True) - - if mode == DistributedMode.GEO: - push_vars = kwargs["push_vars"] - push_var_names = [] - - for k, vs in push_vars.items(): - varnames = "&".join(vs["var_names"]) - sections = "&".join([str(v) for v in vs["sections"]]) - endpoints = "&".join(vs["epmap"]) - is_sparse = "1" if vs["is_sparse"] == ['True'] else "0" - - push_var_names.append(k) - envs[k] = "#".join([varnames, sections, endpoints, is_sparse]) - - envs["geo_trainer_nums"] = str(kwargs["trainers"]) - envs["geo_need_push_nums"] = str(kwargs["push_nums"]) - envs["geo_send_varnames"] = '#'.join(push_var_names) if mode == DistributedMode.SYNC: envs["pserver_endpoints"] = ','.join(kwargs["pserver_endpoints"]) envs["trainer_id"] = str(kwargs["trainer_id"]) + if mode == DistributedMode.GEO: + envs["trainers"] = str(kwargs["trainers"]) + envs["sparse_attrs"] = str(kwargs["sparse_attrs"]) + + envs["need_global_step"] = str(kwargs["need_global_step"]) + mode_str = None if mode == DistributedMode.SYNC: @@ -85,8 +84,14 @@ class Communicator(object): elif mode == DistributedMode.GEO: mode_str = "GEO" - self.communicator_ = core.DistCommunicator(mode_str, program.desc, - global_scope(), envs) + self.mode = mode_str + self.envs = envs + self.communicator_ = None + + def init_with_ctx(self, send_ctx, recv_ctx): + self.communicator_ = core.DistCommunicator(self.mode, send_ctx, + recv_ctx, + global_scope(), self.envs) def start(self): """ @@ -143,3 +148,17 @@ class Communicator(object): comm.is_running() """ self.communicator_.is_running() + + def recv(self): + self.communicator_.recv() + + +class LargeScaleKV(object): + def __init__(self): + self.scale_kv = core.LargeScaleKV() + + def save(self, varname, dirname): + self.scale_kv.save(varname, dirname) + + def load(self, varname, dirname): + self.scale_kv.load(varname, dirname) diff --git a/python/paddle/fluid/contrib/layers/nn.py b/python/paddle/fluid/contrib/layers/nn.py index 50e6eaa80c135b24efa3844a6387278cc247af3a..0e187d4174cd5cca65f79e4ab84b4cc32ecefd21 100644 --- a/python/paddle/fluid/contrib/layers/nn.py +++ b/python/paddle/fluid/contrib/layers/nn.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. +# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -11,21 +11,42 @@ # 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. + +# Copyright(c) 2019 PaddlePaddle Authors.All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0(the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http: // www.apache.org/licenses/LICENSE-2.0 +# +# 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. """ Contrib layers just related to the neural network. """ from __future__ import print_function -import numpy as np -import six import os +import six +import warnings import inspect + +import numpy as np + from paddle.fluid.layer_helper import LayerHelper from paddle.fluid.layers import utils from ... import unique_name from paddle.fluid.initializer import Normal, Constant, NumpyArrayInitializer from paddle.fluid.data_feeder import check_variable_and_dtype, check_type, check_dtype, convert_dtype + +from paddle.fluid import core +from paddle.fluid.entry_attr import ProbabilityEntry, CountFilterEntry + from paddle.fluid.framework import Variable, convert_np_dtype_to_dtype_ from paddle.fluid.layers import slice, reshape import warnings @@ -34,8 +55,8 @@ __all__ = [ 'fused_elemwise_activation', 'sequence_topk_avg_pooling', 'var_conv_2d', 'match_matrix_tensor', 'tree_conv', 'fused_embedding_seq_pool', 'multiclass_nms2', 'search_pyramid_hash', 'shuffle_batch', 'partial_concat', - 'partial_sum', 'tdm_child', 'rank_attention', 'tdm_sampler', 'batch_fc', - '_pull_box_extended_sparse', 'bilateral_slice' + 'sparse_embedding', 'partial_sum', 'tdm_child', 'rank_attention', + 'tdm_sampler', 'batch_fc', '_pull_box_extended_sparse', 'bilateral_slice' ] @@ -150,7 +171,8 @@ def var_conv_2d(input, of var_conv2d. If it is set to None or one attribute of ParamAttr, var_conv2d will create ParamAttr as param_attr. If the Initializer of the param_attr is not set, the parameter is initialized with :math:`Normal(0.0, std)`, - and the :math:`std` is :math:`(\\frac{2.0 }{filter\_elem\_num})^{0.5}`. Default: None. + and the :math:`std` is :math:`(\\frac{2.0 }{filter\_elem\_num})^{ + 0.5}`. Default: None. act (str): Activation type, if it is set to None, activation is not appended. Default: None dtype ('float32'): The data type of parameter and output. @@ -386,10 +408,8 @@ def tree_conv(nodes_vector, name=None): """ ${comment} - - Args: - nodes_vector(${nodes_vector_type}): ${nodes_vector_comment} - edge_set(${edge_set_type}): ${edge_set_comment} +Args : nodes_vector(${nodes_vector_type}) : $ { nodes_vector_comment } +edge_set(${edge_set_type}) : $ { edge_set_comment } output_size(int): output feature width num_filters(int): number of filters, Default 1 max_depth(int): max depth of filters, Default 2 @@ -399,12 +419,15 @@ def tree_conv(nodes_vector, name(str): a name of this layer(optional). If set None, the layer will be named automatically, Default None Returns: - out(${out_type}): ${out_comment} + out(${out_type}): ${ + out_comment + } Examples: .. code-block:: python import paddle.fluid as fluid + # 10 for max_node_size of dataset, 5 for vector width nodes_vector = fluid.layers.data( name='vectors', shape=[10, 5], dtype='float32') @@ -415,10 +438,10 @@ def tree_conv(nodes_vector, # the shape of output will be [10, 6, 1], # 10 for max_node_size of dataset, 6 for output size, 1 for 1 filter out_vector = fluid.layers.tree_conv(nodes_vector, edge_set, 6, 1, 2) - # After reshape, output tensor could be nodes_vector for next tree convolution +#After reshape, output tensor could be nodes_vector for next tree convolution out_vector = fluid.layers.reshape(out_vector, shape=[-1, 10, 6]) out_vector_2 = fluid.layers.tree_conv(out_vector, edge_set, 3, 4, 2) - # also output tensor could be pooling(the pooling in paper called global pooling) +#also output tensor could be pooling(the pooling in paper called global pooling) pooled = fluid.layers.reduce_max(out_vector, dim=2) # global pooling """ check_type(nodes_vector, 'nodes_vector', (Variable), 'tree_conv') @@ -627,7 +650,6 @@ def multiclass_nms2(bboxes, 'score_threshold': score_threshold, 'nms_top_k': nms_top_k, 'nms_threshold': nms_threshold, - 'nms_eta': nms_eta, 'keep_top_k': keep_top_k, 'nms_eta': nms_eta, 'normalized': normalized @@ -939,6 +961,59 @@ def partial_sum(input, start_index=0, length=-1): return out +def sparse_embedding(input, + size, + padding_idx=None, + is_test=False, + entry=None, + param_attr=None, + dtype='float32'): + helper = LayerHelper('sparse_embedding', **locals()) + + check_variable_and_dtype(input, 'input', ['int64'], + 'fluid.contrib.layers.sparse_embedding') + + check_dtype(dtype, 'dtype', ['float32'], + 'fluid.contrib.layers.sparse_embedding') + + w = helper.create_parameter( + attr=helper.param_attr, + shape=size, + type=core.VarDesc.VarType.SELECTED_ROWS, + dtype=dtype, + is_bias=False) + + tmp = helper.create_variable_for_type_inference(dtype) + + padding_idx = -1 if padding_idx is None else padding_idx if padding_idx >= 0 else ( + size[0] + padding_idx) + + entry_str = "none" + + if entry is not None: + if not isinstance(entry, ProbabilityEntry) and not isinstance( + entry, CountFilterEntry): + raise ValueError( + "entry must be instance in [ProbabilityEntry, CountFilterEntry]") + entry_str = entry.to_attr() + + helper.append_op( + type='lookup_table', + inputs={'Ids': input, + 'W': w}, + outputs={'Out': tmp}, + attrs={ + 'padding_idx': padding_idx, + 'is_sparse': True, + 'is_distributed': True, + 'remote_prefetch': True, + 'is_test': is_test, + 'entry': entry_str + }) + + return tmp + + def tdm_child(x, node_nums, child_nums, param_attr=None, dtype='int32'): """ **Tdm Child** diff --git a/python/paddle/fluid/device_worker.py b/python/paddle/fluid/device_worker.py index 72e0351ec36c028593eb8f099a4e39aa314aac37..3831dee2964992f1cc035502cef12ac4967e0a72 100644 --- a/python/paddle/fluid/device_worker.py +++ b/python/paddle/fluid/device_worker.py @@ -15,8 +15,6 @@ from __future__ import print_function -from paddle.fluid.incubate.fleet.parameter_server import version - __all__ = [ 'DeviceWorker', 'Hogwild', 'DownpourSGD', 'Section', 'DownpourSGDOPT' ] @@ -105,6 +103,8 @@ class Hogwild(DeviceWorker): if not opt_info: return + from paddle.fluid.incubate.fleet.parameter_server import version + if version.is_transpiler() and "fleet_desc" not in opt_info: return diff --git a/python/paddle/fluid/distributed/ps_instance.py b/python/paddle/fluid/distributed/ps_instance.py index e89a1b71dd5ee625b4a07ee5c2b98f65f774047f..61b2bcad01d5b1e43a8f5c47747ced0440c87d1e 100644 --- a/python/paddle/fluid/distributed/ps_instance.py +++ b/python/paddle/fluid/distributed/ps_instance.py @@ -66,7 +66,7 @@ class PaddlePSInstance(object): self._comm = self.dh.comm.Split(self._node_type) pass - def get_worker_index(self): + def get_worker_id(self): """ Return worker index """ @@ -75,7 +75,7 @@ class PaddlePSInstance(object): else: return self._rankid / self._proc_per_node - def get_server_index(self): + def get_server_id(self): """ Return server index """ @@ -100,7 +100,7 @@ class PaddlePSInstance(object): """ Return instance is first worker or not """ - return self.is_worker() and 0 == self.get_worker_index() + return self.is_worker() and 0 == self.get_worker_id() def set_ip(self, ip): """ diff --git a/python/paddle/fluid/entry_attr.py b/python/paddle/fluid/entry_attr.py new file mode 100644 index 0000000000000000000000000000000000000000..c0999765488bd62b00233c078750a6c6d65b0752 --- /dev/null +++ b/python/paddle/fluid/entry_attr.py @@ -0,0 +1,74 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +__all__ = ['ProbabilityEntry', 'CountFilterEntry'] + + +class EntryAttr(object): + """ + Examples: + .. code-block:: python + + import paddle.fluid as fluid + """ + + def __init__(self): + self._name = None + + def to_attr(self): + """ + Returns the attributes of this parameter. + + Returns: + Parameter attributes(map): The attributes of this parameter. + """ + raise NotImplementedError("EntryAttr is base class") + + +class ProbabilityEntry(EntryAttr): + def __init__(self, probability): + super(EntryAttr, self).__init__() + + if not isinstance(probability, float): + raise ValueError("probability must be a float in (0,1)") + + if probability <= 0 or probability >= 1: + raise ValueError("probability must be a float in (0,1)") + + self._name = "probability_entry" + self._probability = probability + + def to_attr(self): + return ":".join([self._name, str(self._probability)]) + + +class CountFilterEntry(EntryAttr): + def __init__(self, count_filter): + super(EntryAttr, self).__init__() + + if not isinstance(count_filter, int): + raise ValueError( + "count_filter must be a valid integer greater than 0") + + if count_filter < 0: + raise ValueError( + "count_filter must be a valid integer greater or equal than 0") + + self._name = "count_filter_entry" + self._count_filter = count_filter + + def to_attr(self): + return ":".join([self._name, str(self._count_filter)]) diff --git a/python/paddle/fluid/framework.py b/python/paddle/fluid/framework.py index 8e6aa43e1ad7a8cb3725cb8dfc056942a6824433..1c28ecd3a8f5e477f722badbbb6fe69de2036723 100644 --- a/python/paddle/fluid/framework.py +++ b/python/paddle/fluid/framework.py @@ -2978,7 +2978,8 @@ class Block(object): shape=v.shape, dtype=v.dtype, type=v.type, - lod_level=v.lod_level, + lod_level=v.lod_level + if v.type == core.VarDesc.VarType.LOD_TENSOR else None, stop_gradient=p.stop_gradient, trainable=p.trainable, optimize_attr=p.optimize_attr, diff --git a/python/paddle/fluid/incubate/fleet/base/fleet_base.py b/python/paddle/fluid/incubate/fleet/base/fleet_base.py index b2899067d8833fbfa0ecf38a2d7728b3d1589323..26085ec846512eefd3df962c88e56228daf34784 100644 --- a/python/paddle/fluid/incubate/fleet/base/fleet_base.py +++ b/python/paddle/fluid/incubate/fleet/base/fleet_base.py @@ -21,12 +21,19 @@ from paddle.fluid.executor import Executor from paddle.fluid.optimizer import SGD from paddle.fluid.incubate.fleet.base.mode import Mode -from paddle.fluid.incubate.fleet.base.role_maker import MPISymetricRoleMaker from paddle.fluid.incubate.fleet.base.role_maker import RoleMakerBase -from paddle.fluid.incubate.fleet.base.role_maker import UserDefinedRoleMaker from paddle.fluid.contrib.mixed_precision.decorator import OptimizerWithMixedPrecision from . import mode + +class Mode: + """ + There are various mode for fleet, each of them is designed for different model. + """ + PS = 1 + COLLECTIVE = 2 + + __all__ = ['Fleet', 'DistributedOptimizer'] __all__ += mode.__all__ @@ -219,7 +226,7 @@ class Fleet(object): pass @abc.abstractmethod - def init_server(self, model_dir=None): + def init_server(self, model_dir=None, **kwargs): pass @abc.abstractmethod diff --git a/python/paddle/fluid/incubate/fleet/base/role_maker.py b/python/paddle/fluid/incubate/fleet/base/role_maker.py index b9cd73d158497eac08a1b3988783b60f0cdfb8f2..8596bd05a8685f6c4feccdeecd295fd10abb09c9 100644 --- a/python/paddle/fluid/incubate/fleet/base/role_maker.py +++ b/python/paddle/fluid/incubate/fleet/base/role_maker.py @@ -110,6 +110,9 @@ class RoleMakerBase(object): """ raise NotImplementedError("Please implement this method in child class") + def role_id(self): + return self.worker_index() if self.is_worker() else self.server_index() + def worker_index(self): """ Get current worker id. diff --git a/python/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/__init__.py b/python/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/__init__.py index 667ad0a2ed014c87042dd3dfe7885b2670e1c764..5bc06f9303cd0fc76e5359c1551748f883cf8037 100644 --- a/python/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/__init__.py +++ b/python/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/__init__.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. +# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -11,14 +11,16 @@ # 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. - -import os -import warnings """ Convert the fluid program to distributed data-parallelism programs. """ -import paddle.fluid.io as io -from paddle.fluid.communicator import Communicator + +import os +import sys +import warnings + +from paddle import fluid +from paddle.fluid import core from paddle.fluid.framework import default_main_program from paddle.fluid.framework import default_startup_program from paddle.fluid.framework import Program @@ -27,32 +29,67 @@ from paddle.fluid.executor import Executor from paddle.fluid.parallel_executor import ParallelExecutor from paddle.fluid.optimizer import Optimizer -from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import TrainerRuntimeConfig, DistributedStrategy, SyncStrategy, AsyncStrategy, HalfAsyncStrategy, GeoStrategy, StrategyFactory +from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig -from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspiler as OriginTranspiler -from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig, ServerRuntimeConfig, DistributedMode - -from paddle.fluid.incubate.fleet.base.fleet_base import DistributedOptimizer from paddle.fluid.incubate.fleet.base.fleet_base import Fleet -from paddle.fluid.incubate.fleet.base.fleet_base import Mode +from paddle.fluid.incubate.fleet.base.mode import Mode from paddle.fluid.incubate.fleet.base.role_maker import MPISymetricRoleMaker +from paddle.fluid.incubate.fleet.parameter_server import version +from paddle.fluid.incubate.fleet.parameter_server.ir.public import get_sparse_tablenames +from paddle.fluid.incubate.fleet.parameter_server.ir.public import _get_lr_ops +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import TrainerRuntimeConfig, DistributedStrategy, \ + SyncStrategy, AsyncStrategy, HalfAsyncStrategy, GeoStrategy, StrategyFactory -class DistributedTranspiler(Fleet): +from paddle.fluid.transpiler.details.checkport import wait_server_ready + +from paddle.fluid.incubate.fleet.parameter_server.mode import PSMode +from paddle.fluid.incubate.fleet.base.fleet_base import DistributedOptimizer + +from paddle.fluid.incubate.fleet.parameter_server.ir import trainer_pass as worker +from paddle.fluid.incubate.fleet.parameter_server.ir import pserver_pass as server +from paddle.fluid.incubate.fleet.parameter_server.ir import public as public + + +class FleetTranspiler(Fleet): """ A subclass for compatibility with fluid.transpiler.DistributeTranspiler. """ def __init__(self): - super(DistributedTranspiler, self).__init__(Mode.TRANSPILER) - self._transpile_config = None + super(FleetTranspiler, self).__init__(Mode.TRANSPILER) + + self._inner_mode = None + + if version.is_transpiler(): + self._inner_mode = PSMode.TRANSPILER + else: + self._inner_mode = PSMode.PSLIB + + self._strategy = None self._transpiler = None - self._origin_program = None + self._origin_main_program = None + self._origin_startup_program = None + self._communicator = None self.startup_program = None self.main_program = None - self._communicator = None - def init_worker(self): + self._opt_info = None + self._local_ip = 0 + self._fleet_ptr = None + self._main_programs = [] + self._scopes = [] + self._client2client_request_timeout_ms = 500000 + self._client2client_connect_timeout_ms = 10000 + self._client2client_max_retry = 3 + + def init(self, role_maker=None): + if role_maker is None: + role_maker = MPISymetricRoleMaker() + super(FleetTranspiler, self).init(role_maker) + self._fleet_ptr = core.Fleet() + + def _init_transpiler_worker(self): """ `init_worker` has many many functions to do before training, first, wait for all parameter servers launch completely. @@ -62,70 +99,128 @@ class DistributedTranspiler(Fleet): Returns: None """ + + def sync_strategy_envs(): + kwargs = {} + kwargs[ + "pserver_endpoints"] = self._role_maker.get_pserver_endpoints() + kwargs["trainer_id"] = self._role_maker.worker_index() + return kwargs + + def geo_strategy_envs(): + def get_sparse_attrs(): + opt_init_map = {} + opt_init_map["gaussian_random"] = ["seed", "mean", "std"] + opt_init_map["fill_constant"] = ["value"] + opt_init_map["uniform_random"] = ["seed", "min", "max"] + opt_init_map[ + "truncated_gaussian_random"] = ["seed", "mean", "std"] + + dist_varnames = get_sparse_tablenames(self._origin_main_program, + True) + sparse_varnames = get_sparse_tablenames( + self._origin_main_program, False) + + if len(dist_varnames) != 0: + raise ValueError( + "GeoStrategy can not support large scale embeding now, please use fluid.layers.embedding" + ) + + init_attrs = [] + for value_name in sparse_varnames: + value_var = self._origin_main_program.global_block().vars[ + value_name] + value_attr = [ + value_name, + ",".join([str(dim) for dim in value_var.shape]) + ] + for op in self._origin_startup_program.global_block().ops: + if op.type in opt_init_map.keys( + ) and value_name == op.output("Out")[0]: + init_attr = [op.type] + for attr in opt_init_map[op.type]: + init_attr.append(str(op.attr(attr))) + value_attr.append("&".join(init_attr)) + init_attrs.append(":".join(value_attr)) + break + return "#".join(init_attrs) + + kwargs = {} + kwargs["trainers"] = self.worker_num() + kwargs["sparse_attrs"] = get_sparse_attrs() + return kwargs + # if MPISymetricRoleMaker is defined # we suppose a user wants to submit job on mpi cluster + if isinstance(self._role_maker, MPISymetricRoleMaker): # check whether server has been initialized - from paddle.fluid.transpiler.details.checkport import wait_server_ready - wait_server_ready(fleet.server_endpoints(to_string=False)) + wait_server_ready(self.server_endpoints(to_string=False)) - program_config = self._transpile_config.get_program_config() - trainer_communicator_config = self._transpile_config.get_trainer_runtime_config( - ) + trainer_config = self._strategy.get_trainer_runtime_config() - print(trainer_communicator_config) + print(trainer_config) - if isinstance(self._transpile_config, GeoStrategy): - kwargs = {} - kwargs["push_vars"] = self.vars_info - kwargs["trainers"] = fleet.worker_num() - kwargs["push_nums"] = self._transpile_config.get_program_config( - ).geo_sgd_need_push_nums - - self._communicator = Communicator( - self.main_program, DistributedMode.GEO, kwargs, - trainer_communicator_config.get_communicator_flags()) - - elif isinstance(self._transpile_config, AsyncStrategy): - self._communicator = Communicator( - self.main_program, DistributedMode.ASYNC, None, - trainer_communicator_config.get_communicator_flags()) - - elif isinstance(self._transpile_config, HalfAsyncStrategy): - self._communicator = Communicator( - self.main_program, DistributedMode.HALF_ASYNC, None, - trainer_communicator_config.get_communicator_flags()) - - elif isinstance(self._transpile_config, SyncStrategy): - kwargs = {} - kwargs[ - "pserver_endpoints"] = self._role_maker.get_pserver_endpoints() - kwargs["trainer_id"] = self._role_maker.worker_index() + lrs = _get_lr_ops(self._origin_main_program) - self._communicator = Communicator( - self.main_program, DistributedMode.SYNC, kwargs, - trainer_communicator_config.get_communicator_flags()) + if len(lrs) > 0: + kwargs = {"need_global_step": "1"} + else: + kwargs = {"need_global_step": "0"} + if isinstance(self._strategy, GeoStrategy): + geo_kwargs = geo_strategy_envs() + kwargs.update(geo_kwargs) + if isinstance(self._strategy, SyncStrategy): + sync_kwargs = sync_strategy_envs() + kwargs.update(sync_kwargs) + + kwargs = kwargs if kwargs else None + + send_ctx = fleet.compiled_config.get_communicator_send_context() + + if self.compiled_config.is_geo_mode(): + recv_ctx = fleet.compiled_config.get_communicator_recv_context( + recv_type=4) else: - raise TypeError("Training MODE do not supported") + recv_ctx = fleet.compiled_config.get_communicator_recv_context( + recv_type=1) + + for name, ctx in send_ctx.items(): + print("name: {}, ctx: {}".format(name, ctx)) + + print("==== = ==== =============== ====") + + for name, ctx in recv_ctx.items(): + print("name: {}, ctx: {}".format(name, ctx)) + + from paddle.fluid.communicator import Communicator + self._communicator = Communicator( + trainer_config.mode, kwargs, + trainer_config.get_communicator_flags()) + self._communicator.init_with_ctx(send_ctx, recv_ctx) if not self._communicator.is_running(): self._communicator.start() else: warnings.warn("communicator has been initialized, skip") - def init_server(self, model_dir=None): + def init_worker(self): """ - `init_server` has many many functions to do before start pserver, - first, run executor to initialize startup program, - second, if the `model_dir` is not empty, it will load parameters from it for increment training. - - Args: - model_dir(str): The directory path. + `init_worker` has many many functions to do before training, + first, wait for all parameter servers launch completely. + second, run executor to initialize startup program + third, wait for all worker initialize completely. Returns: None """ + if self._inner_mode == PSMode.TRANSPILER: + self._init_transpiler_worker() + else: + raise NotImplementedError("add implement later") + + def _init_transpiler_server(self, model_dir=None): if not self.startup_program: raise ValueError( "startup_program is None, need invoke DistributedOptimizer.minimize first" @@ -137,7 +232,46 @@ class DistributedTranspiler(Fleet): if not os.path.isdir(model_dir): raise ValueError("There is no directory named '%s'", model_dir) - io.load_persistables(self._executor, model_dir, self.main_program) + sparse_varnames = self.compiled_config.get_sparse_varname_on_ps( + True) + distribtued_varnames = self.compiled_config.get_sparse_varname_on_ps( + False) + + remaining_vars = list( + filter( + FleetTranspiler.__exclude_vars(sparse_varnames + + distribtued_varnames), + self.main_program.list_vars())) + + fluid.io.load_vars( + self._executor, + main_program=self.main_program, + dirname=model_dir, + vars=remaining_vars) + + self._load_sparse_params( + dirname=model_dir, varnames=sparse_varnames) + + # todo(tangwei12) load distributed vars + # self._load_sparse_params(dirname=model_dir, varnames=distribtued_varnames) + + def init_server(self, model_dir=None, **kwargs): + """ + `init_server` has many many functions to do before start pserver, + first, run executor to initialize startup program, + second, if the `model_dir` is not empty, it will load parameters from it for increment training. + + Args: + model_dir(str): The directory path. + + Returns: + None + """ + + if self._inner_mode == PSMode.TRANSPILER: + self._init_transpiler_server(model_dir) + else: + raise NotImplementedError("add implement later") def run_server(self): """ @@ -146,12 +280,16 @@ class DistributedTranspiler(Fleet): Returns: None """ - if not self.main_program: - raise ValueError( - "main_program is None, need invoke DistributedOptimizer.minimize first" - ) - self._executor.run(self.main_program) + if self._inner_mode == PSMode.TRANSPILER: + if not self.main_program: + raise ValueError( + "main_program is None, need invoke DistributedOptimizer.minimize first" + ) + + self._executor.run(self.main_program) + else: + raise NotImplementedError("add implement later") def stop_worker(self): """ @@ -164,10 +302,13 @@ class DistributedTranspiler(Fleet): None """ - self._communicator.stop() - if isinstance(self._role_maker, MPISymetricRoleMaker): - self._role_maker._finalize() - self._executor.close() + if self._inner_mode == PSMode.TRANSPILER: + self._communicator.stop() + if isinstance(self._role_maker, MPISymetricRoleMaker): + self._role_maker._finalize() + self._executor.close() + else: + raise NotImplementedError("add implement later") def distributed_optimizer(self, optimizer, strategy=None): """ @@ -186,11 +327,45 @@ class DistributedTranspiler(Fleet): if not isinstance(optimizer, Optimizer): raise ValueError("optimizer must be an instance of Optimizer") - if not fleet._is_initialized: + if not self._is_initialized: raise ValueError( - "use fleet.init(role) to initialize the role of current node before optimizer.minimize(loss)" + "fleet.init(role) to initialize before optimizer.minimize(loss)") + + if not strategy: + _strategy = StrategyFactory.create_async_strategy() + + if isinstance(strategy, DistributedStrategy): + _strategy = strategy + elif isinstance(strategy, DistributeTranspilerConfig): + if strategy.sync_mode: + _strategy = SyncStrategy() + else: + if strategy.runtime_split_send_recv: + if strategy.geo_sgd_mode: + _strategy = GeoStrategy(strategy.geo_sgd_need_push_nums) + elif strategy.half_async: + _strategy = HalfAsyncStrategy() + else: + _strategy = AsyncStrategy() + else: + _strategy = HalfAsyncStrategy() + # for half_async compatibility + strategy.half_async = True + strategy.runtime_split_send_recv = True + self._strategy.set_program_config(strategy) + elif isinstance(strategy, dict): + if self._inner_mode != PSMode.PSLIB: + raise TypeError("Dict strategy can only be used at PSLIB Mode") + + _strategy = StrategyFactory.create_async_strategy() + _strategy.set_pslib_runtime_config(strategy) + else: + raise TypeError( + "strategy must be an instance of DistributeTranspilerConfig, DistributedStrategy" ) - self._optimizer = TranspilerOptimizer(optimizer, strategy) + + self._strategy = _strategy + self._optimizer = ParameterServerOptimizer(optimizer, _strategy) return self._optimizer def save_inference_model(self, @@ -204,6 +379,10 @@ class DistributedTranspiler(Fleet): Prune the given `main_program` to build a new program especially for inference, and then save it and all related parameters to given `dirname` by the `executor`. """ + + if self._inner_mode == PSMode.PSLIB: + raise NotImplementedError("add implement later") + if isinstance(executor, ParallelExecutor): raise TypeError( "in fleet.save_inference_model() function, executor must be as Executor type, ParallelExecutor is not allowed" @@ -219,13 +398,14 @@ class DistributedTranspiler(Fleet): raise TypeError( "in fleet.save_inference_model() function, main_program must be as Program type, CompiledProgram is not allowed" ) - io.save_inference_model(dirname, feeded_var_names, target_vars, - executor, main_program, None, None, - export_for_deployment) + fluid.io.save_inference_model(dirname, feeded_var_names, + target_vars, executor, main_program, + None, None, export_for_deployment) else: - io.save_inference_model(dirname, feeded_var_names, target_vars, - executor, self._origin_program, None, None, - export_for_deployment, True) + fluid.io.save_inference_model(dirname, feeded_var_names, + target_vars, executor, + self._origin_main_program, None, None, + export_for_deployment, True) model_basename = "__model__" model_filename = os.path.join(dirname, model_basename) @@ -237,7 +417,235 @@ class DistributedTranspiler(Fleet): program._copy_dist_param_info_from(self.main_program) self.save_persistables(executor, dirname, program) - def save_persistables(self, executor, dirname, main_program=None): + def _load_sparse_params(self, dirname, varnames): + from paddle.fluid.communicator import LargeScaleKV + scale_kv = LargeScaleKV() + for varname in varnames: + origin_varname, _, _ = public._get_varname_parts(varname) + sparse_dir = os.path.join(dirname, origin_varname, varname) + scale_kv.load(varname, sparse_dir) + + def _get_optimizer_status(self, op, param_name): + supported_opts = [ + "sgd", "adam", "adagrad", "adamax", "momentum", "lars_momentum", + "rmsprop", "decayed_adagrad", "ftrl" + ] + + reshaped_val_map = {} + reshaped_val_map["sgd"] = [] + reshaped_val_map["adam"] = ["moment1_0", "moment2_0"] + reshaped_val_map["adagrad"] = ["moment_0"] + reshaped_val_map["adamax"] = ["moment_0", "inf_norm_0"] + reshaped_val_map["momentum"] = ["velocity_0"] + reshaped_val_map["lars_momentum"] = ["velocity_0"] + reshaped_val_map[ + "rmsprop"] = ["momentum_0", "mean_square_0", "mean_grad_0"] + reshaped_val_map["decayed_adagrad"] = ["moment_0"] + reshaped_val_map["ftrl"] = ["squared_0", "linear_0"] + + orishaped_val_map = {} + orishaped_val_map["adam"] = ["beta1_pow_acc_0", "beta2_pow_acc_0"] + orishaped_val_map["adamax"] = ["beta1_pow_acc_0"] + + if op not in supported_opts: + raise ValueError( + "fleet can not support optimizer: {}, only this can be supported: {}". + format(op, supported_opts)) + + reshaped_names = [ + param_name + "_" + val for val in reshaped_val_map[op] + ] + + if op not in orishaped_val_map: + origin_names = [] + else: + origin_names = [ + param_name + "_" + val for val in orishaped_val_map[op] + ] + return reshaped_names, origin_names + + def _get_optimizer_op(self, param_name): + opts = public._get_optimize_ops(self._origin_main_program) + for op in opts: + if "Param" in op.input_names and \ + "LearningRate" in op.input_names and op.input("Param")[0] == param_name: + return op + + def _save_dense_params(self, executor, dirname, context, main_program): + self._communicator.recv() + + prog = Program() + block = prog.global_block() + local_vars = [] + + for name, var_ctx in context.items(): + if len(var_ctx.origin_varnames()) != 1: + raise ValueError("Dense can not support split now.") + + varname = var_ctx.origin_varnames()[0] + local_vars.append(varname) + + optimizer = self._get_optimizer_op(varname) + reshaped_varnames, origin_varnames = self._get_optimizer_status( + optimizer.type, varname) + + for var_name in [varname] + reshaped_varnames + origin_varnames: + var = self._origin_main_program.global_block().vars[var_name] + block.append_op( + type='recv_save', + attrs={ + "trainer_id": self._role_maker.worker_index(), + "shape": var.shape, + "slice_shapes": + [",".join([str(i) for i in var.shape])], + "slice_varnames": [var.name], + "remote_varnames": [var.name], + "is_sparse": False, + "endpoints": var_ctx.split_endpoints(), + "file_path": os.path.join(dirname, var.name) + }) + + executor.run(prog) + return local_vars + + def _save_sparse_params(self, executor, dirname, context, main_program): + prog = Program() + block = prog.global_block() + local_vars = [] + + for name, var_ctx in context.items(): + if len(var_ctx.origin_varnames()) != 1: + raise ValueError("Dense can not support split now.") + + varname = var_ctx.origin_varnames()[0] + local_vars.append(varname) + + optimizer = self._get_optimizer_op(varname) + reshaped_varnames, origin_varnames = self._get_optimizer_status( + optimizer.type, varname) + + var = self._origin_main_program.global_block().vars[varname] + slice_shapes = [] + dims1 = ",".join([str(i) for i in var.shape[1:]]) + + for section in var_ctx.sections(): + slice_shapes.append(str(section) + dims1) + + block.append_op( + type='recv_save', + attrs={ + "trainer_id": self._role_maker.worker_index(), + "shape": var.shape, + "slice_shapes": slice_shapes, + "slice_varnames": var_ctx.split_varnames(), + "remote_varnames": var_ctx.split_varnames(), + "is_sparse": True, + "endpoints": var_ctx.split_endpoints(), + "pserver_num": + len(self._role_maker.get_pserver_endpoints()), + "file_path": os.path.join(dirname, var.name) + }) + + for reshaped_varname in reshaped_varnames: + var = self._origin_main_program.global_block().vars[ + reshaped_varname] + + slice_varnames = [] + remote_varnames = [] + for i in range(len(var_ctx.split_varnames())): + slice_varnames.append("{}.block{}".format(reshaped_varname, + i)) + remote_varnames.append(reshaped_varname) + + block.append_op( + type='recv_save', + attrs={ + "trainer_id": self._role_maker.worker_index(), + "shape": var.shape, + "slice_shapes": slice_shapes, + "slice_varnames": slice_varnames, + "remote_varnames": remote_varnames, + "is_sparse": True, + "endpoints": var_ctx.split_endpoints(), + "pserver_num": + len(self._role_maker.get_pserver_endpoints()), + "file_path": os.path.join(dirname, var.name) + }) + + for origin_varname in origin_varnames: + var = self._origin_main_program.global_block().vars[ + origin_varname] + + block.append_op( + type='recv_save', + attrs={ + "trainer_id": self._role_maker.worker_id(), + "shape": var.shape, + "slice_shapes": + [",".join([str(i) for i in var.shape])], + "slice_varnames": [origin_varname], + "remote_varnames": [origin_varname], + "is_sparse": False, + "endpoints": var_ctx.split_endpoints()[:1], + "file_path": os.path.join(dirname, var.name) + }) + executor.run(prog) + return context.keys() + + def _save_distributed_params(self, executor, dirname, context, + main_program): + prog = Program() + block = prog.global_block() + + for name, var_ctx in context.items(): + block.append_op( + type='checkpoint_notify', + attrs={ + "varname": name, + "is_slice": True, + "slice_varnames": var_ctx.split_varnames(), + "remote_varnames": var_ctx.split_varnames(), + "endpoints": var_ctx.split_endpoints(), + "dirname": dirname + }) + + executor.run(prog) + return context.keys() + + def _save_distributed_persistables(self, executor, dirname, main_program): + dense_ctx = fleet.compiled_config.get_communicator_recv_context( + recv_type=1) + + sparse_ctx = fleet.compiled_config.get_communicator_recv_context( + recv_type=2) + + distributed_ctx = fleet.compiled_config.get_communicator_recv_context( + recv_type=3) + + recv_dense_varnames = self._save_dense_params(executor, dirname, + dense_ctx, main_program) + + recv_sparse_varnames = self._save_sparse_params( + executor, dirname, sparse_ctx, main_program) + + recv_distributed_varnames = self._save_distributed_params( + executor, dirname, distributed_ctx, main_program) + + saved_varnames = recv_dense_varnames + list( + recv_sparse_varnames) + list(recv_distributed_varnames) + + remaining_vars = list( + filter( + FleetTranspiler.__exclude_vars(saved_varnames), + main_program.list_vars())) + + fluid.io.save_vars( + executor, + main_program=main_program, + dirname=dirname, + vars=remaining_vars) + + def save_persistables(self, executor, dirname, main_program=None, **kwargs): """ This function filters out all variables with `persistable==True` from the give `main_program` and then saves these variables to the folder `dirname` @@ -245,9 +653,14 @@ class DistributedTranspiler(Fleet): The `dirname` is used to specify the folder where persistable variables are going to be saved. If you would like to save variables in separate - files, set `filename` None; if you would like to save all variables in a + files, set `filename` None; +if you would like to save all variables in a single file, use `filename` to specify the file name. """ + + if self._inner_mode == PSMode.PSLIB: + raise NotImplementedError("add implement later") + if isinstance(executor, ParallelExecutor): raise TypeError( "in fleet.save_persistables() function, executor must be as Executor type, ParallelExecutor is not allowed" @@ -266,91 +679,35 @@ class DistributedTranspiler(Fleet): "in fleet.save_persistables() function, main_program must be as Program type, CompiledProgram is not allowed" ) - if not main_program._is_distributed: - raise ValueError( - "main_program is for local, may not use fleet.save_persistables") - - io.save_persistables(executor, dirname, main_program, None) - - def _transpile(self, config): - if isinstance(config, DistributedStrategy): - self._transpile_config = config - elif isinstance(config, DistributeTranspilerConfig): - if config.sync_mode: - self._transpile_config = SyncStrategy() - else: - if config.runtime_split_send_recv: - if config.geo_sgd_mode: - self._transpile_config = GeoStrategy( - config.geo_sgd_need_push_nums) - elif config.half_async: - self._transpile_config = HalfAsyncStrategy() - else: - self._transpile_config = AsyncStrategy() - - else: - self._transpile_config = HalfAsyncStrategy() - # for half_async compatibility - config.half_async = True - config.runtime_split_send_recv = True - self._transpile_config.set_program_config(config) - else: - raise TypeError( - "config must be an instance of DistributeTranspilerConfig, SyncStrategy, HalfAsyncStrategy, AsyncStrategy or GeoStratey." - ) + self._save_distributed_persistables(executor, dirname, main_program) - program_config = self._transpile_config.get_program_config() + @staticmethod + def __exclude_vars(exclude_var_names=[]): + def is_valid(var): + if var.name in exclude_var_names: + return False - # _origin_program is a deep copy for default_main_program, for inference - self._origin_program = default_main_program().clone(for_test=False) + origin_varname, _, _ = public._get_varname_parts(var.name) + if origin_varname.endswith("@GRAD"): + return False - if program_config.geo_sgd_mode: - from paddle.fluid.transpiler.geo_sgd_transpiler import GeoSgdTranspiler - self._transpiler = GeoSgdTranspiler(program_config) - else: - self._transpiler = OriginTranspiler(program_config) - self._transpiler._set_server_config( - self._transpile_config.get_server_runtime_config()) + if origin_varname == "learning_rate_0": + return False - if self.is_worker(): - self._transpiler.transpile( - trainer_id=fleet.worker_index(), - pservers=fleet.server_endpoints(to_string=True), - trainers=fleet.worker_num(), - sync_mode=program_config.sync_mode) + if var.desc.type() == core.VarDesc.VarType.FEED_MINIBATCH or \ + var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \ + var.desc.type() == core.VarDesc.VarType.READER: + return False + return var.persistable - if isinstance(self._role_maker, MPISymetricRoleMaker): - program_config.wait_port = False - self._transpile_config.set_program_config(program_config) - - self.main_program = self._transpiler.get_trainer_program( - wait_port=program_config.wait_port) - self.startup_program = default_startup_program() - if program_config.geo_sgd_mode: - self.vars_info = self._transpiler._get_vars_info() - self.startup_program = self._transpiler.trainer_startup_program - else: - self._transpiler.transpile( - trainer_id=fleet.worker_index(), - pservers=fleet.server_endpoints(to_string=True), - trainers=fleet.worker_num(), - sync_mode=program_config.sync_mode, - current_endpoint=self.server_endpoints()[self.server_index()]) - self.main_program, self.startup_program = \ - self._transpiler.get_pserver_programs( - self.server_endpoints()[self.server_index()]) - - def _set_opt_info(self, opt_info): - """ - this function saves the result from DistributedOptimizer.minimize() - """ - self._opt_info = opt_info + return is_valid -fleet = DistributedTranspiler() +# fleet is a global instance for parameter server. +fleet = FleetTranspiler() -class TranspilerOptimizer(DistributedOptimizer): +class ParameterServerOptimizer(DistributedOptimizer): """ DistributedOptimizer is a wrapper for paddle.fluid.optimizer A user should pass a paddle.fluid.optimizer to DistributedOptimizer @@ -368,29 +725,28 @@ class TranspilerOptimizer(DistributedOptimizer): None """ - def __init__(self, optimizer, strategy=None): - super(TranspilerOptimizer, self).__init__(optimizer, strategy) - - self.opt_info = dict() - if strategy: - if isinstance(strategy, DistributeTranspilerConfig): - self._strategy = strategy - elif isinstance(strategy, DistributedStrategy): - self._strategy = strategy - else: - raise TypeError( - "In {} mode, strategy must be an instance of DistributeTranspilerConfig, SyncStrategy, HalfAsyncStrategy, AsyncStrategy, or GeoStrategy". - format(fleet._mode)) + def __init__(self, optimizer, strategy, mode=PSMode.TRANSPILER): + super(ParameterServerOptimizer, self).__init__(optimizer, strategy) + self._mode = mode + if self._mode == PSMode.PSLIB: + self._optimizer_name = "Distributed%s" % optimizer.type.capitalize() + if optimizer.type != "adam": + print("Currently, distributed optimizer only support Adam" + "Will config built-in adam for you." + "We will support more functions in DistributedOptimizer", + sys.stderr) + self._optimizer_name = "DistributedAdam" + + self._optimizer = globals()[self._optimizer_name](optimizer) else: - self._strategy = StrategyFactory.create_sync_strategy() + self._optimizer = optimizer - if isinstance(self._strategy, DistributedStrategy): - self.opt_info = self._strategy.get_debug_opt() - self.opt_info["mpi_rank"] = fleet.worker_index() - self.opt_info["mpi_size"] = fleet.worker_num() - self.opt_info["trainer"] = "MultiTrainer" - self.opt_info["device_worker"] = "Hogwild" - fleet._set_opt_info(self.opt_info) + self._window = 1 + self.type = "downpour" + self.data_norm_name = [ + ".batch_size", ".batch_square_sum", ".batch_sum", + ".batch_size@GRAD", ".batch_square_sum@GRAD", ".batch_sum@GRAD" + ] def backward(self, loss, @@ -398,86 +754,91 @@ class TranspilerOptimizer(DistributedOptimizer): parameter_list=None, no_grad_set=None, callbacks=None): - """ - First part of `minimize`, do auto-diff to append backward ops for - the current program. - - Args: - loss (Variable): loss variable to run optimizations. - startup_program (Program): startup_program for initializing parameters - in `parameter_list`. - parameter_list (list): list of Variables to update. - no_grad_set (set|None): set of Variables should be ignored. - callbacks (list|None): list of callables to run when appending backward - operator for one parameter. - - Return: - list: list of (param, grad) pair, grad is the output of backward. - - Examples: - See examples in `apply_gradients`. - """ - return self._optimizer.backward(loss, startup_program, parameter_list, - no_grad_set, callbacks) + raise NotImplementedError() def apply_gradients(self, params_grads): - """ - Second part of `minimize`, appending optimization operators for - given `params_grads` pairs. - - Args: - params_grads (list): list of (param, grad) pair to do optimization. - - Returns: - list: A list of operators appended to the current program. - - Examples: - .. code-block:: python - - loss = network() - optimizer = fluid.optimizer.SGD(learning_rate=0.1) - params_grads = optimizer.backward(loss) - # you may append operations for params_grads here - # ... - optimizer.apply_gradients(params_grads) - """ - return self._optimizer.apply_gradients(params_grads) + raise NotImplementedError() + + def _build_trainer_programs(self, compiled_config): + _main = fleet._origin_main_program.clone() + _startup = fleet._origin_startup_program.clone() + + if not compiled_config.is_geo_mode(): + # for main program + _main = worker.delete_optimizer_pass(_main, compiled_config) + _main = worker.distributed_ops_pass(_main, compiled_config) + _main = worker.append_send_ops_pass(_main, compiled_config) + + # for startup program + _startup = worker.fake_init_ops_pass(_startup, compiled_config) + _startup = worker.init_from_server_pass(_startup, compiled_config) + _startup = worker.delet_extra_optimizes_pass(_startup, + compiled_config) + else: + _main = worker.append_send_ops_pass(_main, compiled_config) + _startup = _startup + + return _main, _startup + + def _build_pserver_programs(self, compiled_config): + _main = fluid.Program() + _startup = fluid.Program() + + if not compiled_config.is_geo_mode(): + _main = server.add_listen_and_serv_pass(_main, compiled_config) + _main = server.add_rpc_global_flags_pass(_main, compiled_config) + _main = server.add_optimizer_pass(_main, compiled_config) + _main = server.large_scale_sparse_pass(_main, _main, + compiled_config, False) + _startup = server.build_pserver_startup_program_pass( + _startup, _main, compiled_config) + _startup = server.large_scale_sparse_pass(_startup, _main, + compiled_config, True) + + if not compiled_config.is_sync_mode(): + _main = server.delete_unused_in_main_pass(_main, + compiled_config) + + _startup = server.delete_unused_in_startup_pass(_startup, _main, + compiled_config) + else: + _main = server.add_listen_and_serv_pass(_main, compiled_config) + _main = server.add_rpc_global_flags_pass(_main, compiled_config) + _main = server.add_geo_optimizer_pass(_main, compiled_config) + _main = server.large_scale_sparse_pass(_main, _main, + compiled_config, False) + _startup = server.build_pserver_startup_program_pass( + _startup, _main, compiled_config) + _startup = server.large_scale_sparse_pass(_startup, _main, + compiled_config, True) + _startup = server.delete_unused_in_startup_pass(_startup, _main, + compiled_config) + + return _main, _startup def minimize(self, - loss, + losses, scopes=None, - startup_program=None, + startup_programs=None, parameter_list=None, no_grad_set=None): - """ - Add operations to minimize `loss` by updating `parameter_list`. - This method combines interface `backward()` and - `apply_gradients()` into one. + if isinstance(losses, list): + raise ValueError("need implement later") - Args: - loss (Variable): loss variable to run optimizations. - scopes (None): TranspilerOptimizer doesn't need scope parameter. - startup_program (Program): startup_program for initializing parameters - in `parameter_list`. - parameter_list (list): list of Variables to update. - no_grad_set (set|None): set of Variables should be ignored. + self._optimizer.minimize(losses, startup_programs, parameter_list, + no_grad_set) - Returns: - tuple: (optimize_ops, params_grads) which are, list of operators appended; - and list of (param, grad) Variables pair for optimization. - """ - if isinstance(loss, list): - raise TypeError( - "DistributedTranspiler's minimize can not accept loss with list") + fleet._origin_main_program = default_main_program().clone( + for_test=False) + fleet._origin_startup_program = default_startup_program().clone( + for_test=False) - if isinstance(startup_program, list): - raise TypeError( - "DistributedTranspiler's minimize can not accept program with list" - ) + compiled_config = public.CompileTimeStrategy( + fleet._origin_main_program, fleet._origin_startup_program, + self._strategy, fleet._role_maker) - optimize_ops, params_grads = self._optimizer.minimize( - loss, startup_program, parameter_list, no_grad_set) - fleet._transpile(config=self._strategy) - loss.block.program._fleet_opt = self.opt_info - return optimize_ops, params_grads + fleet.compiled_config = compiled_config + fleet.main_program, fleet.startup_program = \ + self._build_trainer_programs(compiled_config) if fleet.is_worker() \ + else self._build_pserver_programs(compiled_config) diff --git a/python/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/distributed_strategy.py b/python/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/distributed_strategy.py index 92d07c97da46568f31d86a99f20f0b8fe071b031..35029a3dfc7e70575f66e49d845ec7b51b65f470 100644 --- a/python/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/distributed_strategy.py +++ b/python/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/distributed_strategy.py @@ -19,7 +19,8 @@ __all__ = [ import os import paddle.fluid as fluid -from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig, ServerRuntimeConfig, DistributedMode +from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig, ServerRuntimeConfig +from paddle.fluid.incubate.fleet.parameter_server.mode import DistributedMode class TrainerRuntimeConfig(object): @@ -68,7 +69,8 @@ class TrainerRuntimeConfig(object): elif self.mode == DistributedMode.GEO: mode_str = "GEO" need_keys = [ - 'communicator_thread_pool_size', 'communicator_send_wait_times' + 'communicator_thread_pool_size', 'communicator_send_wait_times', + 'communicator_max_merge_var_num', 'communicator_send_queue_size' ] else: raise ValueError("Unsupported Mode") @@ -124,10 +126,19 @@ class TrainerRuntimeConfig(object): return self.display(self.get_communicator_flags()) +class PSLibRuntimeConfig(object): + def __init__(self): + self.runtime_configs = {} + + def get_runtime_configs(self): + return self.runtime_configs + + class DistributedStrategy(object): def __init__(self): self._program_config = DistributeTranspilerConfig() self._trainer_runtime_config = TrainerRuntimeConfig() + self._pslib_runtime_config = PSLibRuntimeConfig() self._server_runtime_config = ServerRuntimeConfig() num_threads = int(os.getenv("CPU_NUM", "1")) @@ -204,6 +215,12 @@ class DistributedStrategy(object): "check_trainer_runtime_config must be implemented by derived class. You should use StrategyFactory to create DistributedStrategy." ) + def get_pslib_runtime_config(self): + return self._pslib_runtime_config + + def set_pslib_runtime_config(self, config): + self._pslib_runtime_config.runtime_configs = config + def get_server_runtime_config(self): return self._server_runtime_config @@ -375,6 +392,12 @@ class GeoStrategy(DistributedStrategy): def check_trainer_runtime_config(self): self._trainer_runtime_config.mode = DistributedMode.GEO + self._trainer_runtime_config.runtime_configs[ + 'communicator_send_queue_size'] = self._program_config.geo_sgd_need_push_nums + + self._trainer_runtime_config.runtime_configs[ + 'communicator_max_merge_var_num'] = self._program_config.geo_sgd_need_push_nums + def check_server_runtime_config(self): pass diff --git a/python/paddle/fluid/incubate/fleet/parameter_server/ir/__init__.py b/python/paddle/fluid/incubate/fleet/parameter_server/ir/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..abf198b97e6e818e1fbe59006f98492640bcee54 --- /dev/null +++ b/python/paddle/fluid/incubate/fleet/parameter_server/ir/__init__.py @@ -0,0 +1,13 @@ +# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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. diff --git a/python/paddle/fluid/incubate/fleet/parameter_server/ir/ps_dispatcher.py b/python/paddle/fluid/incubate/fleet/parameter_server/ir/ps_dispatcher.py new file mode 100644 index 0000000000000000000000000000000000000000..5f48ba6b2a725b216d6c9793d0520d5e5dd9dfc6 --- /dev/null +++ b/python/paddle/fluid/incubate/fleet/parameter_server/ir/ps_dispatcher.py @@ -0,0 +1,125 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + + +class PSDispatcher(object): + """ + PSDispatcher is the base class for dispatching vars + into different pserver instance. + You need to implement the `dispatch` interface. + """ + + def __init__(self, pserver_endpoints): + self._eps = pserver_endpoints + self._step = 0 + + @property + def eps(self): + return self._eps + + def reset(self): + """ + reset the step counter, set it zero. + """ + self._step = 0 + + def dispatch(self, varlist): + """ + Args: + varlist(list): a list of Variables + Returns: + a map of pserver endpoint -> varname + """ + raise NotImplementedError("Interface has not been implemented.") + + +class HashName(PSDispatcher): + """ + Hash variable names to several endpoints using python + "hash()" function. + + Args: + pserver_endpoints (list): list of endpoint(ip:port). + + Examples: + .. code-block:: python + + pserver_endpoints = ["127.0.0.1:6007", "127.0.0.1:6008"] + vars = ["var1","var2","var3","var4","var5"] + + rr = RoundRobin(pserver_endpoints) + rr.dispatch(vars) + + """ + + def __init__(self, pserver_endpoints): + super(self.__class__, self).__init__(pserver_endpoints) + + def _hash_block(self, block_str, total): + return hash(block_str) % total + + def dispatch(self, varlist): + """ + use `HashName` method to dispatch variables with each parameter server. + Args: + varlist (list): a list of Variables + + """ + eplist = [] + for var in varlist: + server_id = self._hash_block(var.name(), len(self._eps)) + server_for_param = self._eps[server_id] + eplist.append(server_for_param) + return eplist + + +class RoundRobin(PSDispatcher): + """ + Distribute variables to several endpoints using + RondRobin method. + + Args: + pserver_endpoints (list): list of endpoint(ip:port). + + Examples: + .. code-block:: python + + pserver_endpoints = ["127.0.0.1:6007", "127.0.0.1:6008"] + vars = ["var1","var2","var3","var4","var5"] + + rr = RoundRobin(pserver_endpoints) + rr.dispatch(vars) + + """ + + def __init__(self, pserver_endpoints): + super(self.__class__, self).__init__(pserver_endpoints) + + def dispatch(self, varlist): + """ + use `RoundRobin` method to dispatch variables with each parameter server. + Args: + varlist (list): a list of Variables + + """ + eplist = [] + for var in varlist: + server_for_param = self._eps[self._step] + eplist.append(server_for_param) + self._step += 1 + if self._step >= len(self._eps): + self._step = 0 + return eplist diff --git a/python/paddle/fluid/incubate/fleet/parameter_server/ir/pserver_pass.py b/python/paddle/fluid/incubate/fleet/parameter_server/ir/pserver_pass.py new file mode 100644 index 0000000000000000000000000000000000000000..765c18283b49ad956ec34b2c1eefbb4dbcefe85a --- /dev/null +++ b/python/paddle/fluid/incubate/fleet/parameter_server/ir/pserver_pass.py @@ -0,0 +1,927 @@ +# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +import collections +import six + +from paddle.fluid import core +from paddle.fluid.framework import Block + +from paddle.fluid.incubate.fleet.parameter_server.ir.public import _get_optimize_ops +from paddle.fluid.incubate.fleet.parameter_server.ir.public import _orig_varname +from paddle.fluid.incubate.fleet.parameter_server.ir.public import _get_varname_parts +from paddle.fluid.incubate.fleet.parameter_server.ir.public import is_distributed_sparse_op +from paddle.fluid.incubate.fleet.parameter_server.ir.public import get_sparse_tablename +from paddle.fluid.incubate.fleet.parameter_server.ir.public import get_sparse_tablenames +from paddle.fluid.incubate.fleet.parameter_server.ir.public import _get_lr_ops + +LEARNING_RATE_DECAY_COUNTER = "@LR_DECAY_COUNTER@" +OP_ROLE_VAR_ATTR_NAME = core.op_proto_and_checker_maker.kOpRoleVarAttrName() +RPC_OP_ROLE_ATTR_NAME = core.op_proto_and_checker_maker.kOpRoleAttrName() +OPT_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.Optimize +LR_SCHED_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.LRSched + + +def _is_optimizer_op(op): + if "Param" in op.input_names and \ + "LearningRate" in op.input_names: + return True + return False + + +def _same_or_split_var(p_name, var_name): + return p_name == var_name or p_name.startswith(var_name + ".block") + + +def _get_optimizer_input_shape(op_type, varkey, orig_shape, param_shape): + """ + Returns the shape for optimizer inputs that need to be reshaped when + Param and Grad is split to multiple servers. + """ + # HACK(typhoonzero) : Should use functions of corresponding optimizer in + # optimizer.py to get the shape, do not bind this in the transpiler. + if op_type == "adam": + if varkey in ["Moment1", "Moment2"]: + return param_shape + elif op_type == "adagrad": + if varkey == "Moment": + return param_shape + elif op_type == "adamax": + if varkey in ["Moment", "InfNorm"]: + return param_shape + elif op_type in ["momentum", "lars_momentum"]: + if varkey == "Velocity": + return param_shape + elif op_type == "rmsprop": + if varkey in ["Moment", "MeanSquare"]: + return param_shape + elif op_type == "decayed_adagrad": + if varkey == "Moment": + return param_shape + elif op_type == "ftrl": + if varkey in ["SquaredAccumulator", "LinearAccumulator"]: + return param_shape + elif op_type == "sgd": + pass + else: + raise ValueError( + "Not supported optimizer for distributed training: %s" % op_type) + return orig_shape + + +def _append_pserver_non_opt_ops(optimize_block, opt_op, origin_program, config): + def _get_pserver_grad_param_var(var, var_dict): + """ + Return pserver side grad/param variable, return None + if the variable is not grad/param, e.g. + + a@GRAD -> a@GRAD.block0 + a@GRAD -> a@GRAD (a is not split) + fc_0.w_0 -> fc_0.w_0.block_0 + fc_0.w_0 -> fc_0.w_0 (weight is not split) + _generated_var_123 -> None + """ + + grad_block = None + for _, g in six.iteritems(var_dict): + if _orig_varname(g.name) == _orig_varname(var.name): + # skip per trainer vars + if g.name.find(".trainer_") == -1: + # only param or grads have split blocks + ovar_name = _orig_varname(g.name) + if ovar_name in config.param_grad_ep_mapping: + grad_block = g + break + elif ovar_name in config.grad_param_mapping: + grad_block = g + break + + return grad_block + + program = optimize_block.program + # Append the ops for parameters that do not need to be optimized / updated + inputs = _get_input_map_from_op(origin_program.global_block().vars, opt_op) + for key, varlist in six.iteritems(inputs): + if not isinstance(varlist, list): + varlist = [varlist] + for i in range(len(varlist)): + var = varlist[i] + # for ops like clipping and weight decay, get the split var(xxx.block0) + # for inputs / outputs + grad_block = _get_pserver_grad_param_var( + var, program.global_block().vars) + if grad_block: + varlist[i] = grad_block + elif var.name not in program.global_block().vars: + tmpvar = program.global_block()._clone_variable(var) + varlist[i] = tmpvar + else: + varlist[i] = program.global_block().vars[var.name] + inputs[key] = varlist + + outputs = _get_output_map_from_op(origin_program.global_block().vars, + opt_op) + for key, varlist in six.iteritems(outputs): + if not isinstance(varlist, list): + varlist = [varlist] + for i in range(len(varlist)): + var = varlist[i] + grad_block = _get_pserver_grad_param_var( + var, program.global_block().vars) + if grad_block: + varlist[i] = grad_block + elif var.name not in program.global_block().vars: + tmpvar = program.global_block()._clone_variable(var) + varlist[i] = tmpvar + else: + varlist[i] = program.global_block().vars[var.name] + outputs[key] = varlist + + return optimize_block.append_op( + type=opt_op.type, + inputs=inputs, + outputs=outputs, + attrs=opt_op.all_attrs()) + + +def _append_pserver_ops(optimize_block, opt_op, endpoint, grad_to_block_id, + origin_program, merged_var, sparse_grad_to_param, + config): + program = optimize_block.program + pserver_block = program.global_block() + new_inputs = collections.OrderedDict() + + def _get_param_block(opt_op): + # param is already created on global program + unmerged_vars = [] + merged_vars = [] + merged_ordervars = [] + + param_vars = [ + p for p in config.param_grad_ep_mapping[endpoint]["params"] + ] + + for var in param_vars: + name = var.name + orig_varname = _orig_varname(name) + + for pairs in config.merged_variables_pairs: + merged_p = pairs[0] + if merged_p.merged_var.name == orig_varname: + if merged_p.merged_var.name == merged_p.ordered_vars[ + 0].name: + unmerged_vars.append(merged_p.ordered_vars[0]) + else: + merged_vars.append(merged_p.merged_var) + merged_ordervars.append(merged_p.ordered_vars[0]) + break + + param_name = opt_op.input("Param")[0] + + for i in range(len(unmerged_vars)): + if _same_or_split_var(param_name, unmerged_vars[i].name): + for var in param_vars: + if _same_or_split_var(var.name, unmerged_vars[i].name): + return var + + for i in range(len(merged_ordervars)): + if _same_or_split_var(param_name, merged_ordervars[i].name): + for var in param_vars: + if _same_or_split_var(var.name, merged_vars[i].name): + return var + return None + + for key in opt_op.input_names: + if key == "Grad": + # Note !!This is for l2decay on sparse gradient, \ + # because it will create a new tensor for + # decayed gradient but not inplace modify the origin one + origin_grad_name = opt_op.input(key)[0] + if core.kNewGradSuffix( + ) in origin_grad_name and pserver_block.has_var(origin_grad_name): + new_grad = pserver_block.var(origin_grad_name) + new_inputs[key] = new_grad + else: + new_inputs[key] = merged_var + elif key == "Param": + param_block = _get_param_block(opt_op) + + if not param_block: + return + tmpvar = pserver_block.create_var( + name=param_block.name, + persistable=True, + dtype=param_block.dtype, + shape=param_block.shape) + new_inputs[key] = tmpvar + + elif key == "LearningRate": + # learning rate variable has already be created by non - optimize op, + # don't create it once again. + lr_varname = opt_op.input(key)[0] + if lr_varname in pserver_block.vars: + new_inputs[key] = pserver_block.vars[opt_op.input(key)[0]] + else: + origin_var = origin_program.global_block().vars[lr_varname] + tmpvar = pserver_block.create_var( + name=origin_var.name, + persistable=origin_var.persistable, + dtype=origin_var.dtype, + shape=origin_var.shape) + new_inputs[key] = tmpvar + + for key in opt_op.input_names: + new_shape = None + if key in [ + "Param", "Grad", "LearningRate", "Beta1Tensor", "Beta2Tensor" + ]: + continue + var = origin_program.global_block().vars[opt_op.input(key)[0]] + param_var = new_inputs["Param"] + # update accumulator variable shape + new_shape = _get_optimizer_input_shape(opt_op.type, key, var.shape, + param_var.shape) + tmpvar = pserver_block.create_var( + name=var.name, + persistable=var.persistable, + dtype=var.dtype, + shape=new_shape) + new_inputs[key] = tmpvar + + # change output's ParamOut variable + outputs = _get_output_map_from_op(origin_program.global_block().vars, + opt_op) + outputs["ParamOut"] = new_inputs["Param"] + optimize_block.append_op( + type=opt_op.type, + inputs=new_inputs, + outputs=outputs, + attrs=opt_op.all_attrs()) + + # record sparse grad to param name + if new_inputs["Grad"].type == core.VarDesc.VarType.SELECTED_ROWS: + sparse_grad_to_param.append( + str(new_inputs["Grad"].name) + ":" + str(new_inputs["Param"].name)) + + +def _get_input_map_from_op(varmap, op): + """Returns a dict from op input name to the vars in varmap.""" + iomap = collections.OrderedDict() + for key in op.input_names: + vars = [] + for varname in op.input(key): + vars.append(varmap[varname]) + if len(vars) == 1: + iomap[key] = vars[0] + else: + iomap[key] = vars + return iomap + + +def _get_output_map_from_op(varmap, op): + """Returns a dict from op output name to the vars in varmap.""" + iomap = collections.OrderedDict() + for key in op.output_names: + vars = [] + for varname in op.output(key): + vars.append(varmap[varname]) + if len(vars) == 1: + iomap[key] = vars[0] + else: + iomap[key] = vars + return iomap + + +def get_op_by_type(block, op_type): + for op in block.ops: + if op.type == op_type: + return op + raise ValueError("add_listen_and_serv_pass must at first") + + +def add_listen_and_serv_pass(program, config): + attrs = { + "grad_to_block_id": None, + "sparse_grad_to_param": None, + "lr_decay_block_id": None, + "dense_optimize_blocks": None, + "sparse_optimize_blocks": None, + + # runtime attribute + "endpoint": config.get_ps_endpoint(), + "pserver_id": config.get_role_id(), + "Fanin": config.get_trainers(), + "distributed_mode": config.get_distributed_mode(), + "rpc_get_thread_num": -1, + "rpc_send_thread_num": -1, + "rpc_prefetch_thread_num": -1 + } + + # step5 append the listen_and_serv op + program.global_block().append_op( + type="listen_and_serv", inputs={'X': []}, outputs={}, attrs=attrs) + + return program + + +def add_rpc_global_flags_pass(program, config): + server_runtime = config.get_server_runtime_config() + send_threads = server_runtime._rpc_send_thread_num + get_threads = server_runtime._rpc_get_thread_num + pull_threads = server_runtime._rpc_prefetch_thread_num + + op = get_op_by_type(program.global_block(), "listen_and_serv") + + if get_threads < 1 or send_threads < 1 or pull_threads < 1: + raise ValueError( + "error arguments in get_threads/send_threads/pull_threads") + + op._set_attr("rpc_get_thread_num", get_threads) + op._set_attr("rpc_send_thread_num", send_threads) + op._set_attr("rpc_prefetch_thread_num", pull_threads) + + return program + + +def _clone_var(block, var, persistable=True): + return block.create_var( + name=var.name, + shape=var.shape, + dtype=var.dtype, + type=var.type, + lod_level=var.lod_level, + persistable=persistable) + + +def add_optimizer_pass(program, config): + def _append_pserver_grad_merge_ops(optimize_block, grad_varname_for_block, + endpoint, grad_to_block_id): + trainers = config.get_trainers() + + program = optimize_block.program + pserver_block = program.global_block() + grad_block = None + + for g in config.param_grad_ep_mapping[endpoint]["grads"]: + if _orig_varname(g.name) == \ + _orig_varname(grad_varname_for_block): + grad_block = g + break + + if not grad_block: + # do not append this op if current endpoint + # is not dealing with this grad block + return None + + orig_varname, block_name, trainer_name = _get_varname_parts( + grad_block.name) + + if block_name: + merged_var_name = '.'.join([orig_varname, block_name]) + else: + merged_var_name = orig_varname + + merged_var = pserver_block.create_var( + name=grad_block.name, + persistable=True, + type=grad_block.type, + dtype=grad_block.dtype, + shape=grad_block.shape) + + grad_to_block_id.append(merged_var.name + ":" + str(optimize_block.idx)) + if config.is_sync_mode() and trainers > 1: + vars2merge = [] + for i in range(trainers): + per_trainer_name = "%s.trainer_%d" % \ + (merged_var_name, i) + per_trainer_var = pserver_block.create_var( + name=per_trainer_name, + persistable=False, + type=grad_block.type, + dtype=grad_block.dtype, + shape=grad_block.shape) + vars2merge.append(per_trainer_var) + + optimize_block.append_op( + type="sum", + inputs={"X": vars2merge}, + outputs={"Out": merged_var}, + attrs={"use_mkldnn": False}) + optimize_block.append_op( + type="scale", + inputs={"X": merged_var}, + outputs={"Out": merged_var}, + attrs={"scale": 1.0 / float(trainers)}) + return merged_var + + origin_program = config.get_origin_main_program() + origin_program = origin_program.clone() + ps_endpoint = config.get_ps_endpoint() + + opt_op_on_pserver = [] + # Iterate through the ops, and if an op and the optimize ops + # which located on current pserver are in one set, then + # append it into the sub program. + global_ops = [] + # sparse grad name to param name + sparse_grad_to_param = [] + + def _is_opt_op_on_pserver(endpoint, op): + param_names = [ + p.name for p in config.param_grad_ep_mapping[endpoint]["params"] + ] + + unmerged_varnames = [] + merged_varnames = [] + merged_ordernames = [] + + for name in param_names: + orig_varname = _orig_varname(name) + + for pairs in config.merged_variables_pairs: + merged_p = pairs[0] + if merged_p.merged_var.name == orig_varname: + if merged_p.merged_var.name == merged_p.ordered_vars[ + 0].name: + unmerged_varnames.append(merged_p.ordered_vars[0].name) + else: + merged_varnames.append(merged_p.merged_var.name) + merged_ordernames.append(merged_p.ordered_vars[0].name) + break + + param = op.input("Param")[0] + + if param in unmerged_varnames: + return True + + for i in range(len(merged_ordernames)): + if param == merged_ordernames[i]: + merged_p = merged_varnames[i] + merged_g = "{}@GRAD".format(merged_varnames[i]) + op._set_attr(OP_ROLE_VAR_ATTR_NAME, [merged_p, merged_g]) + return True + return False + + def __append_optimize_op__(op, block, grad_to_block_id, merged_var, lr_ops): + if _is_optimizer_op(op): + _append_pserver_ops(block, op, ps_endpoint, grad_to_block_id, + origin_program, merged_var, + sparse_grad_to_param, config) + elif op not in lr_ops: + _append_pserver_non_opt_ops(block, op, origin_program, config) + + optimize_ops = _get_optimize_ops(origin_program) + for _, op in enumerate(optimize_ops): + if _is_optimizer_op(op) and _is_opt_op_on_pserver(ps_endpoint, op): + opt_op_on_pserver.append(op) + + # append lr decay ops to the child block if exists + lr_ops = _get_lr_ops(origin_program) + has_lr_decay = True if len(lr_ops) > 0 else False + lr_decay_block_id = -1 + optimize_blocks = [] + + if has_lr_decay > 0: + counter_increment_idx = -1 + for idx, op in enumerate(lr_ops): + if op.type != 'increment': + continue + counter = op.input("X")[0] + if counter == LEARNING_RATE_DECAY_COUNTER: + counter_increment_idx = idx + break + + if counter_increment_idx != -1: + lr_ops.pop(counter_increment_idx) + + lr_decay_block = program._create_block(program.num_blocks - 1) + optimize_blocks.append(lr_decay_block) + for op in lr_ops: + cloned_op = _append_pserver_non_opt_ops(lr_decay_block, op, + origin_program, config) + # append sub blocks to pserver_program in lr_decay_op + # todo(tangwei12): __clone_lr_op_sub_block__ + lr_decay_block_id = lr_decay_block.idx + + # append op to the current block + grad_to_block_id = [] + pre_block_idx = program.num_blocks - 1 + + for idx, opt_op in enumerate(opt_op_on_pserver): + per_opt_block = program._create_block(pre_block_idx) + optimize_blocks.append(per_opt_block) + optimize_target_param_name = opt_op.attr(OP_ROLE_VAR_ATTR_NAME)[0] + # append grad merging ops before clip and weight decay + # e.g.merge grad->L2Decay op->clip op->optimize + merged_var = None + for _, op in enumerate(optimize_ops): + # find the origin grad var before clipping / L2Decay, + # merged_var should be the input var name of L2Decay + grad_varname_for_block = op.attr(OP_ROLE_VAR_ATTR_NAME)[1] + if op.attr(OP_ROLE_VAR_ATTR_NAME)[0] == optimize_target_param_name: + merged_var = _append_pserver_grad_merge_ops( + per_opt_block, grad_varname_for_block, ps_endpoint, + grad_to_block_id) + if merged_var: + break # append optimize op once then append other ops. + + if merged_var: + for _, op in enumerate(optimize_ops): + # optimizer is connected to itself + if op.attr(OP_ROLE_VAR_ATTR_NAME)[0] == optimize_target_param_name and \ + op not in global_ops: + __append_optimize_op__(op, per_opt_block, grad_to_block_id, + merged_var, lr_ops) + + # dedup grad to ids list + grad_to_block_id = list(set(grad_to_block_id)) + # append global ops + if global_ops: + opt_state_block = program._create_block(program.num_blocks - 1) + optimize_blocks.append(opt_state_block) + for glb_op in global_ops: + __append_optimize_op__(glb_op, opt_state_block, grad_to_block_id, + None, lr_ops) + + if len(optimize_blocks) == 0: + pre_block_idx = program.num_blocks - 1 + empty_block = program._create_block(pre_block_idx) + optimize_blocks.append(empty_block) + + op = get_op_by_type(program.global_block(), "listen_and_serv") + op._set_attr("optimize_blocks", optimize_blocks) + op._set_attr("grad_to_block_id", grad_to_block_id) + op._set_attr("sparse_grad_to_param", sparse_grad_to_param) + op._set_attr("lr_decay_block_id", lr_decay_block_id) + return program + + +def large_scale_sparse_pass(program, main_program, config, is_startup=False): + opt_value_map = {} + opt_value_map["sgd"] = ["Param"] + opt_value_map["adam"] = ["Param", "Moment1", "Moment2"] + opt_value_map["adagrad"] = ["Param", "Moment"] + opt_value_map["adamax"] = ["Param", "Moment", "InfNorm"] + opt_value_map["momentum"] = ["Param", "Velocity"] + opt_value_map["lars_momentum"] = ["Param", "Velocity"] + opt_value_map["rmsprop"] = ["Param", "Moment", "MeanSquare"] + opt_value_map["decayed_adagrad"] = ["Param", "Moment"] + opt_value_map["ftrl"] = ["Param", "SquaredAccumulator", "LinearAccumulator"] + + geo_value_map = {} + geo_value_map["sum"] = "Param" + + opt_init_map = {} + opt_init_map["gaussian_random"] = ["seed", "mean", "std"] + opt_init_map["fill_constant"] = ["value"] + opt_init_map["uniform_random"] = ["seed", "min", "max"] + opt_init_map["truncated_gaussian_random"] = ["seed", "mean", "std"] + + def get_entry_attr(param_name): + origin_name = _orig_varname(param_name) + o_main_program = config.get_origin_main_program() + for op in o_main_program.global_block().ops: + if is_distributed_sparse_op(op) and get_sparse_tablename( + op) == origin_name: + entry = op.attr("entry") + return entry + + def get_initializer_attrs(acture_value_names): + l_sep = "," + l_in = "&" + init_attrs = [] + o_startup_program = config.get_origin_startup_program() + + for value_name in acture_value_names: + origin_var_name = _orig_varname(value_name) + for op in o_startup_program.global_block().ops: + if op.type in opt_init_map.keys( + ) and origin_var_name == op.output("Out")[0]: + init_attr = [op.type] + for attr in opt_init_map[op.type]: + init_attr.append(str(op.attr(attr))) + init_attrs.append(l_in.join(init_attr)) + break + + return l_sep.join(init_attrs) + + def get_optimizer_values(block): + value_names = [] + acture_names = [] + value_dims = [] + grad = None + opt_idx = -1 + + for op in block.ops: + opt_idx += 1 + + if op.type not in opt_value_map.keys(): + continue + + grad = main_program.global_block().vars[op.input("Grad")[0]] + + for value in opt_value_map[op.type]: + var = main_program.global_block().vars[op.input(value)[0]] + if len(var.shape) != 2: + raise ValueError("sparse param's dimension must be 2") + + value_names.append(value) + value_dims.append(var.shape[1]) + acture_names.append(var.name) + + if value_names: + break + return grad, opt_idx, value_names, value_dims, acture_names + + def add_large_scale_op(block, global_block, table_name, value_names, + acture_names, grad, is_entry, opt_idx): + ids = global_block.create_var( + name="kSparseIDs@{}".format(table_name), + persistable=False, + dtype="int64", + shape=[1, 1], + lod_level=0) + + # insert grad split to ids and tensor op + block._insert_op( + opt_idx, + type="lookup_sparse_table_grad_split", + inputs={"Grad": grad}, + outputs={"Row": ids, + "Value": grad}, + attrs={"tablename": table_name, + "is_entry": is_entry}) + + # insert read at first + vars = [global_block.vars[acture_name] for acture_name in acture_names] + block._insert_op( + opt_idx + 1, + type="lookup_sparse_table_read", + inputs={"Ids": ids}, + outputs={"Out": vars}, + attrs={"tablename": table_name, + "value_names": value_names}) + + # append write at last + inputs = {"Ids": ids, "In": vars} + + block.append_op( + type="lookup_sparse_table_write", + inputs=inputs, + outputs={}, + attrs={"tablename": table_name, + "value_names": value_names}) + + op = get_op_by_type(main_program.global_block(), "listen_and_serv") + + param_blockid_map = {} + grad_blockid_map = {} + grad_to_params = op.attr('sparse_grad_to_param') + grad_to_block_ids = op.attr('grad_to_block_id') + + origin_program = config.get_origin_main_program() + sparse_varnames = get_sparse_tablenames(origin_program, False) + + for grad_to_block_id in grad_to_block_ids: + grad, blockid = grad_to_block_id.split(":") + grad_blockid_map[grad] = int(blockid) + + for grad_to_param in grad_to_params: + grad, param = grad_to_param.split(":") + + if _orig_varname(param) in sparse_varnames: + continue + + param_blockid_map[param] = grad_blockid_map[grad] + + if not is_startup: + for param, blockid in param_blockid_map.items(): + opt_block = program.block(blockid) + + grad, opt_idx, value_names, value_dims, acture_names = \ + get_optimizer_values(opt_block) + + entry_attr = get_entry_attr(param) + is_entry = False if entry_attr == "none" else True + add_large_scale_op(opt_block, + program.global_block(), param, value_names, + acture_names, grad, is_entry, opt_idx) + + else: + large_scale_kv_metas = [] + for param, blockid in param_blockid_map.items(): + opt_block = main_program.block(blockid) + grad, _, value_names, value_dims, acture_names = \ + get_optimizer_values(opt_block) + + entry_attr = get_entry_attr(param) + + # training/infer + mode = "0" + names_str = ",".join(value_names) + dims_str = ",".join([str(dim) for dim in value_dims]) + ids_name = "kSparseIDs@{}".format(param) + cached_str = ",".join(acture_names + [ids_name]) + init_attr_str = get_initializer_attrs(acture_names) + + meta_str = ":".join([ + param, names_str, dims_str, mode, grad.name, cached_str, + init_attr_str, entry_attr + ]) + print("large_scale_metas: {}".format(meta_str)) + large_scale_kv_metas.append(meta_str) + + program.global_block().append_op( + type="lookup_sparse_table_init", + inputs=None, + outputs=None, + attrs={"large_scale_metas": large_scale_kv_metas}) + + # todo: need delete unused var. + return program + + +def get_distributed_from_listen_and_serv(program, origin_program): + op = get_op_by_type(program.global_block(), "listen_and_serv") + sparse_varnames = get_sparse_tablenames(origin_program, True) + sparse_params = [] + grad_to_params = op.attr('sparse_grad_to_param') + for grad_to_param in grad_to_params: + _, param = grad_to_param.split(":") + if _orig_varname(param) in sparse_varnames: + sparse_params.append(param) + return sparse_params + + +def delete_unused_in_main_pass(program, config): + origin_program = config.get_origin_main_program() + sparse_params = get_distributed_from_listen_and_serv(program, + origin_program) + + for var in sparse_params: + if program.global_block().has_var(var): + program.global_block()._remove_var(var) + return program + + +def delete_unused_in_startup_pass(program, main_program, config): + origin_program = config.get_origin_main_program() + sparse_params = get_distributed_from_listen_and_serv(main_program, + origin_program) + remove_ops = [] + + for op in program.global_block().ops: + if op.type in ["recv", "fetch_barrier", "concat"]: + continue + + for key in op.output_names: + if op.output(key)[0] in sparse_params: + remove_ops.append(op) + + all_ops = program.global_block().ops + op_idxs = [all_ops.index(op) for op in remove_ops] + + for idx in op_idxs[::-1]: + program.global_block()._remove_op(idx) + + for var in sparse_params: + if program.global_block().has_var(var): + program.global_block()._remove_var(var) + + return program + + +def build_pserver_startup_program_pass(program, p_main_program, config): + ps_endpoint = config.get_ps_endpoint() + o_startup_program = config.get_origin_startup_program() + program.random_seed = o_startup_program.random_seed + params = config.param_grad_ep_mapping[ps_endpoint]["params"] + merged_ordervars = [] + + for var in params: + name = var.name + orig_varname = _orig_varname(name) + + for pairs in config.merged_variables_pairs: + merged_p = pairs[0] + if merged_p.merged_var.name == orig_varname: + if merged_p.merged_var.name != merged_p.ordered_vars[0].name: + merged_ordervars.append(merged_p.ordered_vars[0]) + break + + def _get_splited_name_and_shape(varname): + for splited_param in params: + pname = splited_param.name + if _same_or_split_var(pname, varname) and varname != pname: + return pname, splited_param.shape + + for idx, ordered in enumerate(merged_ordervars): + if _same_or_split_var(varname, ordered.name): + return pname, splited_param.shape + + return "", [] + + # 1. create vars in pserver program to startup program + pserver_vars = p_main_program.global_block().vars + + created_var_map = collections.OrderedDict() + for _, var in six.iteritems(pserver_vars): + tmpvar = program.global_block()._clone_variable(var) + created_var_map[var.name] = tmpvar + + # 2. rename op outputs + for op in o_startup_program.global_block().ops: + new_outputs = collections.OrderedDict() + # do not append startup op if var is not on this pserver + op_on_pserver = False + # TODO(gongwb) : remove this line. + if op.type not in ["recv", "fetch_barrier", "concat"]: + for key in op.output_names: + newname, _ = _get_splited_name_and_shape(op.output(key)[0]) + if newname: + op_on_pserver = True + new_outputs[key] = created_var_map[newname] + elif op.output(key)[0] in pserver_vars: + op_on_pserver = True + new_outputs[key] = pserver_vars[op.output(key)[0]] + + if op_on_pserver: + # most startup program ops have no inputs + new_inputs = _get_input_map_from_op(pserver_vars, op) + + if op.type in [ + "gaussian_random", "fill_constant", "uniform_random", + "truncated_gaussian_random" + ]: + op._set_attr("shape", list(new_outputs["Out"].shape)) + + program.global_block().append_op( + type=op.type, + inputs=new_inputs, + outputs=new_outputs, + attrs=op.all_attrs()) + + return program + + +def add_geo_optimizer_pass(program, config): + endpoint = config.get_ps_endpoint() + params = [p for p in config.param_grad_ep_mapping[endpoint]["params"]] + + sparse_tablenames = get_sparse_tablenames(config.get_origin_main_program(), + False) + + for param in params: + _clone_var(program.global_block(), param) + + optimize_block = [] + sparse_grad_to_param = [] + param_to_block_id = [] + pre_block_idx = program.num_blocks - 1 + + for param in params: + per_opt_block = program._create_block(pre_block_idx) + optimize_block.append(per_opt_block) + var_name = param.name + pserver_block = per_opt_block.program.global_block() + param = pserver_block.vars[var_name] + + delta_var_name = "%s.delta" % (param.name) + origin_varname = _orig_varname(param.name) + + if origin_varname in sparse_tablenames: + sparse_grad_to_param.append(":".join([delta_var_name, param.name])) + + delta_var = pserver_block.create_var( + name=delta_var_name, + persistable=False, + type=param.type, + dtype=param.dtype, + shape=param.shape) + + per_opt_block.append_op( + type="sum", + inputs={"X": [param, delta_var]}, + outputs={"Out": param}) + + param_to_block_id.append(delta_var_name + ":" + str(per_opt_block.idx)) + + op = get_op_by_type(program.global_block(), "listen_and_serv") + op._set_attr("optimize_blocks", optimize_block) + op._set_attr("grad_to_block_id", param_to_block_id) + op._set_attr("sparse_grad_to_param", sparse_grad_to_param) + + return program diff --git a/python/paddle/fluid/incubate/fleet/parameter_server/ir/public.py b/python/paddle/fluid/incubate/fleet/parameter_server/ir/public.py new file mode 100644 index 0000000000000000000000000000000000000000..2056e3deb18476748df0e16bc18b59f0a1074d55 --- /dev/null +++ b/python/paddle/fluid/incubate/fleet/parameter_server/ir/public.py @@ -0,0 +1,849 @@ +# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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. + +# Copyright(c) 2020 PaddlePaddle Authors.All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0(the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http: // www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function +from functools import reduce + +import collections +import math +import os + +import six +from paddle.fluid import core +from paddle.fluid.core import CommContext +from paddle.fluid.incubate.fleet.parameter_server.mode import DistributedMode +from paddle.fluid.incubate.fleet.parameter_server.ir import vars_metatools +from paddle.fluid.incubate.fleet.parameter_server.ir.ps_dispatcher import RoundRobin, PSDispatcher + +OP_NAME_SCOPE = "op_namescope" +CLIP_OP_NAME_SCOPE = "@CLIP" +STEP_COUNTER = "@PS_STEP_COUNTER@" +OP_ROLE_VAR_ATTR_NAME = core.op_proto_and_checker_maker.kOpRoleVarAttrName() +RPC_OP_ROLE_ATTR_NAME = core.op_proto_and_checker_maker.kOpRoleAttrName() +RPC_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.RPC +op_role_attr_name = core.op_proto_and_checker_maker.kOpRoleAttrName() +LR_SCHED_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.LRSched +OPT_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.Optimize + + +def _get_lr_ops(program): + lr_ops = [] + for index, op in enumerate(program.global_block().ops): + role_id = int(op.attr(RPC_OP_ROLE_ATTR_NAME)) + if role_id == int(LR_SCHED_OP_ROLE_ATTR_VALUE) or \ + role_id == int(LR_SCHED_OP_ROLE_ATTR_VALUE) | \ + int(OPT_OP_ROLE_ATTR_VALUE): + lr_ops.append(op) + return lr_ops + + +def is_sparse_op(op): + if op.type == "lookup_table" and op.attr('is_sparse') is True and op.attr( + 'is_distributed') is False: + return True + + if op.type == "distributed_lookup_table" and op.attr( + 'is_distributed') is False: + return True + + return False + + +def is_distributed_sparse_op(op): + if op.type == "lookup_table" and op.attr('is_distributed') is True: + return True + + if op.type == "distributed_lookup_table" and op.attr( + 'is_distributed') is True: + return True + + return False + + +def get_sparse_tablename(op): + return op.input("W")[0] + + +def get_sparse_tablenames(program, is_distributed): + tablenames = set() + if is_distributed: + for op in program.global_block().ops: + if is_distributed_sparse_op(op): + tablenames.add(get_sparse_tablename(op)) + else: + for op in program.global_block().ops: + if is_sparse_op(op): + tablenames.add(get_sparse_tablename(op)) + return list(tablenames) + + +class MergedVariable: + def __init__(self, merged, ordered, offsets): + self.merged_var = merged + self.ordered_vars = ordered + self.offsets = offsets + + +class CompileTimeStrategy(object): + def __init__(self, main_program, startup_program, strategy, role_maker): + + self.min_block_size = 8192 + + self.origin_main_program = main_program + self.origin_startup_program = startup_program + + self.strategy = strategy + self.role_maker = role_maker + + self.origin_sparse_pairs = [] + self.origin_dense_pairs = [] + + self.merged_variables_pairs = [] + self.merged_dense_pairs = [] + self.merged_sparse_pairs = [] + + self.merged_variable_map = {} + self.param_name_to_grad_name = {} + self.grad_name_to_param_name = {} + + self.param_grad_ep_mapping = collections.OrderedDict() + self.grad_param_mapping = collections.OrderedDict() + + self._build_var_distributed() + + def get_distributed_mode(self): + trainer = self.strategy.get_trainer_runtime_config() + return trainer.mode + + def is_sync_mode(self): + trainer = self.strategy.get_trainer_runtime_config() + return trainer.mode == DistributedMode.SYNC + + def is_geo_mode(self): + trainer = self.strategy.get_trainer_runtime_config() + return trainer.mode == DistributedMode.GEO + + def is_async_mode(self): + trainer = self.strategy.get_trainer_runtime_config() + return trainer.mode == DistributedMode.ASYNC + + def get_role_id(self): + return self.role_maker.role_id() + + def get_trainers(self): + return self.role_maker.worker_num() + + def get_ps_endpoint(self): + return self.role_maker.get_pserver_endpoints()[self.get_role_id()] + + def get_ps_endpoints(self): + return self.role_maker.get_pserver_endpoints() + + def get_origin_programs(self): + return self.origin_main_program, self.origin_startup_program + + def get_origin_main_program(self): + return self.origin_main_program + + def get_origin_startup_program(self): + return self.origin_startup_program + + def get_sparse_varname_on_ps(self, is_distributed, endpoint=None): + if not endpoint: + endpoint = self.get_ps_endpoint() + + varnames = get_sparse_tablenames(self.get_origin_main_program(), + is_distributed) + ps_sparse_varnames = [] + for varname in varnames: + tables = self.get_var_distributed(varname, True) + for i in range(len(tables)): + table, ep, _ = tables[i] + if ep == endpoint: + ps_sparse_varnames.append(table) + return ps_sparse_varnames + + def build_ctx(self, + vars, + mapping, + is_grad, + is_sparse, + is_send, + is_distributed=False): + def get_grad_var_ep(slices): + names = [] + eps = [] + sections = [] + + for slice in slices: + if self.is_geo_mode(): + if is_send: + names.append("{}.delta".format(slice.name)) + else: + names.append(slice.name) + elif is_grad and self.is_sync_mode() and self.get_trainers( + ) > 1: + names.append("{}.trainer_{}".format(slice.name, + self.get_role_id())) + else: + names.append(slice.name) + + sections.append(slice.shape[0]) + + for ep, pairs in self.param_grad_ep_mapping.items(): + params, grads = pairs["params"], pairs["grads"] + + for var in params + grads: + if slice.name == var.name: + eps.append(ep) + break + return names, eps, sections + + if isinstance(vars, MergedVariable): + name = vars.merged_var.name + slices = mapping[name] + names, eps, sections = get_grad_var_ep(slices) + origin_varnames = [var.name for var in vars.ordered_vars] + else: + name = vars.name + slices = mapping[name] + names, eps, sections = get_grad_var_ep(slices) + origin_varnames = [vars.name] + + trainer_id = self.get_role_id() + aggregate = True + ctx = CommContext(name, names, eps, sections, origin_varnames, + trainer_id, aggregate, is_sparse, is_distributed) + return ctx + + def get_trainer_send_context(self): + send_ctx = {} + distibuted_varnames = get_sparse_tablenames(self.origin_main_program, + True) + + if not self.is_geo_mode(): + for merged in self.merged_dense_pairs: + grad = merged[1] + ctx = self.build_ctx(grad, self.grad_var_mapping, True, False, + True) + send_ctx[ctx.var_name()] = ctx + + for merged in self.merged_sparse_pairs: + param = merged[0] + grad = merged[1] + + param_name = param.merged_var.name + + is_distributed = True if param_name in distibuted_varnames else False + + ctx = self.build_ctx(grad, self.grad_var_mapping, True, True, + True, is_distributed) + send_ctx[ctx.var_name()] = ctx + + if self.is_async_mode(): + name, ctx = self._step_ctx() + send_ctx[name] = ctx + else: + for pairs in self.origin_sparse_pairs: + param, grad = pairs + param_name = param.name + is_distributed = True if param_name in distibuted_varnames else False + + param_ctx = self.build_ctx(param, self.param_var_mapping, False, + True, True, is_distributed) + grad_ctx = self.build_ctx(grad, self.grad_var_mapping, True, + True, True, is_distributed) + + ctx = CommContext(param_ctx.var_name(), + param_ctx.split_varnames(), + param_ctx.split_endpoints(), + param_ctx.sections(), + grad_ctx.origin_varnames(), + param_ctx.trainer_id(), + param_ctx.aggregate(), + param_ctx.is_sparse(), + param_ctx.is_distributed()) + + send_ctx[ctx.var_name()] = ctx + name, ctx = self._step_ctx() + send_ctx[name] = ctx + return send_ctx + + def get_communicator_send_context(self): + send_ctx = {} + distibuted_varnames = get_sparse_tablenames(self.origin_main_program, + True) + + if self.is_geo_mode(): + for pairs in self.merged_dense_pairs: + param = pairs[0] + ctx = self.build_ctx(param, self.param_var_mapping, False, + False, True) + send_ctx[ctx.var_name()] = ctx + + for pairs in self.merged_sparse_pairs: + param = pairs[0] + param_name = param.merged_var.name + is_distributed = True if param_name in distibuted_varnames else False + + ctx = self.build_ctx(param, self.param_var_mapping, False, True, + True, is_distributed) + send_ctx[ctx.var_name()] = ctx + name, ctx = self._step_ctx() + send_ctx[name] = ctx + else: + for merged in self.merged_dense_pairs: + grad = merged[1] + ctx = self.build_ctx(grad, self.grad_var_mapping, True, False, + True) + send_ctx[ctx.var_name()] = ctx + + for merged in self.merged_sparse_pairs: + param, grad = merged + param_name = param.merged_var.name + + is_distributed = True if param_name in distibuted_varnames else False + + ctx = self.build_ctx(grad, self.grad_var_mapping, True, False, + True, is_distributed) + send_ctx[ctx.var_name()] = ctx + + name, ctx = self._step_ctx() + send_ctx[name] = ctx + return send_ctx + + def get_communicator_recv_context(self, recv_type=1): + # recv_type + # 1 : DENSE 2. SPARSE 3. DISTRIBUTED 4. ALL + distibuted_varnames = get_sparse_tablenames(self.origin_main_program, + True) + sparse_varnames = [] + for pairs in self.origin_sparse_pairs: + param, grad = pairs + sparse_varnames.append(param.name) + + dense_recv_ctx = {} + sparse_recv_ctx = {} + distributed_recv_ctx = {} + + for merged in self.merged_variables_pairs: + params = merged[0] + if params.merged_var.name in sparse_varnames: + continue + + ctx = self.build_ctx(params, self.param_var_mapping, False, False, + False) + dense_recv_ctx[ctx.var_name()] = ctx + + for pairs in self.origin_sparse_pairs: + param, grad = pairs + + if param.name in distibuted_varnames: + ctx = self.build_ctx(param, self.param_var_mapping, False, True, + False, True) + distributed_recv_ctx[ctx.var_name()] = ctx + else: + ctx = self.build_ctx(param, self.param_var_mapping, False, True, + False, False) + sparse_recv_ctx[ctx.var_name()] = ctx + + if recv_type == 1: + return dense_recv_ctx + if recv_type == 2: + return sparse_recv_ctx + if recv_type == 3: + return distributed_recv_ctx + if recv_type == 4: + dense_recv_ctx.update(sparse_recv_ctx) + dense_recv_ctx.update(distributed_recv_ctx) + return dense_recv_ctx + assert ValueError( + "recv_type can only be 1/2/3/4, 1 : DENSE 2. SPARSE 3. DISTRIBUTED 4. ALL" + ) + + def get_server_runtime_config(self): + return self.strategy.get_server_runtime_config() + + def get_var_distributed(self, varname, is_param): + var_distributed = [] + offset = 0 + if is_param: + params = self.param_var_mapping[varname] + param_varnames = [var.name for var in params] + for ep, pairs in self.param_grad_ep_mapping.items(): + for p in pairs["params"]: + if p.name in param_varnames: + offset += p.shape[0] + var_distributed.append((p.name, ep, p.shape[0])) + else: + grads = self.grad_var_mapping[varname] + grad_varnames = [var.name for var in grads] + for ep, pairs in self.param_grad_ep_mapping.items(): + for g in pairs["grads"]: + if g.name in grad_varnames: + var_distributed.append((g.name, ep, g.shape[0])) + return var_distributed + + def _step_ctx(self): + name = STEP_COUNTER + trainer_id = self.get_role_id() + endpoints = self.get_ps_endpoints() + sections = [1] * len(endpoints) + names = [name] * len(endpoints) + ctx = CommContext(name, names, endpoints, sections, [name], trainer_id, + True, False, False) + return name, ctx + + def _create_vars_from_blocklist(self, block_list): + """ + Create vars for each split. + NOTE: only grads need to be named for different trainers, use + add_trainer_suffix to rename the grad vars. + Args: + block_list (list[(varname, block_id, block_size)]): List of gradient blocks. + add_trainer_suffix (Bool): Add trainer suffix to new variable's name if set True. + Returns: + var_mapping (collections.OrderedDict(varname->[new_varname_variable])):A dict mapping + from original var name to each var split. + """ + + # varname->[(block_id, current_block_size)] + block_map = collections.OrderedDict() + var_mapping = collections.OrderedDict() + + for block_str in block_list: + varname, offset, size = block_str.split(":") + if varname not in block_map: + block_map[varname] = [] + block_map[varname].append((int(offset), int(size))) + + for varname, split in six.iteritems(block_map): + orig_var = self.merged_variable_map[varname] + + if len(split) == 1: + var_mapping[varname] = [orig_var] + self.var_distributed.add_distributed_var( + origin_var=orig_var, + slice_var=orig_var, + block_id=0, + offset=0, + is_slice=False, + vtype="Param") + else: + var_mapping[varname] = [] + orig_shape = orig_var.shape + orig_dim1_flatten = 1 + + if len(orig_shape) >= 2: + orig_dim1_flatten = reduce(lambda x, y: x * y, + orig_shape[1:]) + + for i, block in enumerate(split): + size = block[1] + rows = size // orig_dim1_flatten + splited_shape = [rows] + if len(orig_shape) >= 2: + splited_shape.extend(orig_shape[1:]) + + new_var_name = "%s.block%d" % (varname, i) + slice_var = vars_metatools.VarStruct( + name=new_var_name, + shape=splited_shape, + dtype=orig_var.dtype, + type=orig_var.type, + lod_level=orig_var.lod_level, + persistable=False) + var_mapping[varname].append(slice_var) + + self.var_distributed.add_distributed_var( + origin_var=orig_var, + slice_var=slice_var, + block_id=i, + offset=-1, + is_slice=False, + vtype="Param") + + return var_mapping + + def _dispatcher(self): + ps_dispatcher = RoundRobin(self.get_ps_endpoints()) + ps_dispatcher.reset() + grad_var_mapping_items = list(six.iteritems(self.grad_var_mapping)) + + sparse_gradnames = [grad.name for _, grad in self.origin_sparse_pairs] + + for grad_varname, splited_vars in grad_var_mapping_items: + if grad_varname in sparse_gradnames: + continue + + send_vars = [] + for _, var in enumerate(splited_vars): + send_vars.append(var) + + recv_vars = [] + for _, var in enumerate(send_vars): + recv_vars.append(self.grad_param_mapping[var]) + + eps = ps_dispatcher.dispatch(recv_vars) + + for i, ep in enumerate(eps): + self.param_grad_ep_mapping[ep]["params"].append(recv_vars[i]) + self.param_grad_ep_mapping[ep]["grads"].append(send_vars[i]) + + for grad_varname, splited_vars in grad_var_mapping_items: + if grad_varname not in sparse_gradnames: + continue + + ps_dispatcher.reset() + + send_vars = [] + for _, var in enumerate(splited_vars): + send_vars.append(var) + + recv_vars = [] + for _, var in enumerate(send_vars): + recv_vars.append(self.grad_param_mapping[var]) + + eps = ps_dispatcher.dispatch(recv_vars) + + for i, ep in enumerate(eps): + self.param_grad_ep_mapping[ep]["params"].append(recv_vars[i]) + self.param_grad_ep_mapping[ep]["grads"].append(send_vars[i]) + + def _slice_variable(self, + var_list, + slice_count, + min_block_size, + uniform=False): + """ + We may need to split dense tensor to one or more blocks and put + them equally onto parameter server. One block is a sub-tensor + aligned by dim[0] of the tensor. + + We need to have a minimal block size so that the calculations in + the parameter server side can gain better performance. By default + minimum block size 8K elements (maybe 16bit or 32bit or 64bit). + + Args: + var_list (list): List of variables. + slice_count (int): Numel of count that variables will be sliced, which + could be the pserver services' count. + min_block_size (int): Minimum split block size. + Returns: + blocks (list[(varname, block_id, current_block_size)]): A list + of VarBlocks. Each VarBlock specifies a shard of the var. + """ + blocks = [] + for var in var_list: + if not uniform: + var_numel = reduce(lambda x, y: x * y, var.shape) + + split_count = 1 + + # if min_block_size == -1: + # split_count = 1 + # else: + # split_count = slice_count + # max_pserver_count = int( + # math.floor(var_numel / float(min_block_size))) + # if max_pserver_count == 0: + # max_pserver_count = 1 + # if max_pserver_count < slice_count: + # split_count = max_pserver_count + block_size = int(math.ceil(var_numel / float(split_count))) + + if len(var.shape) >= 2: + # align by dim1(width) + dim1 = reduce(lambda x, y: x * y, var.shape[1:]) + remains = block_size % dim1 + if remains != 0: + block_size += dim1 - remains + # update split_count after aligning + split_count = int(math.ceil(var_numel / float(block_size))) + for block_id in range(split_count): + curr_block_size = min(block_size, var_numel - ( + (block_id) * block_size)) + block = vars_metatools.VarBlock(var.name, block_id, + curr_block_size) + blocks.append(str(block)) + else: + block_size = var.shape[0] / slice_count + remainder = var.shape[0] % slice_count + + if block_size == 0: + dim0s = [block_size] * remainder + else: + dim0s = [block_size] * slice_count + for i in range(remainder): + dim0s[i] = dim0s[i] + 1 + + dim1 = reduce(lambda x, y: x * y, var.shape[1:]) + + for block_id in range(len(dim0s)): + numel = dim0s[block_id] * dim1 + block = vars_metatools.VarBlock(var.name, block_id, numel) + blocks.append(str(block)) + return blocks + + def _get_param_grad_blocks(self, pairs, min_block_size, uniform=False): + param_list = [] + grad_list = [] + param_grad_set = set() + for p, g in pairs: + # todo(tangwei12) skip parameter marked not trainable + # if type(p) == Parameter and p.trainable == False: + # continue + p = p.merged_var + g = g.merged_var + + if p.name not in param_grad_set: + param_list.append(p) + param_grad_set.add(p.name) + if g.name not in param_grad_set: + grad_list.append(g) + param_grad_set.add(g.name) + + # when we slice var up into blocks, we will slice the var according to + # pserver services' count. A pserver may have two or more listening ports. + grad_blocks = self._slice_variable(grad_list, + len(self.get_ps_endpoints()), + min_block_size, uniform) + + param_blocks = self._slice_variable(param_list, + len(self.get_ps_endpoints()), + min_block_size, uniform) + return param_blocks, grad_blocks + + def _var_slice_and_distribute(self): + # update these mappings for further transpile: + # 1. param_var_mapping : param var name->[split params vars] + # 2. grad_var_mapping : grad var name->[split grads vars] + # 3. grad_param_mapping : grad.blockx->param.blockx + # 4. param_grad_ep_mapping : ep->{"params" : [], "grads" : [] } + + dps, dgs = self._get_param_grad_blocks(self.merged_dense_pairs, -1, + False) + sps, sgs = self._get_param_grad_blocks(self.merged_sparse_pairs, + self.min_block_size, True) + + param_blocks = dps + sps + grad_blocks = dgs + sgs + + assert (len(grad_blocks) == len(param_blocks)) + + # origin_param_name->[splited_param_vars] + self.param_var_mapping = self._create_vars_from_blocklist(param_blocks) + self.grad_var_mapping = self._create_vars_from_blocklist(grad_blocks) + + # dict(grad_splited_var->param_splited_var) + self.grad_param_mapping = collections.OrderedDict() + for g, p in zip(grad_blocks, param_blocks): + g_name, g_bid, _ = g.split(":") + p_name, p_bid, _ = p.split(":") + self.grad_param_mapping[self.grad_var_mapping[g_name][int(g_bid)]] = \ + self.param_var_mapping[p_name][int(p_bid)] + + print_maps = {} + for k, v in self.grad_param_mapping.items(): + print_maps[str(k)] = str(v) + + # create mapping of endpoint->split var to create pserver side program + self.param_grad_ep_mapping = collections.OrderedDict() + [ + self.param_grad_ep_mapping.update({ + ep: { + "params": [], + "grads": [] + } + }) for ep in self.get_ps_endpoints() + ] + + def _build_var_distributed(self): + self.var_distributed = vars_metatools.VarsDistributed() + + sparse_pairs, dense_pairs = self.get_param_grads() + origin_for_sparse = [] + origin_for_dense = [] + param_name_grad_name = dict() + grad_name_to_param_name = dict() + + for param, grad in sparse_pairs: + param = vars_metatools.create_var_struct(param) + grad = vars_metatools.create_var_struct(grad) + origin_for_sparse.append((param, grad)) + + for param, grad in dense_pairs: + param = vars_metatools.create_var_struct(param) + grad = vars_metatools.create_var_struct(grad) + origin_for_dense.append((param, grad)) + + for dense_pair in origin_for_dense: + param, grad = dense_pair + + m_param = MergedVariable(param, [param], [0]) + m_grad = MergedVariable(grad, [grad], [0]) + self.merged_variables_pairs.append((m_param, m_grad)) + self.merged_dense_pairs.append((m_param, m_grad)) + + for sparse_pair in origin_for_sparse: + param, grad = sparse_pair + + m_param = MergedVariable(param, [param], [0]) + m_grad = MergedVariable(grad, [grad], [0]) + self.merged_variables_pairs.append((m_param, m_grad)) + self.merged_sparse_pairs.append((m_param, m_grad)) + + for merged in self.merged_variables_pairs: + m_param, m_grad = merged + self.merged_variable_map[ + m_param.merged_var.name] = m_param.merged_var + self.merged_variable_map[m_grad.merged_var.name] = m_grad.merged_var + + param_merges = [] + param_merges.extend(origin_for_sparse) + param_merges.extend(origin_for_dense) + + for param, grad in param_merges: + param_name_grad_name[param.name] = grad.name + grad_name_to_param_name[grad.name] = param.name + + self.origin_sparse_pairs = origin_for_sparse + self.origin_dense_pairs = origin_for_dense + self.param_name_to_grad_name = param_name_grad_name + self.grad_name_to_param_name = grad_name_to_param_name + + sparse_pair_map = collections.OrderedDict() + + for pair in self.origin_sparse_pairs + self.origin_dense_pairs: + param, grad = pair + sparse_pair_map[param.name] = str(param) + sparse_pair_map[grad.name] = str(grad) + + self._var_slice_and_distribute() + self._dispatcher() + + def get_param_grads(self): + origin_program = self.origin_main_program + + def _get_params_grads(sparse_varnames): + block = origin_program.global_block() + + dense_param_grads = [] + sparse_param_grads = [] + + optimize_params = set() + origin_var_dict = origin_program.global_block().vars + role_id = int(core.op_proto_and_checker_maker.OpRole.Backward) + for op in block.ops: + if _is_opt_role_op(op): + # delete clip op from opt_ops when run in Parameter Server mode + if OP_NAME_SCOPE in op.all_attrs() \ + and CLIP_OP_NAME_SCOPE in op.attr(OP_NAME_SCOPE): + op._set_attr("op_role", role_id) + continue + if op.attr(OP_ROLE_VAR_ATTR_NAME): + param_name = op.attr(OP_ROLE_VAR_ATTR_NAME)[0] + grad_name = op.attr(OP_ROLE_VAR_ATTR_NAME)[1] + if param_name not in optimize_params: + optimize_params.add(param_name) + param_grad = (origin_var_dict[param_name], + origin_var_dict[grad_name]) + + if param_name in sparse_varnames: + sparse_param_grads.append(param_grad) + else: + dense_param_grads.append(param_grad) + return sparse_param_grads, dense_param_grads + + def _get_sparse_varnames(): + varnames = [] + op_types = {"lookup_table": "W"} + for op in origin_program.global_block().ops: + if op.type in op_types.keys() \ + and op.attr('remote_prefetch') is True: + param_name = op.input(op_types[op.type])[0] + varnames.append(param_name) + + return list(set(varnames)) + + sparse_varnames = _get_sparse_varnames() + sparse_param_grads, dense_param_grads = _get_params_grads( + sparse_varnames) + + return sparse_param_grads, dense_param_grads + + +def _is_opt_role_op(op): + # NOTE : depend on oprole to find out whether this op is for + # optimize + op_maker = core.op_proto_and_checker_maker + optimize_role = core.op_proto_and_checker_maker.OpRole.Optimize + if op_maker.kOpRoleAttrName() in op.attr_names and \ + int(op.all_attrs()[op_maker.kOpRoleAttrName()]) == int(optimize_role): + return True + return False + + +def _get_optimize_ops(_program): + block = _program.global_block() + opt_ops = [] + for op in block.ops: + if _is_opt_role_op(op): + # delete clip op from opt_ops when run in Parameter Server mode + if OP_NAME_SCOPE in op.all_attrs() \ + and CLIP_OP_NAME_SCOPE in op.attr(OP_NAME_SCOPE): + op._set_attr( + "op_role", + int(core.op_proto_and_checker_maker.OpRole.Backward)) + continue + opt_ops.append(op) + return opt_ops + + +def _get_varname_parts(varname): + # returns origin, blockid, trainerid + orig_var_name = "" + trainer_part = "" + block_part = "" + trainer_idx = varname.find(".trainer_") + if trainer_idx >= 0: + trainer_part = varname[trainer_idx + 1:] + else: + trainer_idx = len(varname) + block_index = varname.find(".block") + if block_index >= 0: + block_part = varname[block_index + 1:trainer_idx] + else: + block_index = len(varname) + orig_var_name = varname[0:min(block_index, trainer_idx)] + return orig_var_name, block_part, trainer_part + + +def _orig_varname(varname): + orig, _, _ = _get_varname_parts(varname) + return orig diff --git a/python/paddle/fluid/incubate/fleet/parameter_server/ir/trainer_pass.py b/python/paddle/fluid/incubate/fleet/parameter_server/ir/trainer_pass.py new file mode 100644 index 0000000000000000000000000000000000000000..912eee0df0a6f9821066dc5c0285ea27c7e52874 --- /dev/null +++ b/python/paddle/fluid/incubate/fleet/parameter_server/ir/trainer_pass.py @@ -0,0 +1,309 @@ +# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +import paddle.fluid.core as core +import paddle.fluid.framework as framework + +from paddle.fluid.transpiler.details.program_utils import delete_ops +from paddle.fluid.incubate.fleet.parameter_server.ir.public import _get_optimize_ops +from paddle.fluid.incubate.fleet.parameter_server.ir.public import _get_lr_ops +from paddle.fluid.incubate.fleet.parameter_server.ir.public import get_sparse_tablenames +from paddle.fluid.incubate.fleet.parameter_server.mode import DistributedMode + +OP_NAME_SCOPE = "op_namescope" +CLIP_OP_NAME_SCOPE = "@CLIP" +STEP_COUNTER = "@PS_STEP_COUNTER@" + +OP_ROLE_VAR_ATTR_NAME = core.op_proto_and_checker_maker.kOpRoleVarAttrName() +RPC_OP_ROLE_ATTR_NAME = core.op_proto_and_checker_maker.kOpRoleAttrName() +RPC_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.RPC +LR_SCHED_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.LRSched +OPT_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.Optimize +op_role_attr_name = core.op_proto_and_checker_maker.kOpRoleAttrName() + + +def delete_optimizer_pass(program, config): + def _delete_optimizer_op_and_vars(_program, optimize_ops): + optimize_vars = [] + optimize_op_role_vars = [] + optimize_need_delete_vars = [] + + for op in optimize_ops: + optimize_vars.extend(op.input_arg_names) + optimize_op_role_vars.extend(op.attr("op_role_var")) + + optimize_vars = list(set(optimize_vars)) + optimize_op_role_vars = list(set(optimize_op_role_vars)) + + for var in optimize_vars: + if var not in optimize_op_role_vars: + optimize_need_delete_vars.append(var) + need_delete_optimize_vars = list(set(optimize_need_delete_vars)) + + delete_ops(_program.global_block(), optimize_ops) + for var in need_delete_optimize_vars: + if _program.global_block().has_var(var): + _program.global_block()._remove_var(var) + + optimizer_ops = _get_optimize_ops(program) + lr_ops = _get_lr_ops(program) + optimizer_ops.extend(lr_ops) + _delete_optimizer_op_and_vars(program, optimizer_ops) + + return program + + +def distributed_ops_pass(program, config): + trainer_id = config.get_role_id() + + def _get_pull_sparse_ops(_program): + pull_sparse_ops = {} + op_types = {"lookup_table": "W"} + for op in _program.global_block().ops: + if op.type in op_types.keys() \ + and op.attr('remote_prefetch') is True: + param_name = op.input(op_types[op.type])[0] + ops = pull_sparse_ops.get(param_name, []) + ops.append(op) + pull_sparse_ops[param_name] = ops + return pull_sparse_ops + + def _pull_sparse_fuse(_program, pull_sparse_ops): + for param, ops in pull_sparse_ops.items(): + all_ops = program.global_block().ops + op_idxs = [all_ops.index(op) for op in ops] + inputs = [ + program.global_block().vars[op.input("Ids")[0]] for op in ops + ] + w = program.global_block().vars[ops[0].input("W")[0]] + padding_idx = ops[0].attr("padding_idx") + is_distributed = ops[0].attr("is_distributed") + + outputs = [ + program.global_block().vars[op.output("Out")[0]] for op in ops + ] + + for idx in op_idxs[::-1]: + program.global_block()._remove_op(idx) + + inputs_idxs = [-1] * len(inputs) + outputs_idxs = [-1] * len(outputs) + + for idx, op in enumerate(program.global_block().ops): + for i in range(0, len(op.output_names)): + outs = op.output(op.output_names[i]) + for in_id, in_var in enumerate(inputs): + if in_var.name in outs: + inputs_idxs[in_id] = idx + for i in range(0, len(op.input_names)): + ins = op.input(op.input_names[i]) + for out_id, out_var in enumerate(outputs): + if out_var.name in ins: + outputs_idxs[out_id] = idx + + tables = config.get_var_distributed(w.name, True) + + pserver_endpoints = config.get_ps_endpoints() + + tablenames, eps, sections, = [], [], [] + for table in tables: + tablenames.append(table[0]) + eps.append(table[1]) + sections.append(table[2]) + + if min(outputs_idxs) - max(inputs_idxs) >= 1: + distributed_idx = max(inputs_idxs) + 1 + + program.global_block()._insert_op( + index=distributed_idx, + type="distributed_lookup_table", + inputs={"Ids": inputs, + 'W': w}, + outputs={"Outputs": outputs}, + attrs={ + "table_names": tablenames, + "endpoints": eps, + "is_distributed": is_distributed, + "pserver_num": len(pserver_endpoints), + "padding_idx": padding_idx, + "trainer_id": trainer_id + }) + else: + raise ValueError( + "something wrong with Fleet, submit a issue is recommended") + + pull_sparse_ops = _get_pull_sparse_ops(program) + _pull_sparse_fuse(program, pull_sparse_ops) + return program + + +def append_send_ops_pass(program, config): + mode = config.get_distributed_mode() + trainer_id = config.get_role_id() + pserver_endpoints = config.get_ps_endpoints() + + def _append_send_op(union_vars, queue): + + if queue == STEP_COUNTER: + send_input_vars = [] + else: + send_input_vars = [ + program.global_block().vars[union_var] + for union_var in union_vars + ] + + dummy_output = [] + if mode in [DistributedMode.SYNC, DistributedMode.HALF_ASYNC]: + dummy_output = program.global_block().create_var( + name=framework.generate_control_dev_var_name()) + + program.global_block().append_op( + type="send", + inputs={"X": send_input_vars}, + outputs={"Out": dummy_output}, + attrs={ + "send_varnames": [queue], + "merge_add": True, + "use_send_handler": False, + "endpoints": pserver_endpoints, + RPC_OP_ROLE_ATTR_NAME: RPC_OP_ROLE_ATTR_VALUE + }) + + return dummy_output + + def _append_barrier_op(dummys): + program.global_block().append_op( + type="send_barrier", + inputs={"X": dummys}, + outputs={"Out": []}, + attrs={ + "endpoints": pserver_endpoints, + "trainer_id": trainer_id, + "half_async": True, + RPC_OP_ROLE_ATTR_NAME: RPC_OP_ROLE_ATTR_VALUE + }) + + dummys = [] + + sends = config.get_trainer_send_context() + + for merged_name, send in sends.items(): + dummys.append(_append_send_op(send.origin_varnames(), merged_name)) + + if mode in [DistributedMode.SYNC, DistributedMode.HALF_ASYNC]: + _append_barrier_op(dummys) + + return program + + +def init_from_server_pass(program, config): + fetch_barrier_out = program.global_block().create_var( + name=framework.generate_control_dev_var_name()) + + recv_ctx = config.get_communicator_recv_context(recv_type=1) + recv_varnames = [] + + for name, ctxs in recv_ctx.items(): + recv_varnames.extend(ctxs.origin_varnames()) + + program.global_block().append_op( + type="recv", + inputs={"X": []}, + outputs={"Out": []}, + attrs={ + "recv_varnames": recv_varnames, + "trainer_id": config.get_role_id(), + RPC_OP_ROLE_ATTR_NAME: RPC_OP_ROLE_ATTR_VALUE + }) + + program.global_block().append_op( + type="fetch_barrier", + inputs={}, + outputs={"Out": fetch_barrier_out}, + attrs={ + "endpoints": config.get_ps_endpoints(), + "trainer_id": config.get_role_id(), + RPC_OP_ROLE_ATTR_NAME: RPC_OP_ROLE_ATTR_VALUE + }) + return program + + +def fake_init_ops_pass(program, config): + origin_program = config.get_origin_main_program() + + def _get_sparse_table_names(): + dist_varnames = get_sparse_tablenames(origin_program, True) + sparse_varnames = get_sparse_tablenames(origin_program, False) + return list(set(dist_varnames + sparse_varnames)) + + def _fake_init_sparsetable(sparse_table_names): + #delete table init op + for table_name in sparse_table_names: + table_var = program.global_block().vars[table_name] + table_param_init_op = [] + for op in program.global_block().ops: + if table_name in op.output_arg_names: + table_param_init_op.append(op) + init_op_num = len(table_param_init_op) + if init_op_num != 1: + raise ValueError("table init op num should be 1, now is " + str( + init_op_num)) + table_init_op = table_param_init_op[0] + program.global_block().append_op( + type="fake_init", + inputs={}, + outputs={"Out": table_var}, + attrs={"shape": table_init_op.attr('shape')}) + delete_ops(program.global_block(), table_param_init_op) + + sparse_tables = _get_sparse_table_names() + _fake_init_sparsetable(sparse_tables) + + return program + + +def delet_extra_optimizes_pass(program, config): + optimize_vars = [] + optimize_op_role_vars = [] + optimize_need_delete_vars = [] + + origin_program = config.get_origin_main_program() + for op in _get_optimize_ops(origin_program): + optimize_vars.extend(op.input_arg_names) + optimize_op_role_vars.extend(op.attr("op_role_var")) + + optimize_vars = list(set(optimize_vars)) + optimize_op_role_vars = list(set(optimize_op_role_vars)) + + for var in optimize_vars: + if var not in optimize_op_role_vars: + optimize_need_delete_vars.append(var) + need_delete_optimize_vars = list(set(optimize_need_delete_vars)) + + init_ops = [] + for var in need_delete_optimize_vars: + param_init_op = [] + for op in program.global_block().ops: + if var in op.output_arg_names: + param_init_op.append(op) + init_ops.extend(param_init_op) + delete_ops(program.global_block(), init_ops) + + for var in need_delete_optimize_vars: + if program.global_block().has_var(var): + program.global_block()._remove_var(var) + + return program diff --git a/python/paddle/fluid/incubate/fleet/parameter_server/ir/ufind.py b/python/paddle/fluid/incubate/fleet/parameter_server/ir/ufind.py new file mode 100644 index 0000000000000000000000000000000000000000..aa63af7dcf7ac85031fb00ca4c39fb36d7e588b8 --- /dev/null +++ b/python/paddle/fluid/incubate/fleet/parameter_server/ir/ufind.py @@ -0,0 +1,66 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + + +class UnionFind(object): + """ Union-find data structure. + + Union-find is a data structure that keeps track of a set of elements partitioned + into a number of disjoint (non-overlapping) subsets. + + Reference: + https://en.wikipedia.org/wiki/Disjoint-set_data_structure + + Args: + elements(list): The initialize element list. + """ + + def __init__(self, elementes=None): + self._parents = [] # index -> parent index + self._index = {} # element -> index + self._curr_idx = 0 + if not elementes: + elementes = [] + for ele in elementes: + self._parents.append(self._curr_idx) + self._index.update({ele: self._curr_idx}) + self._curr_idx += 1 + + def find(self, x): + # Find the root index of given element x, + # execute the path compress while findind the root index + if not x in self._index: + return -1 + idx = self._index[x] + while idx != self._parents[idx]: + t = self._parents[idx] + self._parents[idx] = self._parents[t] + idx = t + return idx + + def union(self, x, y): + # Union two given element + x_root = self.find(x) + y_root = self.find(y) + + if x_root == y_root: + return + self._parents[x_root] = y_root + + def is_connected(self, x, y): + # If two given elements have the same root index, + # then they are connected. + return self.find(x) == self.find(y) diff --git a/python/paddle/fluid/incubate/fleet/parameter_server/ir/vars_metatools.py b/python/paddle/fluid/incubate/fleet/parameter_server/ir/vars_metatools.py new file mode 100644 index 0000000000000000000000000000000000000000..c8f3643b25be0780bbdfd1668d849ab00ece355c --- /dev/null +++ b/python/paddle/fluid/incubate/fleet/parameter_server/ir/vars_metatools.py @@ -0,0 +1,182 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function +from paddle.fluid.framework import Variable +from paddle.fluid import core + + +class VarBlock: + def __init__(self, varname, offset, size): + self.varname = varname + # NOTE: real offset is offset * size + self.offset = offset + self.size = size + + def __str__(self): + return "%s:%d:%d" % (self.varname, self.offset, self.size) + + +def create_var_struct(var): + if var.type == core.VarDesc.VarType.SELECTED_ROWS: + lod_level = None + elif var.type == core.VarDesc.VarType.LOD_TENSOR: + lod_level = var.lod_level + else: + raise ValueError("can only support SELECTED_ROWS/LOD_TENSOR now") + + return VarStruct(var.name, var.shape, var.dtype, var.type, lod_level, + var.persistable) + + +class VarStruct(object): + """ + record part properties of a Variable in python. + """ + + def __init__(self, name, shape, dtype, type, lod_level, persistable): + self.name = name + self.shape = shape + self.dtype = dtype + self.type = type + self.lod_level = lod_level + self.persistable = persistable + + def __str__(self): + return "N: {}, S: {}, D: {}, T: {}, LL: {}, P: {}".format( + self.name, self.shape, self.dtype, self.type, self.lod_level, + self.persistable) + + +class VarDistributed(object): + """ + a class to record the var distributed on parameter servers. + the class will record the relationship between origin var and slice var. + the slice var's properties, such as type/shape/offset/endpoint. + """ + + def __init__(self, + origin_var, + slice_var, + is_slice=None, + block_id=None, + offset=None, + vtype=None, + endpoint=None): + """ + Args: + origin_var(Variable|VarStruct): origin var properties + slice_var(Variable|VarStruct): slice var properties + is_slice(bool|None): slice or not, slice_var=True/False and its block size > 8192 are the judgement standard. + block_id(int|None): the number about the slice var. + offset(int|None): if the slice var is sliced, offset is the numel before the var. + vtype(str|None): a tag, such as Optimizer/Param/RemoteProfetch. + endpoint(str|None): which parameter the slice var on, such as "127.0.0.1:1001" + """ + + if isinstance(origin_var, Variable): + self.origin = create_var_struct(origin_var) + else: + self.origin = origin_var + + if isinstance(slice_var, Variable): + self.slice = create_var_struct(slice_var) + else: + self.slice = slice_var + + if self.equal(self.origin, self.slice): + self.is_slice = False + self.block_id = 0 + self.offset = 0 + else: + self.is_slice = True + self.block_id = 0 + self.offset = 0 + + if is_slice is not None: + self.is_slice = is_slice + if block_id is not None: + self.block_id = block_id + if offset is not None: + self.offset = offset + + self.vtype = vtype + self.endpoint = endpoint + + @staticmethod + def equal(var1, var2): + """ + the two var is equal or not. + Returns: + bool: equal will return True else False + """ + assert isinstance(var1, VarStruct) and isinstance(var2, VarStruct) + + return var1.name == var2.name and \ + var1.type == var2.type and \ + var1.shape == var2.shape and \ + var1.dtype == var2.dtype and \ + var1.lod_level == var2.lod_level and \ + var1.persistable == var2.persistable + + def __str__(self): + origin_var_str = "{name} : fluid.{type}.shape{shape}.astype({dtype})". \ + format(i="{", e="}", name=self.origin.name, type=self.origin.type, + shape=self.origin.shape, dtype=self.origin.dtype) + + slice_var_str = "{name} : fluid.{type}.shape{shape}.astype({dtype})" \ + ".slice({is_slice}).block({block_id}).offset({offset})". \ + format(i="{", e="}", name=self.slice.name, type=self.slice.type, + shape=self.slice.shape, dtype=self.slice.dtype, + is_slice=self.is_slice, block_id=self.block_id, offset=self.offset) + + return "var owned: {}, origin var: ( {} ), slice var: ( {} ), endpoint: {} ".format( + self.vtype, origin_var_str, slice_var_str, self.endpoint) + + +class VarsDistributed(object): + """ + a gather about VarDistributed with many methods to find distributed vars. + through the class, we can get overview about the distributed parameters on parameter servers. + this class may centralized and convenient for developer to manage and get variable's distribute. + other module can also use this to find variables such io.py. + """ + + def __init__(self): + self.distributed_vars = [] + + def add_distributed_var(self, + origin_var, + slice_var, + is_slice=None, + block_id=None, + offset=None, + vtype=None, + endpoint=None): + """ + add distributed var in this. + + Args: + origin_var(Variable|VarStruct): origin var properties + slice_var(Variable|VarStruct): slice var properties + is_slice(bool|None): slice or not, slice_var=True/False and its block size > 8192 are the judgement standard. + block_id(int|None): the number about the slice var. + offset(int|None): if the slice var is sliced, offset is the numel before the var. + vtype(str|None): a tag, such as Optimizer/Param/RemoteProfetch. + endpoint(str|None): which parameter the slice var on, such as "127.0.0.1:1001" + Returns: + None + """ + self.distributed_vars.append( + VarDistributed(origin_var, slice_var, is_slice, block_id, offset, + vtype, endpoint)) diff --git a/python/paddle/fluid/tests/unittests/test_checkpoint_notify_op.py b/python/paddle/fluid/incubate/fleet/parameter_server/mode.py similarity index 52% rename from python/paddle/fluid/tests/unittests/test_checkpoint_notify_op.py rename to python/paddle/fluid/incubate/fleet/parameter_server/mode.py index 839ed5793c9c1f67733378889d08e06919f6cb1a..0733f9b8a23e42f14817b603f0ca3a3d02b132bf 100644 --- a/python/paddle/fluid/tests/unittests/test_checkpoint_notify_op.py +++ b/python/paddle/fluid/incubate/fleet/parameter_server/mode.py @@ -12,25 +12,17 @@ # See the License for the specific language governing permissions and # limitations under the License. -from __future__ import print_function -import unittest -import paddle.fluid as fluid +class PSMode: + """ + There are various mode for fleet, each of them is designed for different model. + """ + TRANSPILER = 1 + PSLIB = 2 -class TestCheckpointNotifyOp(unittest.TestCase): - def test_checkpoint_notify_op(self): - program = fluid.Program() - attrs = {} - attrs['epmap'] = [] - attrs['dir'] = '' - attrs['lookup_table'] = '' - program.current_block().append_op( - type='checkpoint_notify', inputs={}, outputs={}, attrs=attrs) - - exe = fluid.Executor(fluid.CPUPlace()) - exe.run(program) - - -if __name__ == '__main__': - unittest.main() +class DistributedMode: + SYNC = 0 + ASYNC = 1 + HALF_ASYNC = 2 + GEO = 3 diff --git a/python/paddle/fluid/incubate/fleet/parameter_server/pslib/__init__.py b/python/paddle/fluid/incubate/fleet/parameter_server/pslib/__init__.py index c1ec749ac1fac35b9295689afa282adc765f49e8..402250455f79dee24bc87ea7fb9136ae24a68e23 100644 --- a/python/paddle/fluid/incubate/fleet/parameter_server/pslib/__init__.py +++ b/python/paddle/fluid/incubate/fleet/parameter_server/pslib/__init__.py @@ -20,7 +20,7 @@ import paddle.fluid as fluid from paddle.fluid.framework import Program from paddle.fluid.incubate.fleet.base.fleet_base import Fleet -from paddle.fluid.incubate.fleet.base.fleet_base import Mode +from paddle.fluid.incubate.fleet.base.mode import Mode from paddle.fluid.incubate.fleet.base.fleet_base import DistributedOptimizer from paddle.fluid.incubate.fleet.base.role_maker import MPISymetricRoleMaker @@ -59,7 +59,6 @@ class PSLib(Fleet): init_worker(): will be called by user. When a user knows current process is_server(), he/she should call init_worker() to initialize global information about worker and connect worker with pserver. You should run startup program before init_worker. - Args: executor(Executor): The executor to run for init server. programs(Program|None): The program that need to run. @@ -134,7 +133,6 @@ class PSLib(Fleet): def init_server(self, model_dir=None, **kwargs): """ init_server() will be called by user. It will load model from model_dir. - Args: model_dir(str): load model path, can be local or hdfs/afs path. kwargs: user-defined attributes, currently support following: @@ -142,10 +140,8 @@ class PSLib(Fleet): 0 is for load whole model, 1 is for load delta model (load diff), default is 0. - Example: >>> fleet.init_server("/you/path/to/model", mode = 0) - """ mode = kwargs.get("mode", 0) self._role_maker._barrier_worker() @@ -208,19 +204,14 @@ class PSLib(Fleet): def distributed_optimizer(self, optimizer, strategy={}): """ distributed_optimizer - Args: optimizer(Optimizer): optimizer strategy(dict): strategy - Examples: .. code-block:: python - fleet.distributed_optimizer(optimizer) - Returns: optimizer(DownpourOptimizer): downpour optimizer - """ self._optimizer = DownpourOptimizer(optimizer, strategy) return self._optimizer @@ -234,7 +225,6 @@ class PSLib(Fleet): export_for_deployment=True): """ save pserver model called from a worker - Args: executor(Executor): fluid executor dirname(str): save model path @@ -242,12 +232,9 @@ class PSLib(Fleet): target_vars(list): default None main_program(Program): default None export_for_deployment(bool): default None - Examples: .. code-block:: python - fleet.save_inference_model(dirname="hdfs:/my/path") - """ self._fleet_ptr.save_model(dirname, 0) @@ -255,15 +242,11 @@ class PSLib(Fleet): """ print stat info of table_id, format: tableid, feasign size, mf size - Args: table_id(int): the id of table - Example: .. code-block:: python - fleet.print_table_stat(0) - """ self._role_maker._barrier_worker() if self._role_maker.is_first_worker(): @@ -274,7 +257,6 @@ class PSLib(Fleet): """ save presistable parameters, when using fleet, it will save sparse and dense feature - Args: executor(Executor): fluid executor dirname(str): save path. It can be hdfs/afs path or local path @@ -284,12 +266,9 @@ class PSLib(Fleet): 1 means save delta pserver model (save diff), 2 means save xbox base, 3 means save batch model. - Example: .. code-block:: python - fleet.save_persistables(dirname="/you/path/to/model", mode = 0) - """ mode = kwargs.get("mode", 0) self._fleet_ptr.client_flush() @@ -302,7 +281,6 @@ class PSLib(Fleet): """ save sparse cache table, when using fleet, it will save sparse cache table - Args: executor(Executor): fluid executor dirname(str): save path. It can be hdfs/afs path or local path @@ -311,15 +289,11 @@ class PSLib(Fleet): mode(int): define for feature extension in the future, currently no use, will pass a default value 0 table_id(int): which table to save cache, default is 0 - Returns: feasign_num(int): cache feasign num - Example: .. code-block:: python - fleet.save_cache_model(None, dirname="/you/path/to/model", mode = 0) - """ mode = kwargs.get("mode", 0) table_id = kwargs.get("table_id", 0) @@ -349,10 +323,8 @@ class PSLib(Fleet): """ shrink cvm of all sparse embedding in pserver, the decay rate is defined as "show_click_decay_rate" in fleet_desc.prototxt - Example: >>> fleet.shrink_sparse_table() - """ self._role_maker._barrier_worker() if self._role_maker.is_first_worker(): @@ -367,7 +339,6 @@ class PSLib(Fleet): def shrink_dense_table(self, decay, emb_dim=11, scope=None, table_id=None): """ shrink batch_sum in pserver by multiplying by decay - Args: decay(float): the decay rate, usually range in (0, 1) emb_dim(int): one element's length in datanorm layer @@ -375,12 +346,10 @@ class PSLib(Fleet): table_id(int): table id of shrinking dense table. None means shrink all, you should specify it when using multiple scopes, default is None. - Example: >>> fleet.shrink_dense_table(0.98, 11, myscope1, 1) >>> fleet.shrink_dense_table(0.98, 11, myscope1, 2) >>> fleet.shrink_dense_table(0.98, 11, myscope2, 3) - """ if scope is None: scope = fluid.global_scope() @@ -405,13 +374,10 @@ class PSLib(Fleet): def clear_one_table(self, table_id): """ clear_one_table() will be called by user. It will clear one table. - Args: table_id(int): table id - Examples: .. code-block:: python - fleet.clear_one_table(0) """ self._role_maker._barrier_worker() @@ -422,12 +388,9 @@ class PSLib(Fleet): def clear_model(self): """ clear_model() will be called by user. It will clear sparse model. - Examples: .. code-block:: python - fleet.clear_model() - """ self._role_maker._barrier_worker() if self._role_maker.is_first_worker(): @@ -437,12 +400,9 @@ class PSLib(Fleet): def clear_model(self): """ clear_model() will be called by user. It will clear sparse model. - Examples: .. code-block:: python - fleet.clear_model() - """ self._role_maker._barrier_worker() if self._role_maker.is_first_worker(): @@ -452,7 +412,6 @@ class PSLib(Fleet): def load_one_table(self, table_id, model_path, **kwargs): """ load pslib model for one table or load params from paddle model - Args: table_id(int): load table id model_path(str): load model path, can be local or hdfs/afs path @@ -467,25 +426,20 @@ class PSLib(Fleet): var_names(list): var name list load_combine(bool): load from a file or split param files default False. - Examples: .. code-block:: python - # load pslib model for one table fleet.load_one_table(0, "hdfs:/my_fleet_model/20190714/0/") fleet.load_one_table(1, "hdfs:/xx/xxx", mode = 0) - # load params from paddle model fleet.load_one_table(2, "hdfs:/my_paddle_model/", scope = my_scope, model_proto_file = "./my_program.bin", load_combine = False) - # below is how to save proto binary file with open("my_program.bin", "wb") as fout: my_program = fluid.default_main_program() fout.write(my_program.desc.serialize_to_string()) - """ self._role_maker._barrier_worker() mode = kwargs.get("mode", 0) @@ -511,7 +465,6 @@ class PSLib(Fleet): load_combine=False): """ load params from paddle model, and push params to pserver - Args: scope(Scope): Scope object table_id(int): the id of table to load @@ -520,7 +473,6 @@ class PSLib(Fleet): can be local or hdfs/afs file var_names(list): load var names load_combine(bool): load from a file or split param files - """ self._role_maker._barrier_worker() if self._role_maker.is_first_worker(): @@ -595,18 +547,14 @@ class PSLib(Fleet): usually for online predict) 3: load batch model (do some statistic works in checkpoint, such as calculate unseen days of each feasign) - Args: model_dir(str): if you use hdfs, model_dir should starts with 'hdfs:', otherwise means local dir kwargs(dict): user-defined properties. mode(int): the modes illustrated above, default 0 - Examples: .. code-block:: python - fleet.load_model("afs:/user/path/") - """ mode = kwargs.get("mode", 0) self._role_maker._barrier_worker() @@ -617,18 +565,14 @@ class PSLib(Fleet): def save_model(self, model_dir=None, **kwargs): """ save pslib model, the modes are same with load model. - Args: model_dir(str): if you use hdfs, model_dir should starts with 'hdfs:', otherwise means local dir kwargs(dict): user-defined properties. mode(int): the modes illustrated above, default 0 - Examples: .. code-block:: python - fleet.save_model("afs:/user/path/") - """ mode = kwargs.get("mode", 0) prefix = kwargs.get("prefix", None) @@ -640,7 +584,6 @@ class PSLib(Fleet): def save_one_table(self, table_id, model_dir, **kwargs): """ save pslib model's one table, the modes are same with load model. - Args: table_id(int): table id model_dir(str): if you use hdfs, model_dir should starts with @@ -649,12 +592,9 @@ class PSLib(Fleet): mode(int): the modes illustrated above, default 0 prefix(str): the parts to save can have prefix, for example, part-prefix-000-00000 - Examples: .. code-block:: python - fleet.save_one_table("afs:/user/path/") - """ mode = kwargs.get("mode", 0) prefix = kwargs.get("prefix", None) @@ -686,7 +626,6 @@ def _prepare_params(input, dtype='float32'): """ preprocess params, this interface is not for users. - Args: input(Variable|list of Variable): Input is a Tensor Variable size(list of int): the embedding dim @@ -695,7 +634,6 @@ def _prepare_params(input, padding_idx(int): padding idx of input param_attr(ParamAttr): To specify the weight parameter property dtype(str): data type of output - """ if param_attr is None: raise ValueError("param_attr must be set") @@ -749,7 +687,6 @@ def _fleet_embedding(input, dtype='float32'): """ add fleet embedding, this interface is not for users. - Args: input(Variable|list of Variable): Input is a Tensor Variable size(list of int): the embedding dim @@ -758,7 +695,6 @@ def _fleet_embedding(input, padding_idx(int): padding idx of input param_attr(ParamAttr): To specify the weight parameter property dtype(str): data type of output - """ # check and set params _prepare_params(input, size, is_sparse, is_distributed, padding_idx, @@ -789,7 +725,6 @@ def _fleet_embedding_v2(input, dtype='float32'): """ add fleet embedding v2, this interface is not for users. - Args: input(Variable|list of Variable): Input is a Tensor Variable size(list of int): the embedding dim @@ -798,7 +733,6 @@ def _fleet_embedding_v2(input, padding_idx(int): padding idx of input param_attr(ParamAttr): To specify the weight parameter property dtype(str): data type of output - """ # check and set params _prepare_params(input, size, is_sparse, is_distributed, padding_idx, @@ -823,10 +757,8 @@ def _fleet_embedding_v2(input, class fleet_embedding(object): """ fleet embedding class, it is used as a wrapper - Example: .. code-block:: python - with fleet_embedding(click_name=label.name): emb = fluid.layers.embedding( input=var, @@ -834,7 +766,6 @@ class fleet_embedding(object): is_sparse=True, is_distributed=True, param_attr=fluid.ParamAttr(name="embedding")) - """ def __init__(self, click_name, scale_sparse_grad=True): @@ -873,11 +804,9 @@ class DownpourOptimizer(DistributedOptimizer): run distributed training. The optimized information will be stored in Fleet() instance who holds the global information about current distributed training. - Args: optimizer(Optimizer): subclass of Optimizer. strategy(any): config for DownpourOptimizer. - Returns: None """ @@ -925,7 +854,6 @@ class DownpourOptimizer(DistributedOptimizer): Because optimizer algorithms run on pserver side. We will make this usable in pserver process, but currently the optimization part is written into Fleet(). A user does not need to care about how to startup a pserver node. - Args: losses (Variable|Variable List): loss variable or loss variable list to run optimization. scopes (Scope| Scope List): scope instance. @@ -933,7 +861,6 @@ class DownpourOptimizer(DistributedOptimizer): in `parameter_list`. parameter_list (list): list of Variables to update. no_grad_set (set|None): set of Variables should be ignored. - Returns: tuple: (optimize_ops, params_grads) which are, list of operators appended; and list of (param, grad) Variables pair for optimization. @@ -943,12 +870,12 @@ class DownpourOptimizer(DistributedOptimizer): losses = [losses] optimize_ops, param_grads, opt_info = \ - self._distributed_optimizer._minimize( - losses, - startup_programs, - parameter_list, - no_grad_set, - self._strategy) + self._distributed_optimizer._minimize( + losses, + startup_programs, + parameter_list, + no_grad_set, + self._strategy) opt_info["mpi_rank"] = fleet.worker_index() opt_info["mpi_size"] = fleet.worker_num() fleet._set_opt_info(opt_info) diff --git a/python/paddle/fluid/incubate/fleet/parameter_server/pslib/node.py b/python/paddle/fluid/incubate/fleet/parameter_server/pslib/node.py index 6febedc8e1811c944b919bee2fcbde37b0bc3ca5..4b600150e0427488c4954d6b00971c034bbf8c32 100644 --- a/python/paddle/fluid/incubate/fleet/parameter_server/pslib/node.py +++ b/python/paddle/fluid/incubate/fleet/parameter_server/pslib/node.py @@ -39,7 +39,7 @@ class DownpourServer(Server): """ DownpourServer class is used to generate server program_desc Args: - server: it is pslib.ServerParameter() + server: it is pslib.ServerParameter() Examples: server = DownpourServer() """ @@ -58,7 +58,7 @@ class DownpourServer(Server): table_id(int): id of sparse params table strategy(dict): the config dict. Returns: - return None + return None """ for table in self._server.downpour_server_param.downpour_table_param: @@ -67,7 +67,7 @@ class DownpourServer(Server): return else: raise ValueError("expect table %s type=%s, but actual type=%s" \ - %(table_id, pslib.PS_SPARSE_TABLE, table.type)) + %(table_id, pslib.PS_SPARSE_TABLE, table.type)) if strategy is None: strategy = dict() table = self._server.downpour_server_param.downpour_table_param.add() @@ -75,18 +75,18 @@ class DownpourServer(Server): table.type = pslib.PS_SPARSE_TABLE support_sparse_key_list = ['sparse_table_class', 'sparse_compress_in_save', 'sparse_shard_num', \ - 'sparse_accessor_class', 'sparse_learning_rate', 'sparse_initial_g2sum', 'sparse_initial_range', \ - 'sparse_weight_bounds', 'sparse_embedx_dim', 'sparse_embedx_threshold', 'sparse_nonclk_coeff', \ - 'sparse_click_coeff', 'sparse_base_threshold', 'sparse_delta_threshold', 'sparse_delta_keep_days', \ - 'sparse_delete_after_unseen_days', 'sparse_show_click_decay_rate', 'sparse_delete_threshold', \ - 'sparse_converter', 'sparse_deconverter', 'sparse_enable_cache', 'sparse_cache_rate', \ - 'sparse_cache_file_num', 'sparse_beta1_decay_rate', 'sparse_beta2_decay_rate', \ - 'sparse_ada_epsilon', 'sparse_optimizer', 'sparse_ssd_unseenday_threshold', \ - 'embed_sparse_optimizer', 'embed_sparse_learning_rate', 'embed_sparse_weight_bounds', \ - 'embed_sparse_initial_range', 'embed_sparse_initial_g2sum', 'embed_sparse_beta1_decay_rate', \ - 'embed_sparse_beta2_decay_rate', 'embedx_sparse_optimizer', 'embedx_sparse_learning_rate', \ - 'embedx_sparse_weight_bounds', 'embedx_sparse_initial_range', 'embedx_sparse_initial_g2sum', \ - 'embedx_sparse_beta1_decay_rate', 'embedx_sparse_beta2_decay_rate'] + 'sparse_accessor_class', 'sparse_learning_rate', 'sparse_initial_g2sum', 'sparse_initial_range', \ + 'sparse_weight_bounds', 'sparse_embedx_dim', 'sparse_embedx_threshold', 'sparse_nonclk_coeff', \ + 'sparse_click_coeff', 'sparse_base_threshold', 'sparse_delta_threshold', 'sparse_delta_keep_days', \ + 'sparse_delete_after_unseen_days', 'sparse_show_click_decay_rate', 'sparse_delete_threshold', \ + 'sparse_converter', 'sparse_deconverter', 'sparse_enable_cache', 'sparse_cache_rate', \ + 'sparse_cache_file_num', 'sparse_beta1_decay_rate', 'sparse_beta2_decay_rate', \ + 'sparse_ada_epsilon', 'sparse_optimizer', 'sparse_ssd_unseenday_threshold', \ + 'embed_sparse_optimizer', 'embed_sparse_learning_rate', 'embed_sparse_weight_bounds', \ + 'embed_sparse_initial_range', 'embed_sparse_initial_g2sum', 'embed_sparse_beta1_decay_rate', \ + 'embed_sparse_beta2_decay_rate', 'embedx_sparse_optimizer', 'embedx_sparse_learning_rate', \ + 'embedx_sparse_weight_bounds', 'embedx_sparse_initial_range', 'embedx_sparse_initial_g2sum', \ + 'embedx_sparse_beta1_decay_rate', 'embedx_sparse_beta2_decay_rate'] for key in strategy: if key not in support_sparse_key_list: @@ -271,7 +271,7 @@ class DownpourServer(Server): strategy(dict): the dense config dict sparse_table_names(list): sparse table names Returns: - return None + return None """ fea_dim = 0 dense_param_vars = [] @@ -289,15 +289,15 @@ class DownpourServer(Server): return else: raise ValueError("expect table %s type=%s, but actual type=%s" \ - %(table_id, pslib.PS_DENSE_TABLE, table.type)) + %(table_id, pslib.PS_DENSE_TABLE, table.type)) if strategy is None: strategy = dict() table = self._server.downpour_server_param.downpour_table_param.add() table.table_id = table_id support_dense_key_list = ['dense_table_class', 'dense_compress_in_save', 'dense_accessor_class', \ - 'dense_optimizer', 'dense_learning_rate', 'dense_avg_decay', 'dense_ada_decay', \ - 'dense_ada_epsilon', 'dense_mom_decay', 'dense_naive_lr'] + 'dense_optimizer', 'dense_learning_rate', 'dense_avg_decay', 'dense_ada_decay', \ + 'dense_ada_epsilon', 'dense_mom_decay', 'dense_naive_lr'] for key in strategy: if key not in support_dense_key_list: @@ -336,7 +336,7 @@ class DownpourServer(Server): strategy(dict): the datanorm config dict sparse_table_names(list): sparse table names Returns: - return None + return None """ fea_dim = 0 dense_param_vars = [] @@ -354,12 +354,12 @@ class DownpourServer(Server): return else: raise ValueError("expect table %s type=%s, but actual type=%s" \ - %(table_id, pslib.PS_DENSE_TABLE, table.type)) + %(table_id, pslib.PS_DENSE_TABLE, table.type)) if strategy is None: strategy = dict() - support_datanorm_key_list = ['datanorm_table_class', 'datanorm_compress_in_save',\ - 'datanorm_accessor_class', 'datanorm_operation', 'datanorm_decay_rate'] + support_datanorm_key_list = ['datanorm_table_class', 'datanorm_compress_in_save', \ + 'datanorm_accessor_class', 'datanorm_operation', 'datanorm_decay_rate'] for key in strategy: if key not in support_datanorm_key_list: @@ -462,7 +462,7 @@ class DownpourWorker(Worker): DownpourWorker class is used to generate worker program_desc Args: window (int): push params frequency - worker: it is pslib.DownpourTrainerParameter + worker: it is pslib.DownpourTrainerParameter Examples: worker = DownpourWorker(1) """ @@ -482,9 +482,8 @@ class DownpourWorker(Worker): slot_key_vars(list): slot key id slot_value_vars(list): slot key value after embedding slot_value_grads(list): grad of all params, default is None - Returns: - return None + return None """ if slot_value_grads is None: slot_value_grad_names = \ @@ -499,9 +498,9 @@ class DownpourWorker(Worker): if var.name + "@GRAD" in all_grad_names: slot_value_grad_names.append(var.name + "@GRAD") sorted_slot_value_vars = [i for i in slot_value_vars if \ - i.name + "@GRAD" in slot_value_grad_names] + i.name + "@GRAD" in slot_value_grad_names] sorted_slot_value_vars += [i for i in slot_value_vars if \ - i.name + "@GRAD" not in slot_value_grad_names] + i.name + "@GRAD" not in slot_value_grad_names] sorted_slot_key_vars = \ [value_to_key[v.name] for v in sorted_slot_value_vars] @@ -538,7 +537,7 @@ class DownpourWorker(Worker): dense_start_table_id(int): dense table start index sparse_table_names(list): sparse table names Returns: - return None + return None """ sparse_table_name_grad = [] for name in sparse_table_names: diff --git a/python/paddle/fluid/incubate/fleet/parameter_server/pslib/optimizer_factory.py b/python/paddle/fluid/incubate/fleet/parameter_server/pslib/optimizer_factory.py index c0be2ca66caf23c75c982f6d7d964f2babd271bb..232d3e0422e5542e1fd13efd80486ff9bb3d4a22 100644 --- a/python/paddle/fluid/incubate/fleet/parameter_server/pslib/optimizer_factory.py +++ b/python/paddle/fluid/incubate/fleet/parameter_server/pslib/optimizer_factory.py @@ -284,7 +284,7 @@ class DistributedAdam(DistributedOptimizerImplBase): "vs %s" % (len(sparse_table_to_index), len(emb_to_table))) for key in sparse_table_to_index: if key not in emb_to_table or \ - sparse_table_to_index[key] != emb_to_table[key]: + sparse_table_to_index[key] != emb_to_table[key]: print("sparse_table_to_index ", sparse_table_to_index) print("emb_to_table ", emb_to_table) raise ValueError("key error: %s" % key) @@ -309,7 +309,7 @@ class DistributedAdam(DistributedOptimizerImplBase): and op.has_attr("AccessorClass"): op._set_attr("AccessorClass", accessor) if one_slot is None: - one_slot = loss.block.program.\ + one_slot = loss.block.program. \ global_block().var(op.input("Ids")[0]) # if accessor is None, use default accessor in op definition diff --git a/python/paddle/fluid/incubate/fleet/tests/fleet_deep_ctr.py b/python/paddle/fluid/incubate/fleet/tests/fleet_deep_ctr.py index f22a13bde55cb2261a3b7ff5fd4342b91f392d65..60378aa98272dae32a97b33e84fc61e71193658c 100644 --- a/python/paddle/fluid/incubate/fleet/tests/fleet_deep_ctr.py +++ b/python/paddle/fluid/incubate/fleet/tests/fleet_deep_ctr.py @@ -19,7 +19,8 @@ import time import paddle.fluid as fluid import paddle.fluid.incubate.fleet.base.role_maker as role_maker from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet -from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory + from paddle.fluid.log_helper import get_logger import ctr_dataset_reader @@ -149,8 +150,7 @@ def train(args): exe = fluid.Executor(fluid.CPUPlace()) fleet.init(role) - strategy = DistributeTranspilerConfig() - strategy.sync_mode = False + strategy = StrategyFactory.create_half_async_strategy() optimizer = fluid.optimizer.SGD(learning_rate=0.0001) optimizer = fleet.distributed_optimizer(optimizer, strategy) diff --git a/python/paddle/fluid/incubate/fleet/utils/fleet_util.py b/python/paddle/fluid/incubate/fleet/utils/fleet_util.py index 2b46459280b614d9e175e1a21f82eac9599db344..3ae61891514ccaa96cc8e7429d1a988a4618173a 100644 --- a/python/paddle/fluid/incubate/fleet/utils/fleet_util.py +++ b/python/paddle/fluid/incubate/fleet/utils/fleet_util.py @@ -23,7 +23,7 @@ import sys import time import paddle.fluid as fluid from paddle.fluid.log_helper import get_logger -from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet as fleet_pslib +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet as fleet_pslib from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet as fleet_transpiler from . import hdfs from .hdfs import * diff --git a/python/paddle/fluid/io.py b/python/paddle/fluid/io.py index 260033f9ef0101ccfeed06c38e360fc12bb78bfb..ffe8939cd7a39cd7835fd9d0ab74dd66d4f24981 100644 --- a/python/paddle/fluid/io.py +++ b/python/paddle/fluid/io.py @@ -108,8 +108,8 @@ def is_persistable(var): res = fluid.io.is_persistable(param) """ if var.desc.type() == core.VarDesc.VarType.FEED_MINIBATCH or \ - var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \ - var.desc.type() == core.VarDesc.VarType.READER: + var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \ + var.desc.type() == core.VarDesc.VarType.READER: return False return var.persistable @@ -232,7 +232,7 @@ def save_vars(executor, This API saves specific variables in the `Program` to files. - There are two ways to specify the variables to be saved: set variables in + There are two ways to specify the variables to be saved: set variables in a list and assign it to the `vars`, or use the `predicate` function to select variables that make `predicate(variable) == True`. The first way has a higher priority. @@ -252,10 +252,10 @@ def save_vars(executor, vars(list[Variable], optional): The list contains all variables to be saved. Default: None predicate(function, optional): The function selects the variables that make - `predicate(variable) == True`. + `predicate(variable) == True`. Default: None filename(str, optional): If you prefer to save all variables in a single file, - use `filename` to specify it. Otherwise, let `filename` be None. + use `filename` to specify it. Otherwise, let `filename` be None. Default: None Returns: @@ -360,7 +360,7 @@ def save_vars(executor, 'save_to_memory': save_to_memory }) - #NOTE(zhiqiu): save op will add variable kLookupTablePath in save_program.desc, + # NOTE(zhiqiu): save op will add variable kLookupTablePath in save_program.desc, # which leads to diff on save_program and its desc. Call _sync_with_cpp # to keep consistency. save_program._sync_with_cpp() @@ -375,7 +375,7 @@ def save_params(executor, dirname, main_program=None, filename=None): :api_attr: Static Graph This operator saves all parameters from the :code:`main_program` to - the folder :code:`dirname` or file :code:`filename`. You can refer to + the folder :code:`dirname` or file :code:`filename`. You can refer to :ref:`api_guide_model_save_reader_en` for more details. Use the :code:`dirname` to specify the saving folder. If you would like to @@ -383,25 +383,25 @@ def save_params(executor, dirname, main_program=None, filename=None): like to save all parameters in a single file, use :code:`filename` to specify the file name. - Note: + Note: Some variables are not Parameter while they are necessary for - training, such as learning rate, global step, etc. So you can NOT save + training, such as learning rate, global step, etc. So you can NOT save and continue your training just by :ref:`api_fluid_io_save_params` and :ref:`api_fluid_io_load_params`. Please use :ref:`api_fluid_io_save_persistables` - and :ref:`api_fluid_io_load_persistables` instead. - - If you want to save your model for the inference, please use the + and :ref:`api_fluid_io_load_persistables` instead. + + If you want to save your model for the inference, please use the :ref:`api_fluid_io_save_inference_model`. You can refer to :ref:`api_guide_model_save_reader_en` for more details. Args: - executor(Executor): The executor to run for saving parameters, You can + executor(Executor): The executor to run for saving parameters, You can refer to :ref:`api_guide_executor_en`. dirname(str, optional): The saving directory path. When you need to save the parameter to the memory, set it to None. main_program(Program, optional): The program whose parameters will be - saved. You can refer to - :ref:`api_guide_Program_en` for more + saved. You can refer to + :ref:`api_guide_Program_en` for more details. If it is None, the default main program will be used. Default: None @@ -418,21 +418,21 @@ def save_params(executor, dirname, main_program=None, filename=None): .. code-block:: python import paddle.fluid as fluid - + params_path = "./my_paddle_model" image = fluid.data(name='img', shape=[None, 28, 28], dtype='float32') label = fluid.data(name='label', shape=[None, 1], dtype='int64') feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace()) predict = fluid.layers.fc(input=image, size=10, act='softmax') - + loss = fluid.layers.cross_entropy(input=predict, label=label) avg_loss = fluid.layers.mean(loss) - + exe = fluid.Executor(fluid.CPUPlace()) exe.run(fluid.default_startup_program()) fluid.io.save_params(executor=exe, dirname=params_path) - # The parameters weights and bias of the fc layer in the network are going to - # be saved in different files in the path "./my_paddle_model" + # The parameters weights and bias of the fc layer in the network are going to + # be saved in different files in the path "./my_paddle_model" """ return save_vars( executor, @@ -552,8 +552,8 @@ def _save_distributed_persistables(executor, dirname, main_program): if var.name in exclude_var_names: return False if var.desc.type() == core.VarDesc.VarType.FEED_MINIBATCH or \ - var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \ - var.desc.type() == core.VarDesc.VarType.READER: + var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \ + var.desc.type() == core.VarDesc.VarType.READER: return False return var.persistable @@ -602,8 +602,8 @@ def save_persistables(executor, dirname, main_program=None, filename=None): This operator saves all persistable variables from :code:`main_program` to the folder :code:`dirname` or file :code:`filename`. You can refer to :ref:`api_guide_model_save_reader_en` for more details. And then - saves these persistables variables to the folder :code:`dirname` or file - :code:`filename`. + saves these persistables variables to the folder :code:`dirname` or file + :code:`filename`. The :code:`dirname` is used to specify the folder where persistable variables are going to be saved. If you would like to save variables in separate @@ -612,14 +612,15 @@ def save_persistables(executor, dirname, main_program=None, filename=None): Args: executor(Executor): The executor to run for saving persistable variables. - You can refer to :ref:`api_guide_executor_en` for + You can refer to :ref:`api_guide_executor_en` for more details. + dirname(str, optional): The saving directory path. When you need to save the parameter to the memory, set it to None. main_program(Program, optional): The program whose persistbale variables will be saved. You can refer to :ref:`api_guide_Program_en` for more details. - If it is None, the default main program will + If it is None, the default main program will be used. Default: None. filename(str, optional): The file to save all variables. If you prefer to @@ -634,20 +635,20 @@ def save_persistables(executor, dirname, main_program=None, filename=None): .. code-block:: python import paddle.fluid as fluid - + dir_path = "./my_paddle_model" file_name = "persistables" image = fluid.data(name='img', shape=[None, 28, 28], dtype='float32') label = fluid.data(name='label', shape=[None, 1], dtype='int64') feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace()) - + predict = fluid.layers.fc(input=image, size=10, act='softmax') loss = fluid.layers.cross_entropy(input=predict, label=label) avg_loss = fluid.layers.mean(loss) exe = fluid.Executor(fluid.CPUPlace()) exe.run(fluid.default_startup_program()) fluid.io.save_persistables(executor=exe, dirname=dir_path, filename=file_name) - # The persistables variables weights and bias in the fc layer of the network + # The persistables variables weights and bias in the fc layer of the network # are going to be saved in the same file named "persistables" in the path # "./my_paddle_model" """ @@ -676,8 +677,8 @@ def load_vars(executor, This API loads variables from files by executor. There are two ways to specify the variables to be loaded: the first way, set - variables in a list and assign it to the `vars`; the second way, use the - `predicate` function to select variables that make `predicate(variable) == True`. + variables in a list and assign it to the `vars`; the second way, use the + `predicate` function to select variables that make `predicate(variable) == True`. The first way has a higher priority. The `dirname` is used to specify the folder where to load variables. @@ -694,7 +695,7 @@ def load_vars(executor, Default: None vars(list[Variable], optional): The list that contains all variables to be loaded. Default: None - predicate(function, optional): The function selects variables that make + predicate(function, optional): The function selects variables that make `predicate(variable) == True`. Default: None filename(str, optional): The file which saved all required variables. If variables @@ -782,15 +783,27 @@ def load_vars(executor, # save origin param shape orig_para_shape = {} load_var_map = {} + + check_vars = [] + sparse_vars = [] + for each_var in vars: assert isinstance(each_var, Variable) + if each_var.type == core.VarDesc.VarType.RAW: continue if isinstance(each_var, Parameter): orig_para_shape[each_var.name] = tuple(each_var.desc.get_shape( )) + + if each_var.type == core.VarDesc.VarType.SELECTED_ROWS: + sparse_vars.append(each_var) + continue + new_var = _clone_var_in_block_(load_block, each_var) + check_vars.append(each_var) + if filename is None: if dirname is None: raise ValueError( @@ -804,6 +817,57 @@ def load_vars(executor, else: load_var_map[new_var.name] = new_var + for each_var in sparse_vars: + assert isinstance(each_var, Variable) + + if filename is not None: + raise ValueError( + "SelectedRows can not be load with load_combine") + + new_var = _clone_var_in_block_(load_block, each_var) + + var_path = os.path.join(dirname, new_var.name) + if not os.path.exists(var_path): + raise ValueError("SelectedRows var {} can not find at {}". + format(new_var.name, var_path)) + + if os.path.isfile(var_path): + load_block.append_op( + type='load', + inputs={}, + outputs={'Out': [new_var]}, + attrs={'file_path': os.path.join(dirname, new_var.name)}) + else: + blocks = [] + block_paths = os.listdir(var_path) + + for block in block_paths: + if block.startswith(new_var.name): + blocks.append(block) + + slices = [] + for block in blocks: + slice = load_block.create_var( + name=block, + type=new_var.type, + shape=new_var.shape, + dtype=new_var.dtype, + persistable=False) + slices.append(slice) + + file_path = os.path.join(var_path, block, "Param") + load_block.append_op( + type='load', + inputs={}, + outputs={'Out': [slice]}, + attrs={'file_path': file_path}) + + load_block.append_op( + type='lookup_sparse_table_merge', + inputs={'X': slices}, + outputs={'Out': new_var}, + attrs={}) + if filename is not None: load_var_list = [] for name in sorted(load_var_map.keys()): @@ -823,7 +887,7 @@ def load_vars(executor, executor.run(load_prog) # check var shape - for each_var in vars: + for each_var in check_vars: if not isinstance(each_var, Parameter): continue var_temp = paddle.fluid.global_scope().find_var(each_var.name) @@ -1116,18 +1180,18 @@ def save_inference_model(dirname, for more details. Note: - The :code:`dirname` is used to specify the folder where inference model + The :code:`dirname` is used to specify the folder where inference model structure and parameters are going to be saved. If you would like to save params of - Program in separate files, set `params_filename` None; if you would like to save all + Program in separate files, set `params_filename` None; if you would like to save all params of Program in a single file, use `params_filename` to specify the file name. Args: dirname(str): The directory path to save the inference model. feeded_var_names(list[str]): list of string. Names of variables that need to be fed data during inference. - target_vars(list[Variable]): list of Variable. Variables from which we can get + target_vars(list[Variable]): list of Variable. Variables from which we can get inference results. - executor(Executor): The executor that saves the inference model. You can refer + executor(Executor): The executor that saves the inference model. You can refer to :ref:`api_guide_executor_en` for more details. main_program(Program, optional): The original program, which will be pruned to build the inference model. If is set None, @@ -1145,7 +1209,7 @@ def save_inference_model(dirname, optimization and re-training. Currently, only True is supported. Default: True. - program_only(bool, optional): If True, It will save inference program only, and do not + program_only(bool, optional): If True, It will save inference program only, and do not save params of Program. Default: False. @@ -1187,7 +1251,7 @@ def save_inference_model(dirname, executor=exe) # In this example, the save_inference_mode inference will prune the default - # main program according to the network's input node (img) and output node(predict). + # main program according to the network's input node (img) and output node(predict). # The pruned inference program is going to be saved in the "./infer_model/__model__" # and parameters are going to be saved in separate files under folder # "./infer_model". @@ -1212,7 +1276,7 @@ def save_inference_model(dirname, main_program = _get_valid_program(main_program) - # remind user to set auc_states to zeros if the program contains auc op + # remind user to set auc_states to zeros if the program contains auc op all_ops = main_program.global_block().ops for op in all_ops: # clear device of Op @@ -1546,7 +1610,7 @@ def _save_persistable_nodes(executor, dirname, graph): for node in persistable_nodes: var_desc = node.var() if var_desc.type() == core.VarDesc.VarType.RAW or \ - var_desc.type() == core.VarDesc.VarType.READER: + var_desc.type() == core.VarDesc.VarType.READER: continue var = program.global_block().create_var( name=var_desc.name(), @@ -1585,7 +1649,7 @@ def _load_persistable_nodes(executor, dirname, graph): for node in persistable_nodes: var_desc = node.var() if var_desc.type() == core.VarDesc.VarType.RAW or \ - var_desc.type() == core.VarDesc.VarType.READER: + var_desc.type() == core.VarDesc.VarType.READER: continue var = program.global_block().create_var( name=var_desc.name(), @@ -1614,7 +1678,7 @@ def save(program, model_path): The parameters contains all the trainable Variable, will save to a file with suffix ".pdparams". The optimizer information contains all the variable used by optimizer. For Adam optimizer, contains beta1, beta2, momentum etc. All the information will save to a file with suffix ".pdopt". (If the optimizer have no variable need to save (like SGD), the fill will not generated). The network description is the description of the program. It's only used for deployment. The description will save to a file with a suffix ".pdmodel". - + Args: program(Program) : The program to saved. model_path(str): the file prefix to save the program. The format is "dirname/file_prefix". If file_prefix is empty str. A exception will be raised @@ -1676,22 +1740,22 @@ def load(program, model_path, executor=None, var_list=None): This function get parameters and optimizer information from program, and then get corresponding value from file. An exception will throw if shape or dtype of the parameters is not match. - This function can also load model file saved with [ save_params, save_persistables, save_vars ]. - var_list can not be None when load single model file + This function can also load model file saved with [ save_params, save_persistables, save_vars ]. + var_list can not be None when load single model file ( filename is not None When save_params, save_persistables or save_vars is called ). - Args: + Args: program(Program): The program will be loaded model_path(str): The file prefix store the program - executor(Executor, optional): The executor used for initialize the parameter + executor(Executor, optional): The executor used for initialize the parameter When startup program is not run. - var_list(list, optional): The variable list to load single model file saved with - [ save_params, save_persistables, save_vars ]. + var_list(list, optional): The variable list to load single model file saved with + [ save_params, save_persistables, save_vars ]. Default: None Returns: None - + Examples: .. code-block:: python @@ -1780,9 +1844,9 @@ def load(program, model_path, executor=None, var_list=None): _logger.error(e) raise e except: - raise RuntimeError( "Failed to load model file , please make sure model file is saved with the " \ - "the following APIs: [ save_params, save_persistables, save_vars ]. " \ - "When these API called, filename CANNOT be None") + raise RuntimeError("Failed to load model file , please make sure model file is saved with the " \ + "the following APIs: [ save_params, save_persistables, save_vars ]. " \ + "When these API called, filename CANNOT be None") return @@ -1842,13 +1906,13 @@ def load_program_state(model_path, var_list=None): :api_attr: Static Graph Load program state from local file - + Args: model_path(str): The file prefix store the program - var_list(list, optional): The variable list to load saved with - [ save_params, save_persistables, save_vars ]. + var_list(list, optional): The variable list to load saved with + [ save_params, save_persistables, save_vars ]. Default: None. - The var_list is only used to get name, + The var_list is only used to get name, will not be modified. Returns: state_dict(dict): the dict store Parameter and optimizer information @@ -1868,7 +1932,7 @@ def load_program_state(model_path, var_list=None): fluid.save( prog, "./temp") program_state = fluid.load_program_state( "./temp") - + """ model_prefix = model_path if model_prefix.endswith(".pdparams"): @@ -1976,19 +2040,19 @@ def set_program_state(program, state_dict): Set program parameter from state_dict - An exception will throw if shape or dtype of the parameters is not match. + An exception will throw if shape or dtype of the parameters is not match. NOTICE: This function MUST called after run start_up_program Args: program(Program): The program to be set state_dict(dict): the dict store Parameter and optimizer information - Returns: + Returns: None - + Examples: .. code-block:: python - + import paddle.fluid as fluid x = fluid.data( name="x", shape=[10, 10], dtype='float32') y = fluid.layers.fc( x, 10) diff --git a/python/paddle/fluid/layers/io.py b/python/paddle/fluid/layers/io.py index 2edfe040245c380718cc72a25a10b8f90baf2f63..d513d44acfff230eb229e161e689fbc60a73c602 100644 --- a/python/paddle/fluid/layers/io.py +++ b/python/paddle/fluid/layers/io.py @@ -28,7 +28,7 @@ from ..framework import convert_np_dtype_to_dtype_, default_main_program, \ default_startup_program, program_guard, Program, Variable from ..layer_helper import LayerHelper from ..unique_name import generate as unique_name -from ..transpiler.distribute_transpiler import DistributedMode + import logging from ..data_feeder import check_dtype, check_type @@ -231,6 +231,8 @@ class ListenAndServ(object): return parent_block def complete_op(self): + from ..incubate.fleet.parameter_server.mode import DistributedMode + main_program = self.helper.main_program current_block = main_program.current_block() parent_block = self.parent_block() @@ -391,7 +393,6 @@ def _py_reader(capacity, name=None, use_double_buffer=True, feed_list=None): - if feed_list is not None: if not isinstance(feed_list, list): raise TypeError("feed_list should be a list of Variable" @@ -557,7 +558,7 @@ def py_reader(capacity, name=None, use_double_buffer=True): """ - :api_attr: Static Graph + :api_attr: Static Graph Create a Python reader for data feeding in Python @@ -726,7 +727,7 @@ def create_py_reader_by_data(capacity, name=None, use_double_buffer=True): """ - :api_attr: Static Graph + :api_attr: Static Graph The OP creates a Python reader for data feeding in Python, it is similar to :ref:`api_fluid_layers_py_reader` except that it can read data from @@ -865,7 +866,7 @@ def double_buffer(reader, place=None, name=None): def read_file(reader): """ - :api_attr: Static Graph + :api_attr: Static Graph Execute the given reader and get data via it. diff --git a/python/paddle/fluid/layers/nn.py b/python/paddle/fluid/layers/nn.py index cde57c9fefd4135ec37c385ff5fc97cd7e0622d3..b73d10ff4e7f26888543828f65de4d4bd0d16233 100644 --- a/python/paddle/fluid/layers/nn.py +++ b/python/paddle/fluid/layers/nn.py @@ -485,9 +485,15 @@ def embedding(input, 'fluid.layers.embedding') check_dtype(dtype, 'dtype', ['float16', 'float32', 'float64'], 'fluid.layers.embedding') - remote_prefetch = is_sparse and (not is_distributed) - if remote_prefetch: - assert is_sparse is True and is_distributed is False + + if is_distributed: + is_distributed = False + warnings.warn( + "is_distributed is go out of use, `fluid.contrib.layers.sparse_embedding` is your needed" + ) + + remote_prefetch = True if is_sparse else False + w = helper.create_parameter( attr=helper.param_attr, shape=size, dtype=dtype, is_bias=False) tmp = helper.create_variable_for_type_inference(dtype) diff --git a/python/paddle/fluid/optimizer.py b/python/paddle/fluid/optimizer.py index 85d07f687e3f68a9e11ddc1938f66545836bf9eb..2ce95131f05603083157ee621875f73172ab12ae 100644 --- a/python/paddle/fluid/optimizer.py +++ b/python/paddle/fluid/optimizer.py @@ -784,9 +784,6 @@ class Optimizer(object): params_grads = sorted(params_grads, key=lambda x: x[0].name) - params_grads, table_param_and_grad, table_optimize_op = \ - self._process_distribute_lookuptable(params_grads) - # 'optimizer(grad_clip)' or 'set_gradient_clip' if self._grad_clip is not None: params_grads = self._grad_clip(params_grads) @@ -798,10 +795,6 @@ class Optimizer(object): params_grads, self.regularization, self._param_device_map) optimize_ops = self._create_optimization_pass(params_grads) - if table_optimize_op is not None: - optimize_ops.append(table_optimize_op) - params_grads.append(table_param_and_grad) - return optimize_ops def apply_optimize(self, loss, startup_program, params_grads): diff --git a/python/paddle/fluid/tests/unittests/CMakeLists.txt b/python/paddle/fluid/tests/unittests/CMakeLists.txt index 17893a12189c150f8182a0cf135d3312a17404c3..4ba3bf4389bfaa62b81eec4b917cf79c5f00ed51 100644 --- a/python/paddle/fluid/tests/unittests/CMakeLists.txt +++ b/python/paddle/fluid/tests/unittests/CMakeLists.txt @@ -19,10 +19,8 @@ list(APPEND MIXED_DIST_TEST_OPS test_dgc_op) list(APPEND MIXED_DIST_TEST_OPS test_dgc_momentum_op) list(APPEND MIXED_DIST_TEST_OPS test_dgc_optimizer) list(APPEND MIXED_DIST_TEST_OPS test_simple_dist_transpiler) -list(APPEND MIXED_DIST_TEST_OPS test_nce_remote_table_op) list(APPEND MIXED_DIST_TEST_OPS test_recv_save_op) list(APPEND MIXED_DIST_TEST_OPS test_transpiler_ops) -list(APPEND MIXED_DIST_TEST_OPS test_lookup_remote_table_op) list(APPEND MIXED_DIST_TEST_OPS test_launch) list(APPEND MIXED_DIST_TEST_OPS test_launch_ps) list(APPEND MIXED_DIST_TEST_OPS test_communicator_async) @@ -57,6 +55,20 @@ if(WIN32) LIST(REMOVE_ITEM TEST_OPS test_avoid_twice_initialization) LIST(REMOVE_ITEM TEST_OPS test_checkpoint_notify_op) + LIST(REMOVE_ITEM TEST_OPS test_distributed_strategy) + LIST(REMOVE_ITEM TEST_OPS test_downpoursgd) + LIST(REMOVE_ITEM TEST_OPS test_fleet) + LIST(REMOVE_ITEM TEST_OPS test_fleet_metric) + LIST(REMOVE_ITEM TEST_OPS test_fleet_nocvm_1) + LIST(REMOVE_ITEM TEST_OPS test_fleet_ps) + LIST(REMOVE_ITEM TEST_OPS test_fleet_rolemaker) + LIST(REMOVE_ITEM TEST_OPS test_fleet_rolemaker_2) + LIST(REMOVE_ITEM TEST_OPS test_fleet_rolemaker_3) + LIST(REMOVE_ITEM TEST_OPS test_fleet_unitaccessor) + LIST(REMOVE_ITEM TEST_OPS test_fleet_utils) + LIST(REMOVE_ITEM TEST_OPS test_lookup_sparse_table_split_op) + LIST(REMOVE_ITEM TEST_OPS test_ps_dispatcher) + # TODO: Fix these unittests failed on Windows LIST(REMOVE_ITEM TEST_OPS test_debugger) list(REMOVE_ITEM TEST_OPS test_fake_init_op) @@ -68,6 +80,7 @@ endif() if(APPLE OR WIN32) LIST(REMOVE_ITEM TEST_OPS test_hdfs) LIST(REMOVE_ITEM TEST_OPS test_fs_interface) + LIST(REMOVE_ITEM TEST_OPS test_fleet_metric) endif() if (NOT ${WITH_GPU}) @@ -330,8 +343,17 @@ if(WITH_DISTRIBUTE) list(REMOVE_ITEM DIST_TEST_OPS "test_dist_base") list(REMOVE_ITEM DIST_TEST_OPS "test_dist_fleet_base") - py_test_modules(test_lookup_remote_table_op MODULES test_lookup_remote_table_op ENVS ${dist_ENVS}) - py_test_modules(test_nce_remote_table_op MODULES test_nce_remote_table_op ENVS ${dist_ENVS}) + # FIXME(seiriosX) will readd after PR 22957 Merged + list(REMOVE_ITEM DIST_TEST_OPS "test_dist_ctr") + list(REMOVE_ITEM DIST_TEST_OPS "test_dist_mnist_lars") + list(REMOVE_ITEM DIST_TEST_OPS "test_dist_mnist_train") + list(REMOVE_ITEM DIST_TEST_OPS "test_dist_save_load") + list(REMOVE_ITEM DIST_TEST_OPS "test_dist_simnet_bow") + list(REMOVE_ITEM DIST_TEST_OPS "test_dist_simnet_bow") + list(REMOVE_ITEM DIST_TEST_OPS "test_dist_text_classification") + list(REMOVE_ITEM DIST_TEST_OPS "test_dist_train") + list(REMOVE_ITEM DIST_TEST_OPS "test_dist_word2vec") + py_test_modules(test_recv_save_op MODULES test_recv_save_op ENVS ${dist_ENVS}) py_test_modules(test_transpiler_ops MODULES test_transpiler_ops ENVS ${dist_ENVS}) py_test_modules(test_communicator_async MODULES test_communicator_async ENVS ${dist_ENVS}) diff --git a/python/paddle/fluid/tests/unittests/dist_fleet_ctr.py b/python/paddle/fluid/tests/unittests/dist_fleet_ctr.py index 1e2b4e221a8cdca4fcaf93b357db02bff63a93fe..6bf95b9d6715bfade20069eec130a676d7edeb55 100644 --- a/python/paddle/fluid/tests/unittests/dist_fleet_ctr.py +++ b/python/paddle/fluid/tests/unittests/dist_fleet_ctr.py @@ -34,6 +34,17 @@ fluid.default_startup_program().random_seed = 1 fluid.default_main_program().random_seed = 1 +def fake_ctr_reader(): + def reader(): + for _ in range(1000): + deep = np.random.random_integers(0, 1e5 - 1, size=16).tolist() + wide = np.random.random_integers(0, 1e5 - 1, size=8).tolist() + label = np.random.random_integers(0, 1, size=1).tolist() + yield [deep, wide, label] + + return reader + + class TestDistCTR2x2(FleetDistRunnerBase): """ For test CTR model, using Fleet api @@ -49,8 +60,8 @@ class TestDistCTR2x2(FleetDistRunnerBase): Returns: avg_cost: LoDTensor of cost. """ - dnn_input_dim, lr_input_dim, train_file_path = ctr_dataset_reader.prepare_data( - ) + dnn_input_dim, lr_input_dim = int(1e5), int(1e5) + dnn_data = fluid.layers.data( name="dnn_data", shape=[-1, 1], @@ -125,7 +136,7 @@ class TestDistCTR2x2(FleetDistRunnerBase): avg_cost = fluid.layers.mean(x=cost) self.feeds = datas - self.train_file_path = train_file_path + self.train_file_path = ["fake1", "fake2"] self.avg_cost = avg_cost self.predict = predict @@ -147,25 +158,13 @@ class TestDistCTR2x2(FleetDistRunnerBase): Args: fleet(Fleet api): the fleet object of Parameter Server, define distribute training role """ - dnn_input_dim, lr_input_dim, train_file_path = ctr_dataset_reader.prepare_data( - ) exe = fluid.Executor(fluid.CPUPlace()) - fleet.init_worker() exe.run(fleet.startup_program) - thread_num = 2 - batch_size = 128 - filelist = [] - for _ in range(thread_num): - filelist.append(train_file_path) - - train_reader = paddle.batch( - paddle.reader.shuffle( - ctr_dataset_reader.CtrReader()._reader_creator(filelist), - buf_size=batch_size * 100), - batch_size=batch_size) + batch_size = 4 + train_reader = paddle.batch(fake_ctr_reader(), batch_size=batch_size) self.reader.decorate_sample_list_generator(train_reader) compiled_prog = fluid.compiler.CompiledProgram( diff --git a/python/paddle/fluid/tests/unittests/dist_fleet_sparse_embedding_ctr.py b/python/paddle/fluid/tests/unittests/dist_fleet_sparse_embedding_ctr.py new file mode 100644 index 0000000000000000000000000000000000000000..c69e1247a9bb8f97350ae79bcc6df1bc645204ea --- /dev/null +++ b/python/paddle/fluid/tests/unittests/dist_fleet_sparse_embedding_ctr.py @@ -0,0 +1,189 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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. +""" +Distribute CTR model for test fleet api +""" + +from __future__ import print_function + +import os +import time + +import random +import numpy as np + +import paddle +import paddle.fluid as fluid + +from test_dist_fleet_base import runtime_main, FleetDistRunnerBase + + +def fake_ctr_reader(): + def reader(): + for _ in range(1000): + deep = np.random.random_integers(0, 1e10, size=16).tolist() + wide = np.random.random_integers(0, 1e10, size=8).tolist() + label = np.random.random_integers(0, 1, size=1).tolist() + yield [deep, wide, label] + + return reader + + +class TestDistCTR2x2(FleetDistRunnerBase): + """ + For test CTR model, using Fleet api + """ + + def net(self, args, batch_size=4, lr=0.01): + """ + network definition + + Args: + batch_size(int): the size of mini-batch for training + lr(float): learning rate of training + Returns: + avg_cost: LoDTensor of cost. + """ + dnn_input_dim, lr_input_dim = 10, 10 + + dnn_data = fluid.layers.data( + name="dnn_data", + shape=[-1, 1], + dtype="int64", + lod_level=1, + append_batch_size=False) + lr_data = fluid.layers.data( + name="lr_data", + shape=[-1, 1], + dtype="int64", + lod_level=1, + append_batch_size=False) + label = fluid.layers.data( + name="click", + shape=[-1, 1], + dtype="int64", + lod_level=0, + append_batch_size=False) + + datas = [dnn_data, lr_data, label] + + if args.reader == "pyreader": + self.reader = fluid.io.PyReader( + feed_list=datas, + capacity=64, + iterable=False, + use_double_buffer=False) + + # build dnn model + initializer = int(os.getenv("INITIALIZER", "0")) + inference = bool(int(os.getenv("INFERENCE", "0"))) + + if initializer == 0: + init = fluid.initializer.Constant(value=0.01) + elif initializer == 1: + init = fluid.initializer.Uniform() + elif initializer == 2: + init = fluid.initializer.Normal() + else: + raise ValueError("error initializer code: {}".format(initializer)) + + dnn_layer_dims = [128, 64, 32] + dnn_embedding = fluid.contrib.layers.sparse_embedding( + input=dnn_data, + size=[dnn_input_dim, dnn_layer_dims[0]], + is_test=inference, + param_attr=fluid.ParamAttr( + name="deep_embedding", initializer=init)) + dnn_pool = fluid.layers.sequence_pool( + input=dnn_embedding, pool_type="sum") + dnn_out = dnn_pool + for i, dim in enumerate(dnn_layer_dims[1:]): + fc = fluid.layers.fc( + input=dnn_out, + size=dim, + act="relu", + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01)), + name='dnn-fc-%d' % i) + dnn_out = fc + + # build lr model + lr_embbding = fluid.contrib.layers.sparse_embedding( + input=lr_data, + size=[lr_input_dim, 1], + is_test=inference, + param_attr=fluid.ParamAttr( + name="wide_embedding", + initializer=fluid.initializer.Constant(value=0.01))) + + lr_pool = fluid.layers.sequence_pool(input=lr_embbding, pool_type="sum") + merge_layer = fluid.layers.concat(input=[dnn_out, lr_pool], axis=1) + predict = fluid.layers.fc(input=merge_layer, size=2, act='softmax') + + acc = fluid.layers.accuracy(input=predict, label=label) + auc_var, _, _ = fluid.layers.auc(input=predict, label=label) + cost = fluid.layers.cross_entropy(input=predict, label=label) + avg_cost = fluid.layers.mean(x=cost) + + self.feeds = datas + self.train_file_path = ["fake1", "fake2"] + self.avg_cost = avg_cost + self.predict = predict + + return avg_cost + + def do_pyreader_training(self, fleet): + """ + do training using dataset, using fetch handler to catch variable + Args: + fleet(Fleet api): the fleet object of Parameter Server, define distribute training role + """ + + exe = fluid.Executor(fluid.CPUPlace()) + fleet.init_worker() + exe.run(fleet.startup_program) + + batch_size = 4 + + train_reader = paddle.batch(fake_ctr_reader(), batch_size=batch_size) + self.reader.decorate_sample_list_generator(train_reader) + + compiled_prog = fluid.compiler.CompiledProgram( + fleet.main_program).with_data_parallel( + loss_name=self.avg_cost.name, + build_strategy=self.strategy.get_build_strategy(), + exec_strategy=self.strategy.get_execute_strategy()) + + for epoch_id in range(1): + self.reader.start() + try: + while True: + loss_val = exe.run(program=compiled_prog, + fetch_list=[self.avg_cost.name]) + loss_val = np.mean(loss_val) + print("TRAIN ---> pass: {} loss: {}\n".format(epoch_id, + loss_val)) + except fluid.core.EOFException: + self.reader.reset() + + model_dir = os.getenv("MODEL_DIR", None) + if model_dir: + fleet.save_inference_model(exe, model_dir, + [feed.name for feed in self.feeds], + self.avg_cost) + fleet.stop_worker() + + +if __name__ == "__main__": + runtime_main(TestDistCTR2x2) diff --git a/python/paddle/fluid/tests/unittests/test_communicator_async.py b/python/paddle/fluid/tests/unittests/test_communicator_async.py index 6c1d55cc29575f85fa309294ed6f44d7827e119a..d032d6d75b5b3a48ea1e752190952f4c52e23b07 100644 --- a/python/paddle/fluid/tests/unittests/test_communicator_async.py +++ b/python/paddle/fluid/tests/unittests/test_communicator_async.py @@ -25,7 +25,7 @@ from paddle.fluid.communicator import Communicator import paddle.fluid.incubate.fleet.base.role_maker as role_maker from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet -from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory class TestCommunicator(unittest.TestCase): @@ -49,11 +49,7 @@ class TestCommunicator(unittest.TestCase): avg_cost = self.net() optimizer = fluid.optimizer.SGD(0.01) - - strategy = DistributeTranspilerConfig() - strategy.sync_mode = False - strategy.runtime_split_send_recv = True - strategy.wait_port = False + strategy = StrategyFactory.create_async_strategy() optimizer = fleet.distributed_optimizer(optimizer, strategy) optimizer.minimize(avg_cost) diff --git a/python/paddle/fluid/tests/unittests/test_communicator_geo.py b/python/paddle/fluid/tests/unittests/test_communicator_geo.py index e3c91b3d15be46f2169c55141b9671aadfa4a4a6..46cae41f3045486837e33722b6c75f91859b65ba 100644 --- a/python/paddle/fluid/tests/unittests/test_communicator_geo.py +++ b/python/paddle/fluid/tests/unittests/test_communicator_geo.py @@ -14,22 +14,23 @@ from __future__ import print_function -import unittest +import os +import sys import time import threading +import subprocess +import unittest import numpy import paddle import paddle.fluid as fluid -from paddle.fluid.communicator import Communicator -from paddle.fluid.transpiler.distribute_transpiler import DistributedMode import paddle.fluid.incubate.fleet.base.role_maker as role_maker from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet -from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory -class TestCommunicator(unittest.TestCase): +class TestCommunicatorGeoEnd2End(unittest.TestCase): def net(self): x = fluid.layers.data(name='x', shape=[13], dtype='float32') y_predict = fluid.layers.fc(input=x, size=1, act=None) @@ -37,47 +38,129 @@ class TestCommunicator(unittest.TestCase): cost = fluid.layers.square_error_cost(input=y_predict, label=y) avg_cost = fluid.layers.mean(cost) - return avg_cost + return avg_cost, x, y - def test_communicator_geo(self): - role = role_maker.UserDefinedRoleMaker( - current_id=0, - role=role_maker.Role.WORKER, - worker_num=2, - server_endpoints=["127.0.0.1:6001", "127.0.0.1:6002"]) + def fake_reader(self): + def reader(): + for i in range(10000): + x = numpy.random.random((1, 13)).astype('float32') + y = numpy.random.randint(0, 2, (1, 1)).astype('int64') + yield x, y - fleet.init(role) - avg_cost = self.net() + return reader + def run_pserver(self, role, strategy): + fleet.init(role) + avg_cost, x, y = self.net() optimizer = fluid.optimizer.SGD(0.01) + optimizer = fleet.distributed_optimizer(optimizer, strategy) + optimizer.minimize(avg_cost) - strategy = DistributeTranspilerConfig() - strategy.sync_mode = False - strategy.runtime_split_send_recv = True - strategy.geo_sgd_mode = True - strategy.wait_port = False + fleet.init_server() + fleet.run_server() + + def run_trainer(self, role, strategy): + place = fluid.core.CPUPlace() + exe = fluid.Executor(place) + + fleet.init(role) + avg_cost, x, y = self.net() + optimizer = fluid.optimizer.SGD(0.01) optimizer = fleet.distributed_optimizer(optimizer, strategy) optimizer.minimize(avg_cost) fleet.init_worker() - time.sleep(10) + exe.run(fleet.startup_program) + + train_reader = paddle.batch(self.fake_reader(), batch_size=24) + feeder = fluid.DataFeeder(place=place, feed_list=[x, y]) + + for batch_id, data in enumerate(train_reader()): + exe.run(fleet.main_program, feed=feeder.feed(data), fetch_list=[]) + fleet.stop_worker() + def run_ut(self): + training_role = os.getenv("TRAINING_ROLE", "TRAINER") + + role = role_maker.UserDefinedRoleMaker( + current_id=0, + role=role_maker.Role.WORKER + if training_role == "TRAINER" else role_maker.Role.SERVER, + worker_num=1, + server_endpoints=["127.0.0.1:18099"]) + + strategy = StrategyFactory.create_geo_strategy(10) + + if training_role == "TRAINER": + self.run_trainer(role, strategy) + else: + self.run_pserver(role, strategy) + + def test_communicator(self): + run_server_cmd = """ +from __future__ import print_function + +import sys +import os + +import time +import threading +import subprocess +import unittest +import numpy + +import paddle +import paddle.fluid as fluid + +from paddle.fluid.communicator import Communicator +import paddle.fluid.incubate.fleet.base.role_maker as role_maker +from paddle.fluid.incubate.fleet.parameter_server.mode import DistributedMode +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory + +from test_communicator_geo import TestCommunicatorGeoEnd2End + + +class RunServer(TestCommunicatorGeoEnd2End): + def runTest(self): + pass + +os.environ["TRAINING_ROLE"] = "PSERVER" +os.environ["http_proxy"] = "" +os.environ["https_proxy"] = "" + +half_run_server = RunServer() +half_run_server.run_ut() +""" + + server_file = "run_server_for_communicator_geo.py" + with open(server_file, "w") as wb: + wb.write(run_server_cmd) + os.environ["TRAINING_ROLE"] = "PSERVER" + os.environ["http_proxy"] = "" + os.environ["https_proxy"] = "" + + _python = sys.executable + + ps_cmd = "{} {}".format(_python, server_file) + ps_proc = subprocess.Popen( + ps_cmd.strip().split(" "), + stdout=subprocess.PIPE, + stderr=subprocess.PIPE) + + time.sleep(5) -# class TestCommunicatorGEO(unittest.TestCase): -# def test_communicator_init_and_start(self): -# prog = fluid.Program() + os.environ["TRAINING_ROLE"] = "TRAINER" + os.environ["http_proxy"] = "" + os.environ["https_proxy"] = "" -# envs = {} -# envs["communicator_thread_pool_size"] = "5" -# envs["communicator_send_wait_times"] = "5" + self.run_ut() + ps_proc.kill() -# kwargs = {} -# kwargs["push_vars"] = {} -# kwargs["trainers"] = 10 -# kwargs["push_nums"] = 10 + if os.path.exists(server_file): + os.remove(server_file) -# comm = Communicator(prog, DistributedMode.GEO, kwargs, envs) if __name__ == '__main__': unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_communicator_half_async.py b/python/paddle/fluid/tests/unittests/test_communicator_half_async.py index 8a7904db95f7a1b8088197fdf16969e1ccfefae2..542d1874179ec53b0a4701e941f9748d0bc14766 100644 --- a/python/paddle/fluid/tests/unittests/test_communicator_half_async.py +++ b/python/paddle/fluid/tests/unittests/test_communicator_half_async.py @@ -24,12 +24,10 @@ import numpy import paddle import paddle.fluid as fluid -from paddle.fluid.communicator import Communicator import paddle.fluid.incubate.fleet.base.role_maker as role_maker -from paddle.fluid.transpiler.distribute_transpiler import DistributedMode -from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory class TestCommunicatorHalfAsyncEnd2End(unittest.TestCase): @@ -71,8 +69,8 @@ class TestCommunicatorHalfAsyncEnd2End(unittest.TestCase): optimizer = fleet.distributed_optimizer(optimizer, strategy) optimizer.minimize(avg_cost) - exe.run(fleet.startup_program) fleet.init_worker() + exe.run(fleet.startup_program) train_reader = paddle.batch(self.fake_reader(), batch_size=24) feeder = fluid.DataFeeder(place=place, feed_list=[x, y]) @@ -83,10 +81,7 @@ class TestCommunicatorHalfAsyncEnd2End(unittest.TestCase): fleet.stop_worker() def run_ut(self): - strategy = DistributeTranspilerConfig() - strategy.sync_mode = False - strategy.runtime_split_send_recv = True - strategy.half_async = True + strategy = StrategyFactory.create_half_async_strategy() training_role = os.getenv("TRAINING_ROLE", "TRAINER") @@ -118,18 +113,20 @@ import numpy import paddle import paddle.fluid as fluid from paddle.fluid.communicator import Communicator -from paddle.fluid.communicator import DistributedMode +from paddle.fluid.incubate.fleet.parameter_server.mode import DistributedMode import paddle.fluid.incubate.fleet.base.role_maker as role_maker from test_communicator_half_async import TestCommunicatorHalfAsyncEnd2End -from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory class RunServer(TestCommunicatorHalfAsyncEnd2End): def runTest(self): pass +os.environ["http_proxy"] = "" +os.environ["https_proxy"] = "" os.environ["TRAINING_ROLE"] = "PSERVER" half_run_server = RunServer() half_run_server.run_ut() @@ -147,6 +144,8 @@ half_run_server.run_ut() stdout=subprocess.PIPE, stderr=subprocess.PIPE) + os.environ["http_proxy"] = "" + os.environ["https_proxy"] = "" os.environ["TRAINING_ROLE"] = "TRAINER" os.environ["FLAGS_communicator_send_queue_size"] = "1" os.environ["FLAGS_communicator_max_merge_var_num"] = "1" @@ -158,20 +157,5 @@ half_run_server.run_ut() os.remove(server_file) -# class TestCommunicatorHalfAsync2(unittest.TestCase): -# def test_communicator_init_and_start(self): -# prog = fluid.Program() - -# envs = {} -# envs["communicator_send_queue_size"] = "12" -# envs["communicator_max_merge_var_num"] = "12" -# envs["communicator_thread_pool_size"] = "5" -# envs["communicator_send_wait_times"] = "5" - -# comm = Communicator(prog, DistributedMode.HALF_ASYNC, None, envs) -# comm.start() -# time.sleep(10) -# comm.stop() - if __name__ == '__main__': unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_dataset.py b/python/paddle/fluid/tests/unittests/test_dataset.py index ea40d9abb96f019616487d8cd316748240708fcd..cc2cee602918d53dd5435d9f498a9e8c9c948c58 100644 --- a/python/paddle/fluid/tests/unittests/test_dataset.py +++ b/python/paddle/fluid/tests/unittests/test_dataset.py @@ -819,6 +819,9 @@ class TestDataset2(unittest.TestCase): """ Testcase for InMemoryDataset from create to run. """ + + self.skipTest("parameter server will add pslib UT later") + with open("test_in_memory_dataset2_run_a.txt", "w") as f: data = "1 1 2 3 3 4 5 5 5 5 1 1\n" data += "1 2 2 3 4 4 6 6 6 6 1 2\n" @@ -834,7 +837,7 @@ class TestDataset2(unittest.TestCase): train_program = fluid.Program() startup_program = fluid.Program() scope = fluid.Scope() - from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet + from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet with fluid.program_guard(train_program, startup_program): slots = ["slot1_ff", "slot2_ff", "slot3_ff", "slot4_ff"] slots_vars = [] @@ -881,6 +884,9 @@ class TestDataset2(unittest.TestCase): """ Testcase for InMemoryDataset from create to run. """ + + self.skipTest("parameter server will add pslib UT later") + with open("test_in_memory_dataset2_run2_a.txt", "w") as f: data = "1 1 2 3 3 4 5 5 5 5 1 1\n" data += "1 2 2 3 4 4 6 6 6 6 1 2\n" @@ -896,7 +902,7 @@ class TestDataset2(unittest.TestCase): train_program = fluid.Program() startup_program = fluid.Program() scope = fluid.Scope() - from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet + from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet with fluid.program_guard(train_program, startup_program): slots = ["slot1_ff", "slot2_ff", "slot3_ff", "slot4_ff"] slots_vars = [] diff --git a/python/paddle/fluid/tests/unittests/test_dist_ctr.py b/python/paddle/fluid/tests/unittests/test_dist_ctr.py deleted file mode 100644 index f20989746dc48be0ce470dbe431e75b13491282b..0000000000000000000000000000000000000000 --- a/python/paddle/fluid/tests/unittests/test_dist_ctr.py +++ /dev/null @@ -1,120 +0,0 @@ -# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# 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 __future__ import print_function - -import os -import unittest -from test_dist_base import TestDistBase - -import os -flag_name = os.path.splitext(__file__)[0] - - -class TestDistCTR2x2(TestDistBase): - def _setup_config(self): - self._sync_mode = True - self._enforce_place = "CPU" - - def test_dist_ctr(self): - self.check_with_place( - "dist_ctr.py", delta=1e-2, check_error_log=True, log_name=flag_name) - - -class TestDistCTRWithL2Decay2x2(TestDistBase): - def _setup_config(self): - self._sync_mode = True - self._enforce_place = "CPU" - - def test_dist_ctr(self): - need_envs = {"USE_L2_DECAY": "1"} - self.check_with_place( - "dist_ctr.py", - delta=1e-7, - check_error_log=True, - need_envs=need_envs, - log_name=flag_name) - - -@unittest.skip(reason="Skip unstable ci") -class TestDistCTR2x2_ASYNC(TestDistBase): - def _setup_config(self): - self._sync_mode = False - self._hogwild_mode = True - self._enforce_place = "CPU" - - def test_dist_ctr(self): - need_envs = { - "FLAGS_communicator_send_queue_size": "2", - "FLAGS_communicator_max_merge_var_num": "2", - "FLAGS_communicator_max_send_grad_num_before_recv": "2", - } - - self.check_with_place( - "dist_ctr.py", - delta=100, - check_error_log=True, - need_envs=need_envs, - log_name=flag_name) - - -@unittest.skip(reason="Skip unstable ci") -class TestDistCTR2x2_ASYNCWithLRDecay2x2(TestDistBase): - def _setup_config(self): - self._sync_mode = False - self._hogwild_mode = True - self._enforce_place = "CPU" - - def test_dist_ctr(self): - need_envs = { - "FLAGS_communicator_send_queue_size": "2", - "FLAGS_communicator_max_merge_var_num": "2", - "FLAGS_communicator_max_send_grad_num_before_recv": "2", - "LR_DECAY": "1" - } - - self.check_with_place( - "dist_ctr.py", - delta=100, - check_error_log=True, - need_envs=need_envs, - log_name=flag_name) - - -@unittest.skip(reason="Skip unstable ci") -class TestDistCTR2x2_ASYNC2(TestDistBase): - def _setup_config(self): - self._sync_mode = False - self._hogwild_mode = True - self._enforce_place = "CPU" - - def test_dist_ctr(self): - need_envs = { - "FLAGS_communicator_send_queue_size": "2", - "FLAGS_communicator_max_merge_var_num": "2", - "FLAGS_communicator_max_send_grad_num_before_recv": "2", - "FLAGS_communicator_independent_recv_thread": "0", - "FLAGS_communicator_is_sgd_optimizer": "0" - } - - self.check_with_place( - "dist_ctr.py", - delta=100, - check_error_log=True, - need_envs=need_envs, - log_name=flag_name) - - -if __name__ == "__main__": - unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_dist_fleet_base.py b/python/paddle/fluid/tests/unittests/test_dist_fleet_base.py index 32a06188c5f56306b4aa2ad4c80fb0fac2cad350..16f0fc0a35e6140941da09c13bf67855670fc6a1 100644 --- a/python/paddle/fluid/tests/unittests/test_dist_fleet_base.py +++ b/python/paddle/fluid/tests/unittests/test_dist_fleet_base.py @@ -16,27 +16,21 @@ from __future__ import print_function """ high level unit test for distribute fleet. """ -import argparse + import os -import pickle -import subprocess import sys -import time -import traceback -import math -import collections -import socket -from contextlib import closing +import subprocess -import six -import unittest -import numpy as np +import argparse +from contextlib import closing +import socket +import time import tempfile +import unittest import paddle.fluid as fluid import paddle.fluid.incubate.fleet.base.role_maker as role_maker from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet -from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory __all__ = ['FleetDistRunnerBase', 'TestFleetBase', 'runtime_main'] @@ -106,7 +100,16 @@ class FleetDistRunnerBase(object): fluid.clip.set_gradient_clip( clip=fluid.clip.GradientClipByGlobalNorm(2.0)) - optimizer = fluid.optimizer.SGD(LEARNING_RATE) + use_decay = int(os.getenv("DECAY", "0")) + if use_decay: + optimizer = fluid.optimizer.SGD( + learning_rate=fluid.layers.exponential_decay( + learning_rate=LEARNING_RATE, + decay_steps=500, + decay_rate=0.969, + staircase=True)) + else: + optimizer = fluid.optimizer.SGD(LEARNING_RATE) optimizer = fleet.distributed_optimizer(optimizer, strategy) optimizer.minimize(avg_cost) @@ -232,13 +235,11 @@ class TestFleetBase(unittest.TestCase): def _run_cluster(self, model, envs): env = {'GRAD_CLIP': str(self._grad_clip_mode)} - env.update(envs) - python_path = self._python_interp - if os.getenv('WITH_COVERAGE', 'OFF') == 'ON': envs['COVERAGE_FILE'] = os.getenv('COVERAGE_FILE', '') python_path += " -m coverage run --branch -p" + env.update(envs) tr_cmd = "{0} {1} --role trainer --endpoints {2} --current_id {{}} --trainers {3} --mode {4} --geo_sgd_need_push_nums {5} --reader {6}".format( python_path, model, self._ps_endpoints, self._trainers, self._mode, @@ -258,6 +259,7 @@ class TestFleetBase(unittest.TestCase): time.sleep(0.1) if stat0 is not None: break + while True: stat1 = tr1.poll() time.sleep(0.1) @@ -267,6 +269,12 @@ class TestFleetBase(unittest.TestCase): tr0_out, tr0_err = tr0.communicate() tr1_out, tr1_err = tr1.communicate() + tr0_ret = tr0.returncode + tr1_ret = tr0.returncode + + self.assertEqual(tr0_ret, 0, "something wrong in tr0, please check") + self.assertEqual(tr1_ret, 0, "something wrong in tr1, please check") + # close trainer file tr0_pipe.close() tr1_pipe.close() diff --git a/python/paddle/fluid/tests/unittests/test_dist_fleet_ctr.py b/python/paddle/fluid/tests/unittests/test_dist_fleet_ctr.py index 796ac611db81e2a822134c9fa0ca862d4a294da8..5fc37335b21536cef160c9f72e68bf7eb0610e97 100644 --- a/python/paddle/fluid/tests/unittests/test_dist_fleet_ctr.py +++ b/python/paddle/fluid/tests/unittests/test_dist_fleet_ctr.py @@ -84,6 +84,7 @@ class TestDistMnistAsync2x2(TestFleetBase): "dist_fleet_ctr.py", delta=1e-5, check_error_log=True) +@unittest.skip(reason="Skip unstable ut, reader need to be rewrite") class TestDistMnistAsyncDataset2x2(TestFleetBase): def _setup_config(self): self._mode = "async" diff --git a/python/paddle/fluid/tests/unittests/test_dist_fleet_geo.py b/python/paddle/fluid/tests/unittests/test_dist_fleet_geo.py index ee0600d31054630d01d0b352297051b7ae78ada4..0fe7c386c1eeb751f34cf681778132310c304d51 100644 --- a/python/paddle/fluid/tests/unittests/test_dist_fleet_geo.py +++ b/python/paddle/fluid/tests/unittests/test_dist_fleet_geo.py @@ -19,8 +19,7 @@ import unittest import paddle.fluid as fluid import paddle.fluid.incubate.fleet.base.role_maker as role_maker from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet -from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig, ServerRuntimeConfig -from paddle.fluid.transpiler.geo_sgd_transpiler import GeoSgdTranspiler +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory from test_dist_fleet_base import TestFleetBase from dist_simnet_bow import train_network @@ -28,7 +27,7 @@ from dist_simnet_bow import train_network class TestDistGeoCtr_2x2(TestFleetBase): def _setup_config(self): self._mode = "geo" - self._reader = "dataset" + self._reader = "pyreader" self._geo_sgd_need_push_nums = 5 def check_with_place(self, @@ -71,10 +70,7 @@ class TestGeoSgdTranspiler(unittest.TestCase): is_sparse = True is_distribute = False - strategy = DistributeTranspilerConfig() - strategy.sync_mode = False - strategy.geo_sgd_mode = True - strategy.geo_sgd_need_push_nums = 5 + strategy = StrategyFactory.create_geo_strategy(5) avg_cost, _, _ = train_network(batch_size, is_distribute, is_sparse) diff --git a/python/paddle/fluid/tests/unittests/test_dist_fleet_grad_clip.py b/python/paddle/fluid/tests/unittests/test_dist_fleet_grad_clip.py index 34f4d8c542725a12f8e62f759f1ceb85a6744f7d..46616f3dde486e61488d6852ca9efc37a066ab0b 100644 --- a/python/paddle/fluid/tests/unittests/test_dist_fleet_grad_clip.py +++ b/python/paddle/fluid/tests/unittests/test_dist_fleet_grad_clip.py @@ -24,6 +24,7 @@ from test_dist_fleet_base import TestFleetBase from dist_simnet_bow import train_network +@unittest.skip(reason="Skip unstable ut, add it after PR 22957 merged") class TestDistGeoClipByGlobalNormTranspiler(unittest.TestCase): def test_pserver(self): role = role_maker.UserDefinedRoleMaker( @@ -55,6 +56,7 @@ class TestDistGeoClipByGlobalNormTranspiler(unittest.TestCase): pserver_mian_program = fleet.main_program +@unittest.skip(reason="Skip unstable ut, add it after PR 22957 merged") class TestDistGeoClipByGlobalNorm(TestFleetBase): def _setup_config(self): self._mode = "geo" @@ -107,6 +109,7 @@ class TestDistGeoClipByGlobalNorm(TestFleetBase): "dist_fleet_ctr.py", delta=1e-5, check_error_log=True) +@unittest.skip(reason="Skip unstable ut, add it after PR 22957 merged") class TestDistASyncClipByGlobalNorm(TestFleetBase): def _setup_config(self): self._mode = "async" diff --git a/python/paddle/fluid/tests/unittests/test_dist_fleet_ps.py b/python/paddle/fluid/tests/unittests/test_dist_fleet_ps.py new file mode 100644 index 0000000000000000000000000000000000000000..8132add37a673d9035ca108cc124f075b53226f1 --- /dev/null +++ b/python/paddle/fluid/tests/unittests/test_dist_fleet_ps.py @@ -0,0 +1,174 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +import unittest +import paddle.fluid as fluid +import paddle.fluid.incubate.fleet.base.role_maker as role_maker +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory + +# For Net +base_lr = 0.2 +emb_lr = base_lr * 3 +dict_dim = 1500 +emb_dim = 128 +hid_dim = 128 +margin = 0.1 +sample_rate = 1 +batch_size = 4 + + +class TestPSPassWithBow(unittest.TestCase): + def net(self): + def get_acc(cos_q_nt, cos_q_pt, batch_size): + cond = fluid.layers.less_than(cos_q_nt, cos_q_pt) + cond = fluid.layers.cast(cond, dtype='float64') + cond_3 = fluid.layers.reduce_sum(cond) + acc = fluid.layers.elementwise_div( + cond_3, + fluid.layers.fill_constant( + shape=[1], value=batch_size * 1.0, dtype='float64'), + name="simnet_acc") + return acc + + def get_loss(cos_q_pt, cos_q_nt): + loss_op1 = fluid.layers.elementwise_sub( + fluid.layers.fill_constant_batch_size_like( + input=cos_q_pt, + shape=[-1, 1], + value=margin, + dtype='float32'), + cos_q_pt) + loss_op2 = fluid.layers.elementwise_add(loss_op1, cos_q_nt) + loss_op3 = fluid.layers.elementwise_max( + fluid.layers.fill_constant_batch_size_like( + input=loss_op2, shape=[-1, 1], value=0.0, dtype='float32'), + loss_op2) + avg_cost = fluid.layers.mean(loss_op3) + return avg_cost + + is_distributed = False + is_sparse = True + + # query + q = fluid.layers.data( + name="query_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + q_emb = fluid.layers.embedding( + input=q, + is_distributed=is_distributed, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr), + is_sparse=is_sparse) + q_emb = fluid.layers.reshape(q_emb, [-1, emb_dim]) + # vsum + q_sum = fluid.layers.sequence_pool(input=q_emb, pool_type='sum') + q_ss = fluid.layers.softsign(q_sum) + # fc layer after conv + q_fc = fluid.layers.fc( + input=q_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__q_fc__", + learning_rate=base_lr)) + # label data + label = fluid.layers.data(name="label", shape=[1], dtype="int64") + # pt + pt = fluid.layers.data( + name="pos_title_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + pt_emb = fluid.layers.embedding( + input=pt, + is_distributed=is_distributed, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr), + is_sparse=is_sparse) + pt_emb = fluid.layers.reshape(pt_emb, [-1, emb_dim]) + # vsum + pt_sum = fluid.layers.sequence_pool(input=pt_emb, pool_type='sum') + pt_ss = fluid.layers.softsign(pt_sum) + # fc layer + pt_fc = fluid.layers.fc( + input=pt_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__fc__", + learning_rate=base_lr), + bias_attr=fluid.ParamAttr(name="__fc_b__")) + # nt + nt = fluid.layers.data( + name="neg_title_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + nt_emb = fluid.layers.embedding( + input=nt, + is_distributed=is_distributed, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr), + is_sparse=is_sparse) + nt_emb = fluid.layers.reshape(nt_emb, [-1, emb_dim]) + # vsum + nt_sum = fluid.layers.sequence_pool(input=nt_emb, pool_type='sum') + nt_ss = fluid.layers.softsign(nt_sum) + # fc layer + nt_fc = fluid.layers.fc( + input=nt_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__fc__", + learning_rate=base_lr), + bias_attr=fluid.ParamAttr(name="__fc_b__")) + cos_q_pt = fluid.layers.cos_sim(q_fc, pt_fc) + cos_q_nt = fluid.layers.cos_sim(q_fc, nt_fc) + # loss + avg_cost = get_loss(cos_q_pt, cos_q_nt) + # acc + acc = get_acc(cos_q_nt, cos_q_pt, batch_size) + return [avg_cost, acc, cos_q_pt] + + def test(self): + endpoints = [ + "127.0.0.1:36004", "127.0.0.1:36005", "127.0.0.1:36006", + "127.0.0.1:36007" + ] + + role = role_maker.UserDefinedRoleMaker( + current_id=0, + role=role_maker.Role.SERVER, + worker_num=2, + server_endpoints=endpoints) + + fleet.init(role) + loss, acc, _ = self.net() + optimizer = fluid.optimizer.SGD(base_lr) + strategy = StrategyFactory.create_sync_strategy() + optimizer = fleet.distributed_optimizer(optimizer, strategy) + optimizer.minimize(loss) + + +if __name__ == '__main__': + unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_dist_fleet_ps2.py b/python/paddle/fluid/tests/unittests/test_dist_fleet_ps2.py new file mode 100644 index 0000000000000000000000000000000000000000..833b7307fa317b171e3acbd3a508a1c8a8da3d94 --- /dev/null +++ b/python/paddle/fluid/tests/unittests/test_dist_fleet_ps2.py @@ -0,0 +1,191 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +import os +import unittest +import tempfile +import shutil + +import paddle.fluid as fluid +import paddle.fluid.incubate.fleet.base.role_maker as role_maker +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory + +# For Net +base_lr = 0.2 +emb_lr = base_lr * 3 +dict_dim = 1500 +emb_dim = 128 +hid_dim = 128 +margin = 0.1 +sample_rate = 1 +batch_size = 4 + + +class TestPSPassWithBow(unittest.TestCase): + def net(self): + def get_acc(cos_q_nt, cos_q_pt, batch_size): + cond = fluid.layers.less_than(cos_q_nt, cos_q_pt) + cond = fluid.layers.cast(cond, dtype='float64') + cond_3 = fluid.layers.reduce_sum(cond) + acc = fluid.layers.elementwise_div( + cond_3, + fluid.layers.fill_constant( + shape=[1], value=batch_size * 1.0, dtype='float64'), + name="simnet_acc") + return acc + + def get_loss(cos_q_pt, cos_q_nt): + loss_op1 = fluid.layers.elementwise_sub( + fluid.layers.fill_constant_batch_size_like( + input=cos_q_pt, + shape=[-1, 1], + value=margin, + dtype='float32'), + cos_q_pt) + loss_op2 = fluid.layers.elementwise_add(loss_op1, cos_q_nt) + loss_op3 = fluid.layers.elementwise_max( + fluid.layers.fill_constant_batch_size_like( + input=loss_op2, shape=[-1, 1], value=0.0, dtype='float32'), + loss_op2) + avg_cost = fluid.layers.mean(loss_op3) + return avg_cost + + is_distributed = False + is_sparse = True + + # query + q = fluid.layers.data( + name="query_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + q_emb = fluid.contrib.layers.sparse_embedding( + input=q, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr)) + q_emb = fluid.layers.reshape(q_emb, [-1, emb_dim]) + # vsum + q_sum = fluid.layers.sequence_pool(input=q_emb, pool_type='sum') + q_ss = fluid.layers.softsign(q_sum) + # fc layer after conv + q_fc = fluid.layers.fc( + input=q_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__q_fc__", + learning_rate=base_lr)) + # label data + label = fluid.layers.data(name="label", shape=[1], dtype="int64") + # pt + pt = fluid.layers.data( + name="pos_title_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + pt_emb = fluid.contrib.layers.sparse_embedding( + input=pt, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr)) + pt_emb = fluid.layers.reshape(pt_emb, [-1, emb_dim]) + # vsum + pt_sum = fluid.layers.sequence_pool(input=pt_emb, pool_type='sum') + pt_ss = fluid.layers.softsign(pt_sum) + # fc layer + pt_fc = fluid.layers.fc( + input=pt_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__fc__", + learning_rate=base_lr), + bias_attr=fluid.ParamAttr(name="__fc_b__")) + # nt + nt = fluid.layers.data( + name="neg_title_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + nt_emb = fluid.contrib.layers.sparse_embedding( + input=nt, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr)) + nt_emb = fluid.layers.reshape(nt_emb, [-1, emb_dim]) + # vsum + nt_sum = fluid.layers.sequence_pool(input=nt_emb, pool_type='sum') + nt_ss = fluid.layers.softsign(nt_sum) + # fc layer + nt_fc = fluid.layers.fc( + input=nt_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__fc__", + learning_rate=base_lr), + bias_attr=fluid.ParamAttr(name="__fc_b__")) + cos_q_pt = fluid.layers.cos_sim(q_fc, pt_fc) + cos_q_nt = fluid.layers.cos_sim(q_fc, nt_fc) + # loss + avg_cost = get_loss(cos_q_pt, cos_q_nt) + # acc + acc = get_acc(cos_q_nt, cos_q_pt, batch_size) + return [avg_cost, acc, cos_q_pt] + + def test(self): + endpoints = ["127.0.0.1:36004"] + + role = role_maker.UserDefinedRoleMaker( + current_id=0, + role=role_maker.Role.SERVER, + worker_num=2, + server_endpoints=endpoints) + + fleet.init(role) + loss, acc, _ = self.net() + optimizer = fluid.optimizer.SGD(base_lr) + strategy = StrategyFactory.create_async_strategy() + optimizer = fleet.distributed_optimizer(optimizer, strategy) + optimizer.minimize(loss) + + fleet.startup_program_bak = fleet.startup_program + fleet.startup_program = None + + with self.assertRaises(ValueError): + fleet.init_server() + + model_dir = tempfile.mkdtemp() + + with self.assertRaises(ValueError): + fleet.init_server(os.path.join(model_dir, "temp")) + + fleet.startup_program = fleet.startup_program_bak + fleet.init_server() + + from paddle.fluid.communicator import LargeScaleKV + kv = LargeScaleKV() + kv.save("__emb__", os.path.join(model_dir, "__emb__", "__emb__")) + + fleet.main_program = fluid.Program() + fleet.init_server(model_dir) + shutil.rmtree(model_dir) + + +if __name__ == '__main__': + unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_dist_fleet_ps3.py b/python/paddle/fluid/tests/unittests/test_dist_fleet_ps3.py new file mode 100644 index 0000000000000000000000000000000000000000..de4363f255ba8fd80b7caea11a03a28899c1c9e7 --- /dev/null +++ b/python/paddle/fluid/tests/unittests/test_dist_fleet_ps3.py @@ -0,0 +1,174 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +import unittest +import paddle.fluid as fluid +import paddle.fluid.incubate.fleet.base.role_maker as role_maker +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory + +# For Net +base_lr = 0.2 +emb_lr = base_lr * 3 +dict_dim = 1500 +emb_dim = 128 +hid_dim = 128 +margin = 0.1 +sample_rate = 1 +batch_size = 4 + + +class TestPSPassWithBow(unittest.TestCase): + def net(self): + def get_acc(cos_q_nt, cos_q_pt, batch_size): + cond = fluid.layers.less_than(cos_q_nt, cos_q_pt) + cond = fluid.layers.cast(cond, dtype='float64') + cond_3 = fluid.layers.reduce_sum(cond) + acc = fluid.layers.elementwise_div( + cond_3, + fluid.layers.fill_constant( + shape=[1], value=batch_size * 1.0, dtype='float64'), + name="simnet_acc") + return acc + + def get_loss(cos_q_pt, cos_q_nt): + loss_op1 = fluid.layers.elementwise_sub( + fluid.layers.fill_constant_batch_size_like( + input=cos_q_pt, + shape=[-1, 1], + value=margin, + dtype='float32'), + cos_q_pt) + loss_op2 = fluid.layers.elementwise_add(loss_op1, cos_q_nt) + loss_op3 = fluid.layers.elementwise_max( + fluid.layers.fill_constant_batch_size_like( + input=loss_op2, shape=[-1, 1], value=0.0, dtype='float32'), + loss_op2) + avg_cost = fluid.layers.mean(loss_op3) + return avg_cost + + is_distributed = False + is_sparse = True + + # query + q = fluid.layers.data( + name="query_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + q_emb = fluid.layers.embedding( + input=q, + is_distributed=is_distributed, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr), + is_sparse=is_sparse) + q_emb = fluid.layers.reshape(q_emb, [-1, emb_dim]) + # vsum + q_sum = fluid.layers.sequence_pool(input=q_emb, pool_type='sum') + q_ss = fluid.layers.softsign(q_sum) + # fc layer after conv + q_fc = fluid.layers.fc( + input=q_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__q_fc__", + learning_rate=base_lr)) + # label data + label = fluid.layers.data(name="label", shape=[1], dtype="int64") + # pt + pt = fluid.layers.data( + name="pos_title_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + pt_emb = fluid.layers.embedding( + input=pt, + is_distributed=is_distributed, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr), + is_sparse=is_sparse) + pt_emb = fluid.layers.reshape(pt_emb, [-1, emb_dim]) + # vsum + pt_sum = fluid.layers.sequence_pool(input=pt_emb, pool_type='sum') + pt_ss = fluid.layers.softsign(pt_sum) + # fc layer + pt_fc = fluid.layers.fc( + input=pt_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__fc__", + learning_rate=base_lr), + bias_attr=fluid.ParamAttr(name="__fc_b__")) + # nt + nt = fluid.layers.data( + name="neg_title_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + nt_emb = fluid.layers.embedding( + input=nt, + is_distributed=is_distributed, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr), + is_sparse=is_sparse) + nt_emb = fluid.layers.reshape(nt_emb, [-1, emb_dim]) + # vsum + nt_sum = fluid.layers.sequence_pool(input=nt_emb, pool_type='sum') + nt_ss = fluid.layers.softsign(nt_sum) + # fc layer + nt_fc = fluid.layers.fc( + input=nt_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__fc__", + learning_rate=base_lr), + bias_attr=fluid.ParamAttr(name="__fc_b__")) + cos_q_pt = fluid.layers.cos_sim(q_fc, pt_fc) + cos_q_nt = fluid.layers.cos_sim(q_fc, nt_fc) + # loss + avg_cost = get_loss(cos_q_pt, cos_q_nt) + # acc + acc = get_acc(cos_q_nt, cos_q_pt, batch_size) + return [avg_cost, acc, cos_q_pt] + + def test(self): + endpoints = [ + "127.0.0.1:36004", "127.0.0.1:36005", "127.0.0.1:36006", + "127.0.0.1:36007" + ] + + role = role_maker.UserDefinedRoleMaker( + current_id=0, + role=role_maker.Role.SERVER, + worker_num=2, + server_endpoints=endpoints) + + fleet.init(role) + loss, acc, _ = self.net() + optimizer = fluid.optimizer.SGD(base_lr) + strategy = StrategyFactory.create_geo_strategy(20) + optimizer = fleet.distributed_optimizer(optimizer, strategy) + optimizer.minimize(loss) + + +if __name__ == '__main__': + unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_dist_fleet_ps4.py b/python/paddle/fluid/tests/unittests/test_dist_fleet_ps4.py new file mode 100644 index 0000000000000000000000000000000000000000..dc40b2eb5c6480fb22f28c66e2b8205575269b66 --- /dev/null +++ b/python/paddle/fluid/tests/unittests/test_dist_fleet_ps4.py @@ -0,0 +1,174 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +import unittest +import paddle.fluid as fluid +import paddle.fluid.incubate.fleet.base.role_maker as role_maker +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory + +# For Net +base_lr = 0.2 +emb_lr = base_lr * 3 +dict_dim = 1500 +emb_dim = 128 +hid_dim = 128 +margin = 0.1 +sample_rate = 1 +batch_size = 4 + + +class TestPSPassWithBow(unittest.TestCase): + def net(self): + def get_acc(cos_q_nt, cos_q_pt, batch_size): + cond = fluid.layers.less_than(cos_q_nt, cos_q_pt) + cond = fluid.layers.cast(cond, dtype='float64') + cond_3 = fluid.layers.reduce_sum(cond) + acc = fluid.layers.elementwise_div( + cond_3, + fluid.layers.fill_constant( + shape=[1], value=batch_size * 1.0, dtype='float64'), + name="simnet_acc") + return acc + + def get_loss(cos_q_pt, cos_q_nt): + loss_op1 = fluid.layers.elementwise_sub( + fluid.layers.fill_constant_batch_size_like( + input=cos_q_pt, + shape=[-1, 1], + value=margin, + dtype='float32'), + cos_q_pt) + loss_op2 = fluid.layers.elementwise_add(loss_op1, cos_q_nt) + loss_op3 = fluid.layers.elementwise_max( + fluid.layers.fill_constant_batch_size_like( + input=loss_op2, shape=[-1, 1], value=0.0, dtype='float32'), + loss_op2) + avg_cost = fluid.layers.mean(loss_op3) + return avg_cost + + is_distributed = False + is_sparse = True + + # query + q = fluid.layers.data( + name="query_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + q_emb = fluid.layers.embedding( + input=q, + is_distributed=is_distributed, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr), + is_sparse=is_sparse) + q_emb = fluid.layers.reshape(q_emb, [-1, emb_dim]) + # vsum + q_sum = fluid.layers.sequence_pool(input=q_emb, pool_type='sum') + q_ss = fluid.layers.softsign(q_sum) + # fc layer after conv + q_fc = fluid.layers.fc( + input=q_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__q_fc__", + learning_rate=base_lr)) + # label data + label = fluid.layers.data(name="label", shape=[1], dtype="int64") + # pt + pt = fluid.layers.data( + name="pos_title_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + pt_emb = fluid.layers.embedding( + input=pt, + is_distributed=is_distributed, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr), + is_sparse=is_sparse) + pt_emb = fluid.layers.reshape(pt_emb, [-1, emb_dim]) + # vsum + pt_sum = fluid.layers.sequence_pool(input=pt_emb, pool_type='sum') + pt_ss = fluid.layers.softsign(pt_sum) + # fc layer + pt_fc = fluid.layers.fc( + input=pt_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__fc__", + learning_rate=base_lr), + bias_attr=fluid.ParamAttr(name="__fc_b__")) + # nt + nt = fluid.layers.data( + name="neg_title_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + nt_emb = fluid.layers.embedding( + input=nt, + is_distributed=is_distributed, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr), + is_sparse=is_sparse) + nt_emb = fluid.layers.reshape(nt_emb, [-1, emb_dim]) + # vsum + nt_sum = fluid.layers.sequence_pool(input=nt_emb, pool_type='sum') + nt_ss = fluid.layers.softsign(nt_sum) + # fc layer + nt_fc = fluid.layers.fc( + input=nt_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__fc__", + learning_rate=base_lr), + bias_attr=fluid.ParamAttr(name="__fc_b__")) + cos_q_pt = fluid.layers.cos_sim(q_fc, pt_fc) + cos_q_nt = fluid.layers.cos_sim(q_fc, nt_fc) + # loss + avg_cost = get_loss(cos_q_pt, cos_q_nt) + # acc + acc = get_acc(cos_q_nt, cos_q_pt, batch_size) + return [avg_cost, acc, cos_q_pt] + + def test(self): + endpoints = [ + "127.0.0.1:36004", "127.0.0.1:36005", "127.0.0.1:36006", + "127.0.0.1:36007" + ] + + role = role_maker.UserDefinedRoleMaker( + current_id=0, + role=role_maker.Role.SERVER, + worker_num=2, + server_endpoints=endpoints) + + fleet.init(role) + loss, acc, _ = self.net() + optimizer = fluid.optimizer.SGD(base_lr) + strategy = StrategyFactory.create_async_strategy() + optimizer = fleet.distributed_optimizer(optimizer, strategy) + optimizer.minimize(loss) + + +if __name__ == '__main__': + unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_dist_fleet_ps5.py b/python/paddle/fluid/tests/unittests/test_dist_fleet_ps5.py new file mode 100644 index 0000000000000000000000000000000000000000..5e525bdb54d4c2c00a96075533d0c0cd6074fe1b --- /dev/null +++ b/python/paddle/fluid/tests/unittests/test_dist_fleet_ps5.py @@ -0,0 +1,180 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +import unittest +import paddle.fluid as fluid +import paddle.fluid.incubate.fleet.base.role_maker as role_maker +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory + +# For Net +base_lr = 0.2 +emb_lr = base_lr * 3 +dict_dim = 1500 +emb_dim = 128 +hid_dim = 128 +margin = 0.1 +sample_rate = 1 +batch_size = 4 + + +class TestPSPassWithBow(unittest.TestCase): + def net(self): + def get_acc(cos_q_nt, cos_q_pt, batch_size): + cond = fluid.layers.less_than(cos_q_nt, cos_q_pt) + cond = fluid.layers.cast(cond, dtype='float64') + cond_3 = fluid.layers.reduce_sum(cond) + acc = fluid.layers.elementwise_div( + cond_3, + fluid.layers.fill_constant( + shape=[1], value=batch_size * 1.0, dtype='float64'), + name="simnet_acc") + return acc + + def get_loss(cos_q_pt, cos_q_nt): + loss_op1 = fluid.layers.elementwise_sub( + fluid.layers.fill_constant_batch_size_like( + input=cos_q_pt, + shape=[-1, 1], + value=margin, + dtype='float32'), + cos_q_pt) + loss_op2 = fluid.layers.elementwise_add(loss_op1, cos_q_nt) + loss_op3 = fluid.layers.elementwise_max( + fluid.layers.fill_constant_batch_size_like( + input=loss_op2, shape=[-1, 1], value=0.0, dtype='float32'), + loss_op2) + avg_cost = fluid.layers.mean(loss_op3) + return avg_cost + + is_distributed = False + is_sparse = True + + # query + q = fluid.layers.data( + name="query_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + q_emb = fluid.layers.embedding( + input=q, + is_distributed=is_distributed, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr), + is_sparse=is_sparse) + q_emb = fluid.layers.reshape(q_emb, [-1, emb_dim]) + # vsum + q_sum = fluid.layers.sequence_pool(input=q_emb, pool_type='sum') + q_ss = fluid.layers.softsign(q_sum) + # fc layer after conv + q_fc = fluid.layers.fc( + input=q_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__q_fc__", + learning_rate=base_lr)) + # label data + label = fluid.layers.data(name="label", shape=[1], dtype="int64") + # pt + pt = fluid.layers.data( + name="pos_title_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + pt_emb = fluid.layers.embedding( + input=pt, + is_distributed=is_distributed, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__", + learning_rate=emb_lr), + is_sparse=is_sparse) + pt_emb = fluid.layers.reshape(pt_emb, [-1, emb_dim]) + # vsum + pt_sum = fluid.layers.sequence_pool(input=pt_emb, pool_type='sum') + pt_ss = fluid.layers.softsign(pt_sum) + # fc layer + pt_fc = fluid.layers.fc( + input=pt_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__fc__", + learning_rate=base_lr), + bias_attr=fluid.ParamAttr(name="__fc_b__")) + # nt + nt = fluid.layers.data( + name="neg_title_ids", shape=[1], dtype="int64", lod_level=1) + # embedding + nt_emb = fluid.layers.embedding( + input=nt, + is_distributed=is_distributed, + size=[dict_dim, emb_dim], + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__emb__tmp_", + learning_rate=emb_lr), + is_sparse=False) + nt_emb = fluid.layers.reshape(nt_emb, [-1, emb_dim]) + # vsum + nt_sum = fluid.layers.sequence_pool(input=nt_emb, pool_type='sum') + nt_ss = fluid.layers.softsign(nt_sum) + # fc layer + nt_fc = fluid.layers.fc( + input=nt_ss, + size=hid_dim, + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01), + name="__fc__", + learning_rate=base_lr), + bias_attr=fluid.ParamAttr(name="__fc_b__")) + cos_q_pt = fluid.layers.cos_sim(q_fc, pt_fc) + cos_q_nt = fluid.layers.cos_sim(q_fc, nt_fc) + # loss + avg_cost = get_loss(cos_q_pt, cos_q_nt) + # acc + acc = get_acc(cos_q_nt, cos_q_pt, batch_size) + return [avg_cost, acc, cos_q_pt] + + def test(self): + endpoints = [ + "127.0.0.1:36004", "127.0.0.1:36005", "127.0.0.1:36006", + "127.0.0.1:36007" + ] + + role = role_maker.UserDefinedRoleMaker( + current_id=0, + role=role_maker.Role.SERVER, + worker_num=2, + server_endpoints=endpoints) + + fleet.init(role) + loss, acc, _ = self.net() + + optimizer = fluid.optimizer.SGD( + learning_rate=fluid.layers.exponential_decay( + learning_rate=base_lr, + decay_steps=500, + decay_rate=0.969, + staircase=True)) + strategy = StrategyFactory.create_async_strategy() + optimizer = fleet.distributed_optimizer(optimizer, strategy) + optimizer.minimize(loss) + + +if __name__ == '__main__': + unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_dist_fleet_sparse_embedding_ctr.py b/python/paddle/fluid/tests/unittests/test_dist_fleet_sparse_embedding_ctr.py new file mode 100644 index 0000000000000000000000000000000000000000..7c7253c3745c15662f0fa1125de8d9357de983af --- /dev/null +++ b/python/paddle/fluid/tests/unittests/test_dist_fleet_sparse_embedding_ctr.py @@ -0,0 +1,290 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +import os +import shutil +import tempfile +import unittest +import paddle +import paddle.fluid as fluid + +from test_dist_fleet_base import TestFleetBase +from dist_fleet_sparse_embedding_ctr import fake_ctr_reader + + +class TestDistMnistSync2x2(TestFleetBase): + def _setup_config(self): + self._mode = "sync" + self._reader = "pyreader" + + def check_with_place(self, + model_file, + delta=1e-3, + check_error_log=False, + need_envs={}): + required_envs = { + "PATH": os.getenv("PATH", ""), + "PYTHONPATH": os.getenv("PYTHONPATH", ""), + "LD_LIBRARY_PATH": os.getenv("LD_LIBRARY_PATH", ""), + "FLAGS_rpc_deadline": "5000", # 5sec to fail fast + "http_proxy": "", + "CPU_NUM": "2" + } + + required_envs.update(need_envs) + + if check_error_log: + required_envs["GLOG_v"] = "3" + required_envs["GLOG_logtostderr"] = "1" + + tr0_losses, tr1_losses = self._run_cluster(model_file, required_envs) + + def test_dist_train(self): + self.check_with_place( + "dist_fleet_sparse_embedding_ctr.py", + delta=1e-5, + check_error_log=True) + + +class TestDistMnistAsync2x2(TestFleetBase): + def _setup_config(self): + self._mode = "async" + self._reader = "pyreader" + + def check_with_place(self, + model_file, + delta=1e-3, + check_error_log=False, + need_envs={}): + required_envs = { + "PATH": os.getenv("PATH", ""), + "PYTHONPATH": os.getenv("PYTHONPATH", ""), + "LD_LIBRARY_PATH": os.getenv("LD_LIBRARY_PATH", ""), + "FLAGS_rpc_deadline": "5000", # 5sec to fail fast + "http_proxy": "", + "CPU_NUM": "2" + } + + required_envs.update(need_envs) + + if check_error_log: + required_envs["GLOG_v"] = "3" + required_envs["GLOG_logtostderr"] = "1" + + tr0_losses, tr1_losses = self._run_cluster(model_file, required_envs) + + def test_dist_train(self): + self.check_with_place( + "dist_fleet_sparse_embedding_ctr.py", + delta=1e-5, + check_error_log=True) + + +class TestDistMnistAsync2x2WithDecay(TestFleetBase): + def _setup_config(self): + self._mode = "async" + self._reader = "pyreader" + + def check_with_place(self, + model_file, + delta=1e-3, + check_error_log=False, + need_envs={}): + required_envs = { + "PATH": os.getenv("PATH", ""), + "PYTHONPATH": os.getenv("PYTHONPATH", ""), + "LD_LIBRARY_PATH": os.getenv("LD_LIBRARY_PATH", ""), + "FLAGS_rpc_deadline": "5000", # 5sec to fail fast + "http_proxy": "", + "CPU_NUM": "2", + "DECAY": "1" + } + + required_envs.update(need_envs) + + if check_error_log: + required_envs["GLOG_v"] = "3" + required_envs["GLOG_logtostderr"] = "1" + + tr0_losses, tr1_losses = self._run_cluster(model_file, required_envs) + + def test_dist_train(self): + self.check_with_place( + "dist_fleet_sparse_embedding_ctr.py", + delta=1e-5, + check_error_log=True) + + +class TestDistMnistAsync2x2WithUnifrom(TestFleetBase): + def _setup_config(self): + self._mode = "async" + self._reader = "pyreader" + + def check_with_place(self, + model_file, + delta=1e-3, + check_error_log=False, + need_envs={}): + required_envs = { + "PATH": os.getenv("PATH", ""), + "PYTHONPATH": os.getenv("PYTHONPATH", ""), + "LD_LIBRARY_PATH": os.getenv("LD_LIBRARY_PATH", ""), + "FLAGS_rpc_deadline": "5000", # 5sec to fail fast + "http_proxy": "", + "CPU_NUM": "2", + "INITIALIZER": "1" + } + + required_envs.update(need_envs) + + if check_error_log: + required_envs["GLOG_v"] = "3" + required_envs["GLOG_logtostderr"] = "1" + + tr0_losses, tr1_losses = self._run_cluster(model_file, required_envs) + + def test_dist_train(self): + self.check_with_place( + "dist_fleet_sparse_embedding_ctr.py", + delta=1e-5, + check_error_log=True) + + +class TestDistMnistAsync2x2WithGauss(TestFleetBase): + def _setup_config(self): + self._mode = "async" + self._reader = "pyreader" + + def _run_local_infer(self, model_file): + def net(): + """ + network definition + + Args: + batch_size(int): the size of mini-batch for training + lr(float): learning rate of training + Returns: + avg_cost: LoDTensor of cost. + """ + dnn_input_dim, lr_input_dim = 10, 10 + + dnn_data = fluid.layers.data( + name="dnn_data", + shape=[-1, 1], + dtype="int64", + lod_level=1, + append_batch_size=False) + lr_data = fluid.layers.data( + name="lr_data", + shape=[-1, 1], + dtype="int64", + lod_level=1, + append_batch_size=False) + label = fluid.layers.data( + name="click", + shape=[-1, 1], + dtype="int64", + lod_level=0, + append_batch_size=False) + + datas = [dnn_data, lr_data, label] + + inference = True + init = fluid.initializer.Uniform() + + dnn_layer_dims = [128, 64, 32] + dnn_embedding = fluid.contrib.layers.sparse_embedding( + input=dnn_data, + size=[dnn_input_dim, dnn_layer_dims[0]], + is_test=inference, + param_attr=fluid.ParamAttr( + name="deep_embedding", initializer=init)) + dnn_pool = fluid.layers.sequence_pool( + input=dnn_embedding, pool_type="sum") + dnn_out = dnn_pool + for i, dim in enumerate(dnn_layer_dims[1:]): + fc = fluid.layers.fc( + input=dnn_out, + size=dim, + act="relu", + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Constant(value=0.01)), + name='dnn-fc-%d' % i) + dnn_out = fc + + # build lr model + lr_embbding = fluid.contrib.layers.sparse_embedding( + input=lr_data, + size=[lr_input_dim, 1], + is_test=inference, + param_attr=fluid.ParamAttr( + name="wide_embedding", + initializer=fluid.initializer.Constant(value=0.01))) + + lr_pool = fluid.layers.sequence_pool( + input=lr_embbding, pool_type="sum") + merge_layer = fluid.layers.concat(input=[dnn_out, lr_pool], axis=1) + predict = fluid.layers.fc(input=merge_layer, size=2, act='softmax') + return datas, predict + + reader = paddle.batch(fake_ctr_reader(), batch_size=4) + datas, predict = net() + exe = fluid.Executor(fluid.CPUPlace()) + feeder = fluid.DataFeeder(place=fluid.CPUPlace(), feed_list=datas) + exe.run(fluid.default_startup_program()) + + fluid.io.load_persistables(exe, model_file) + + for batch_id, data in enumerate(reader()): + score = exe.run(fluid.default_main_program(), + feed=feeder.feed(data), + fetch_list=[predict]) + + def check_with_place(self, + model_file, + delta=1e-3, + check_error_log=False, + need_envs={}): + model_dir = tempfile.mkdtemp() + required_envs = { + "PATH": os.getenv("PATH", ""), + "PYTHONPATH": os.getenv("PYTHONPATH", ""), + "LD_LIBRARY_PATH": os.getenv("LD_LIBRARY_PATH", ""), + "FLAGS_rpc_deadline": "5000", # 5sec to fail fast + "http_proxy": "", + "CPU_NUM": "2", + "INITIALIZER": "2", + "MODEL_DIR": model_dir + } + + required_envs.update(need_envs) + if check_error_log: + required_envs["GLOG_v"] = "3" + required_envs["GLOG_logtostderr"] = "1" + + self._run_cluster(model_file, required_envs) + self._run_local_infer(model_dir) + shutil.rmtree(model_dir) + + def test_dist_train(self): + self.check_with_place( + "dist_fleet_sparse_embedding_ctr.py", + delta=1e-5, + check_error_log=True) + + +if __name__ == "__main__": + unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_dist_mnist_train.py b/python/paddle/fluid/tests/unittests/test_dist_mnist_train.py index 6042dfa4efd3367759ade87b56eb1047ecc917bf..a5bcada14d8b0ff1bb1a419d2929e1c184b6c295 100644 --- a/python/paddle/fluid/tests/unittests/test_dist_mnist_train.py +++ b/python/paddle/fluid/tests/unittests/test_dist_mnist_train.py @@ -72,24 +72,5 @@ class TestDistMnistDcAsgd(TestDistBase): log_name=flag_name) -# FIXME(typhoonzero): enable these tests once we have 4 -# 4 GPUs on CI machine, and the base class should be updated. -# -# class TestDistMnist2x2ReduceMode(TestDistBase): -# def _setup_config(self): -# self._sync_mode = True -# self._use_reduce = True - -# def test_se_resnext(self): -# self.check_with_place("dist_mnist.py", delta=1e-7) - -# class TestDistMnistAsyncReduceMode(TestDistBase): -# def _setup_config(self): -# self._sync_mode = False -# self._use_reduce = True - -# def test_se_resnext(self): -# self.check_with_place("dist_mnist.py", delta=200) - if __name__ == "__main__": unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_dist_transpiler.py b/python/paddle/fluid/tests/unittests/test_dist_transpiler.py index 746d29b69b982e1b8e3cea0ce44aa7ec3517e5ca..13a36f4a81e1f44fa8b3a2ba3570fc672bb079ce 100644 --- a/python/paddle/fluid/tests/unittests/test_dist_transpiler.py +++ b/python/paddle/fluid/tests/unittests/test_dist_transpiler.py @@ -660,15 +660,15 @@ class TestDistLookupTable(TestDistLookupTableBase): # 1 optimize for fc_w or fc_b adam self.assertEqual([op.type for op in pserver1.blocks[1].ops], ["sum", "scale", "adam", "scale", "scale"]) - # 4 prefetch -> lookup_sparse_table for data0 + # 4 prefetch -> lookup_sparse_table_read for data0 self.assertEqual([op.type for op in pserver1.blocks[2].ops], ["sum", "scale", "adam", "scale", "scale"]) # 2 optimize for table sgd self.assertEqual([op.type for op in pserver1.blocks[3].ops], ["sum", "sgd"]) - # 3 prefetch -> lookup_sparse_table for data0 + # 3 prefetch -> lookup_sparse_table_read for data0 self.assertEqual([op.type for op in pserver1.blocks[4].ops], - ["lookup_sparse_table"]) + ["lookup_sparse_table_read"]) # 5 save table self.assertEqual([op.type for op in pserver1.blocks[5].ops], ["save"]) @@ -754,9 +754,9 @@ class TestAsyncDistLookupTable(TestDistLookupTableBase): ["adam", "scale", "scale"]) # 3 optimize for table sgd self.assertEqual([op.type for op in pserver1.blocks[3].ops], ["sgd"]) - # 4 prefetch -> lookup_sparse_table for data0 + # 4 prefetch -> lookup_sparse_table_read for data0 self.assertEqual([op.type for op in pserver1.blocks[4].ops], - ["lookup_sparse_table"]) + ["lookup_sparse_table_read"]) # 5 save table self.assertEqual([op.type for op in pserver1.blocks[5].ops], ["save"]) diff --git a/python/paddle/fluid/tests/unittests/test_distributed_strategy.py b/python/paddle/fluid/tests/unittests/test_distributed_strategy.py index 8dbe2f398f210b43454ae6a984650bd9f7c5dc43..df32912b0c291df0ebb2fafb4b73be564d3bf6f3 100644 --- a/python/paddle/fluid/tests/unittests/test_distributed_strategy.py +++ b/python/paddle/fluid/tests/unittests/test_distributed_strategy.py @@ -15,7 +15,7 @@ import unittest import paddle.fluid as fluid from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig, ServerRuntimeConfig -from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import TrainerRuntimeConfig, StrategyFactory +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet import paddle.fluid.incubate.fleet.base.role_maker as role_maker import os @@ -201,8 +201,11 @@ class TestCreateDefaultStrategy(unittest.TestCase): server_endpoints=["127.0.0.1:6001", "127.0.0.1:6002"]) fleet.init(role) - optimizer = fluid.optimizer.SGD(0.0001) - optimizer = fleet.distributed_optimizer(optimizer) + def type_error_optimizer(): + optimizer = fluid.optimizer.SGD(0.0001) + optimizer = fleet.distributed_optimizer(optimizer) + + self.assertRaises(TypeError, type_error_optimizer) class TestHalfAsyncStrategy(unittest.TestCase): diff --git a/python/paddle/fluid/tests/unittests/test_entry_attr.py b/python/paddle/fluid/tests/unittests/test_entry_attr.py new file mode 100644 index 0000000000000000000000000000000000000000..918f6eab29b49258f3b07d05d23d8795c1e5b61e --- /dev/null +++ b/python/paddle/fluid/tests/unittests/test_entry_attr.py @@ -0,0 +1,102 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +import unittest +import paddle.fluid as fluid +from paddle.fluid.entry_attr import ProbabilityEntry, CountFilterEntry + + +class EntryAttrChecks(unittest.TestCase): + def base(self): + with self.assertRaises(NotImplementedError): + import paddle.fluid.entry_attr as entry + base = entry.EntryAttr() + base.to_attr() + + def probability_entry(self): + prob = ProbabilityEntry(0.5) + ss = prob.to_attr() + self.assertEqual("probability_entry:0.5", ss) + + with self.assertRaises(ValueError): + prob1 = ProbabilityEntry("none") + + with self.assertRaises(ValueError): + prob2 = ProbabilityEntry(-1) + + def countfilter_entry(self): + counter = CountFilterEntry(20) + ss = counter.to_attr() + self.assertEqual("count_filter_entry:20", ss) + + with self.assertRaises(ValueError): + counter1 = CountFilterEntry("none") + + with self.assertRaises(ValueError): + counter2 = CountFilterEntry(-1) + + def spaese_layer(self): + prog = fluid.Program() + scope = fluid.core.Scope() + + with fluid.scope_guard(scope): + with fluid.program_guard(prog): + input = fluid.layers.data( + name="dnn_data", + shape=[-1, 1], + dtype="int64", + lod_level=1, + append_batch_size=False) + prob = ProbabilityEntry(0.5) + emb = fluid.contrib.layers.sparse_embedding( + input=input, + size=[100, 10], + is_test=False, + entry=prob, + param_attr=fluid.ParamAttr(name="deep_embedding")) + pool = fluid.layers.sequence_pool(input=emb, pool_type="sum") + predict = fluid.layers.fc(input=pool, size=2, act='softmax') + + block = prog.global_block() + for op in block.ops: + if op.type == "lookup_table": + entry = op.attr("entry") + is_test = op.attr("is_test") + is_sparse = op.attr("is_sparse") + is_distributed = op.attr("is_distributed") + + self.assertEqual(entry, "probability_entry:0.5") + self.assertTrue(is_distributed) + self.assertTrue(is_sparse) + self.assertFalse(is_test) + + +class TestEntryAttrs(EntryAttrChecks): + def test_base(self): + self.base() + + def test_prob(self): + self.probability_entry() + + def test_counter(self): + self.countfilter_entry() + + def test_spaese_embedding_layer(self): + self.spaese_layer() + + +if __name__ == '__main__': + unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_entry_attr2.py b/python/paddle/fluid/tests/unittests/test_entry_attr2.py new file mode 100644 index 0000000000000000000000000000000000000000..48cdfc191cf1f926ca19a5263e9a6ec5bf1786cc --- /dev/null +++ b/python/paddle/fluid/tests/unittests/test_entry_attr2.py @@ -0,0 +1,61 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +import unittest +import paddle.fluid as fluid +from paddle.fluid.framework import default_main_program +from paddle.fluid.entry_attr import ProbabilityEntry, CountFilterEntry + + +class EntryAttrChecks(unittest.TestCase): + def embedding_layer(self): + prog = fluid.Program() + scope = fluid.core.Scope() + + with fluid.scope_guard(scope): + with fluid.program_guard(prog): + input = fluid.layers.data( + name="dnn_data", + shape=[-1, 1], + dtype="int64", + lod_level=1, + append_batch_size=False) + emb = fluid.layers.embedding( + input=input, + size=[100, 10], + is_sparse=True, + is_distributed=True, + param_attr=fluid.ParamAttr(name="deep_embedding")) + pool = fluid.layers.sequence_pool(input=emb, pool_type="sum") + predict = fluid.layers.fc(input=pool, size=2, act='softmax') + + block = prog.global_block() + for op in block.ops: + if op.type == "lookup_table": + is_sparse = op.attr("is_sparse") + is_distributed = op.attr("is_distributed") + + self.assertFalse(is_distributed) + self.assertTrue(is_sparse) + + +class TestEntryAttrs(EntryAttrChecks): + def test_embedding_layer(self): + self.embedding_layer() + + +if __name__ == '__main__': + unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_fleet.py b/python/paddle/fluid/tests/unittests/test_fleet.py index ca232dd2ff09b9435ce9554199306dd3e31489c9..449f31faf4035971f996e76612f10c882ce9179c 100644 --- a/python/paddle/fluid/tests/unittests/test_fleet.py +++ b/python/paddle/fluid/tests/unittests/test_fleet.py @@ -34,8 +34,7 @@ class TestFleet1(unittest.TestCase): def test_pslib_1(self): """Test cases for pslib.""" import paddle.fluid as fluid - from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet - from paddle.fluid.incubate.fleet.parameter_server.pslib import PSLib + from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet from paddle.fluid.incubate.fleet.base.role_maker import GeneralRoleMaker try: import netifaces diff --git a/python/paddle/fluid/tests/unittests/test_fleet_1.py b/python/paddle/fluid/tests/unittests/test_fleet_1.py deleted file mode 100644 index eaca009dd4a13f26473a9a445d20946d43441b3e..0000000000000000000000000000000000000000 --- a/python/paddle/fluid/tests/unittests/test_fleet_1.py +++ /dev/null @@ -1,232 +0,0 @@ -# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# 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. -"""Test fleet.""" - -from __future__ import print_function -import os -import unittest -import paddle.fluid.incubate.fleet.base.role_maker as role_maker - - -class TestFleet2(unittest.TestCase): - """Test cases for fleet ops.""" - - def setUp(self): - """Set up, set envs.""" - os.environ["PADDLE_TRAINERS_NUM"] = "2" - os.environ[ - "PADDLE_PSERVERS_IP_PORT_LIST"] = "127.0.0.1:36001,127.0.0.2:36001" - - def test_pslib_1(self): - """Test cases for pslib.""" - import paddle.fluid as fluid - from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet - from paddle.fluid.incubate.fleet.parameter_server.pslib import \ - fleet_embedding, _prepare_params, _fleet_embedding, \ - _fleet_embedding_v2, FLEET_GLOBAL_DICT - from paddle.fluid.incubate.fleet.base.role_maker import GeneralRoleMaker - try: - import netifaces - except: - print("warning: no netifaces, skip test_pslib_1") - return - os.environ["POD_IP"] = "127.0.0.1" - os.environ["PADDLE_PORT"] = "36001" - os.environ["TRAINING_ROLE"] = "TRAINER" - os.environ["PADDLE_TRAINER_ENDPOINTS"] = "127.0.0.1:36001" - os.environ["PADDLE_PSERVERS_IP_PORT_LIST"] = "127.0.0.1:36002" - os.environ["PADDLE_TRAINER_ID"] = "0" - role_maker = GeneralRoleMaker() - role_maker.generate_role() - place = fluid.CPUPlace() - exe = fluid.Executor(place) - fleet.init(role_maker) - train_program = fluid.Program() - startup_program = fluid.Program() - scope = fluid.Scope() - global FLEET_GLOBAL_DICT - with fluid.program_guard(train_program, startup_program): - show = fluid.layers.data(name="show", shape=[-1, 1], \ - dtype="int64", lod_level=1, append_batch_size=False) - click = fluid.layers.data(name="click", shape=[-1, 1], \ - dtype="int64", lod_level=1, append_batch_size=False) - with fleet_embedding(click_name=click.name): - emb = fluid.layers.embedding(input=show, size=[1, 1], \ - is_sparse=True, is_distributed=True, \ - param_attr=fluid.ParamAttr(name="embedding")) - emb = fluid.layers.data_norm( - input=emb, - name="a", - epsilon=1e-4, - param_attr={ - "batch_size": 1e4, - "batch_sum_default": 0.0, - "batch_square": 1e4 - }) - fc = fluid.layers.fc(input=emb, size=1, act=None) - label = fluid.layers.data(name="click", shape=[-1, 1], \ - dtype="int64", lod_level=1, append_batch_size=False) - label_cast = fluid.layers.cast(label, dtype='float32') - cost = fluid.layers.log_loss(fc, label_cast) - try: - adam = fluid.optimizer.Adam(learning_rate=0.000005) - adam = fleet.distributed_optimizer( - adam, - strategy={ - "embedding": { - "sparse_accessor_class": "DownpourSparseValueAccessor" - } - }) - adam.minimize([cost], [scope]) - except: - print("do not support pslib test, skip") - return - FLEET_GLOBAL_DICT["cur_accessor"] = "DownpourCtrAccessor" - try: - _prepare_params(input=show, size=[1, 1]) - except: - print("catch expected exception of param_attr=None") - try: - _prepare_params( - input=show, size=[1, 1], param_attr=fluid.ParamAttr()) - except: - print("catch expected exception of name=None") - try: - tmp = fluid.ParamAttr(name="embedding") - _prepare_params(input=show, size=1, param_attr=tmp) - except: - print("catch expected exception of size not list") - try: - tmp = fluid.ParamAttr(name="embedding") - _prepare_params(input=show, size=[-1, 12], param_attr=tmp) - except: - print("catch expected exception of size not equal") - try: - tmp = fluid.ParamAttr(name="embedding") - _prepare_params( - input=show, size=[-1, 1], param_attr=tmp, is_sparse=False) - except: - print("catch expected exception of is_sparse=False") - try: - tmp = fluid.ParamAttr(name="embedding") - _prepare_params(input=show, size=[-1, 1], param_attr=tmp, \ - is_sparse=True, is_distributed=False) - except: - print("catch expected exception of is_distributed=False") - try: - _prepare_params(input=show, size=[-1, 1], \ - param_attr=fluid.ParamAttr(name="embedding"), \ - is_sparse=True, is_distributed=True, dtype="abc") - except: - print("catch expected exception of unknown dtype") - try: - FLEET_GLOBAL_DICT["emb_to_accessor"]["embedding"] = "unknown" - tmp = fluid.ParamAttr(name="embedding") - _prepare_params(input=show, size=[-1, 1], param_attr=tmp) - except: - print("catch expected exception of unknown accessor") - FLEET_GLOBAL_DICT["cur_accessor"] = "DownpourCtrAccessor" - try: - _fleet_embedding(input=show, size=[-1, 1], is_sparse=True, \ - is_distributed=True, dtype="float32", \ - param_attr=fluid.ParamAttr(name="embedding")) - except: - print("catch expected exception of unknown accessor") - try: - _fleet_embedding_v2(input=show, size=[-1, 1], is_sparse=True, \ - is_distributed=True, dtype="float32", \ - param_attr=fluid.ParamAttr(name="embedding")) - except: - print("catch expected exception of unknown accessor") - - adam1 = fluid.optimizer.Adam(learning_rate=0.000005) - adam1 = fleet.distributed_optimizer( - adam1, - strategy={ - "embedding": { - "sparse_accessor_class": "DownpourSparseValueAccessor" - } - }) - try: - pre = FLEET_GLOBAL_DICT["emb_to_table"] - FLEET_GLOBAL_DICT["emb_to_table"] = {} - adam1.minimize([cost], [scope]) - except: - FLEET_GLOBAL_DICT["emb_to_table"] = pre - print("catch expected exception of empty emb_to_table") - try: - pre = FLEET_GLOBAL_DICT["emb_to_table"] - FLEET_GLOBAL_DICT["emb_to_table"] = {} - FLEET_GLOBAL_DICT["emb_to_table"]["emb1"] = 0 - adam1.minimize([cost], [scope]) - except: - FLEET_GLOBAL_DICT["emb_to_table"] = pre - print("catch expected exception of error emb_to_table") - try: - adam2 = fluid.optimizer.Adam(learning_rate=0.000005) - adam2 = fleet.distributed_optimizer(adam2) - adam2.supported_embedding_types = [] - adam2.minimize([cost], [scope]) - except: - print("catch expected exception of embedding_types") - try: - adam3 = fluid.optimizer.Adam(learning_rate=0.000005) - adam3 = fleet.distributed_optimizer( - adam3, - strategy={ - "embedding": { - "sparse_accessor_class": "DownpourSparseValueAccessor", - "sparse_embedx_dim": 999 - } - }) - adam3.minimize([cost], [scope]) - except: - print("catch expected exception of embedx_dim error") - - try: - adam4 = fluid.optimizer.Adam(learning_rate=0.000005) - adam4 = fleet.distributed_optimizer( - adam4, - strategy={ - "embedding": { - "sparse_accessor_class": "DownpourCtrAccessor", - "sparse_embedx_dim": 999 - } - }) - adam4.minimize([cost], [scope]) - except: - print("catch expected exception of embedx_dim error") - train_program1 = fluid.Program() - startup_program1 = fluid.Program() - FLEET_GLOBAL_DICT["emb_to_accessor"] = {} - with fluid.program_guard(train_program1, startup_program1): - show = fluid.layers.data(name="show", shape=[-1, 1], \ - dtype="int64", lod_level=1, append_batch_size=False) - with fleet_embedding(click_name=click.name): - emb = fluid.layers.embedding(input=show, size=[1, 1], \ - is_sparse=True, is_distributed=True, \ - param_attr=fluid.ParamAttr(name="embedding")) - with fleet_embedding(click_name=click.name): - emb1 = fluid.embedding(input=show, size=[1, 1], \ - is_sparse=True, is_distributed=True, \ - param_attr=fluid.ParamAttr(name="embedding")) - fleet.save_model("./tmodel_000") - fleet.save_one_table(0, "./tmodel_001") - fleet.save_one_table(0, "./tmodel_002", prefix="thahaha") - fleet.load_model("./tmodel_0003") - fleet.load_one_table(0, "./tmodel_004") - - -if __name__ == "__main__": - unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_fleet_2.py b/python/paddle/fluid/tests/unittests/test_fleet_2.py deleted file mode 100644 index fe42c249bec79a8e1d941bf47a4f6d44abaee502..0000000000000000000000000000000000000000 --- a/python/paddle/fluid/tests/unittests/test_fleet_2.py +++ /dev/null @@ -1,107 +0,0 @@ -# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# 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. -"""Test fleet.""" - -from __future__ import print_function -import os -import paddle.fluid as fluid -import unittest -import paddle.fluid.incubate.fleet.base.role_maker as role_maker -from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet -from paddle.fluid.incubate.fleet.parameter_server.pslib import \ - fleet_embedding, _prepare_params, _fleet_embedding, \ - _fleet_embedding_v2, FLEET_GLOBAL_DICT -from paddle.fluid.incubate.fleet.base.role_maker import GeneralRoleMaker - - -class TestFleet2(unittest.TestCase): - """Test cases for fleet ops.""" - - def test_in_memory_dataset_run_fleet(self): - """ - Testcase for InMemoryDataset from create to run. - """ - with open("test_in_memory_dataset_run_fleet_a.txt", "w") as f: - data = "1 1 1 2 2 3 3 4 5 5 5 5 1 1\n" - data += "1 0 1 3 2 3 4 4 6 6 6 6 1 2\n" - data += "1 1 1 4 2 3 5 4 7 7 7 7 1 3\n" - f.write(data) - with open("test_in_memory_dataset_run_fleet_b.txt", "w") as f: - data = "1 0 1 5 2 3 3 4 5 5 5 5 1 4\n" - data += "1 1 1 6 2 3 4 4 6 6 6 6 1 5\n" - data += "1 0 1 7 2 3 5 4 7 7 7 7 1 6\n" - data += "1 1 1 8 2 3 6 4 8 8 8 8 1 7\n" - f.write(data) - - slots = ["click", "slot1", "slot2", "slot3", "slot4"] - slots_vars = [] - for slot in slots: - var = fluid.layers.data( - name=slot, shape=[1], dtype="int64", lod_level=1) - slots_vars.append(var) - click = slots_vars[0] - embs = [] - for slot in slots_vars[1:3]: - with fleet_embedding(click_name=click.name): - emb = fluid.layers.embedding(input=slot, size=[-1, 11], \ - is_sparse=True, is_distributed=True, \ - param_attr=fluid.ParamAttr(name="embedding")) - embs.append(emb) - for slot in slots_vars[3:5]: - with fleet_embedding(click_name=click.name): - emb = fluid.embedding(input=slot, size=[-1, 11], \ - is_sparse=True, is_distributed=True, \ - param_attr=fluid.ParamAttr(name="embedding")) - emb = fluid.layers.reshape(emb, [-1, 11]) - embs.append(emb) - concat = fluid.layers.concat([embs[0], embs[3]], axis=1) - fc = fluid.layers.fc(input=concat, size=1, act=None) - label_cast = fluid.layers.cast(slots_vars[1], dtype='float32') - cost = fluid.layers.log_loss(fc, label_cast) - cost = fluid.layers.mean(cost) - - try: - fleet.init() - adam = fluid.optimizer.Adam(learning_rate=0.000005) - adam = fleet.distributed_optimizer(adam) - scope = fluid.Scope() - adam.minimize([cost], [scope]) - except: - print("do not support pslib test, skip") - return - - dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset") - dataset.set_batch_size(1) - dataset.set_thread(2) - dataset.set_filelist([ - "test_in_memory_dataset_run_fleet_a.txt", - "test_in_memory_dataset_run_fleet_b.txt" - ]) - dataset.set_pipe_command("cat") - dataset.set_use_var(slots_vars) - dataset.load_into_memory() - - exe = fluid.Executor(fluid.CPUPlace()) - exe.run(fluid.default_startup_program()) - exe.train_from_dataset(fluid.default_main_program(), dataset) - fleet._opt_info["stat_var_names"] = ["233"] - exe.infer_from_dataset(fluid.default_main_program(), dataset) - fleet._opt_info = None - fleet._fleet_ptr = None - os.remove("./test_in_memory_dataset_run_fleet_a.txt") - os.remove("./test_in_memory_dataset_run_fleet_b.txt") - - -if __name__ == "__main__": - unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_fleet_api_input.py b/python/paddle/fluid/tests/unittests/test_fleet_api_input.py index 0c50f6cf3ccfebba706bd9d019dbfe608daad9fa..9ca2b7c567c24a858efd08df9f4bff1e5e247b5e 100644 --- a/python/paddle/fluid/tests/unittests/test_fleet_api_input.py +++ b/python/paddle/fluid/tests/unittests/test_fleet_api_input.py @@ -22,7 +22,7 @@ from paddle.fluid.incubate.fleet.base.role_maker import UserDefinedCollectiveRol from paddle.fluid.incubate.fleet.base.role_maker import Role import paddle.fluid.incubate.fleet.base.role_maker as role_maker from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet -from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import TranspilerOptimizer +from paddle.fluid.incubate.fleet.parameter_server import TranspilerOptimizer from paddle.fluid.incubate.fleet.collective import CollectiveOptimizer from dist_simnet_bow import train_network diff --git a/python/paddle/fluid/tests/unittests/test_fleet_metric.py b/python/paddle/fluid/tests/unittests/test_fleet_metric.py index 6e5feece93fc5725bb5e49fa62daa7a22c1a6392..2dacc02797a251b894118e170f5a287a848790fc 100644 --- a/python/paddle/fluid/tests/unittests/test_fleet_metric.py +++ b/python/paddle/fluid/tests/unittests/test_fleet_metric.py @@ -20,8 +20,7 @@ import paddle.fluid as fluid import os import unittest import paddle.fleet.metrics.metric as metric -from paddle.fluid.incubate.fleet.base.role_maker import GeneralRoleMaker -from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet as fleet +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet class TestFleetMetric(unittest.TestCase): diff --git a/python/paddle/fluid/tests/unittests/test_fleet_nocvm_1.py b/python/paddle/fluid/tests/unittests/test_fleet_nocvm_1.py index a3038d1fb889d9fb40e30b4cebfad6db43de19b2..7b7e3c7c4173fe34368d6f4207491b3800907f57 100644 --- a/python/paddle/fluid/tests/unittests/test_fleet_nocvm_1.py +++ b/python/paddle/fluid/tests/unittests/test_fleet_nocvm_1.py @@ -33,8 +33,7 @@ class TestFleet1(unittest.TestCase): def test_pslib_1(self): """Test cases for pslib.""" import paddle.fluid as fluid - from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet - from paddle.fluid.incubate.fleet.parameter_server.pslib import PSLib + from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet from paddle.fluid.incubate.fleet.base.role_maker import GeneralRoleMaker try: import netifaces diff --git a/python/paddle/fluid/tests/unittests/test_fleet_ps.py b/python/paddle/fluid/tests/unittests/test_fleet_ps.py new file mode 100644 index 0000000000000000000000000000000000000000..04d1616399a2684b321f74aed63f753a8d0230d7 --- /dev/null +++ b/python/paddle/fluid/tests/unittests/test_fleet_ps.py @@ -0,0 +1,70 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +import unittest +from paddle.fluid.framework import default_main_program +from paddle.fluid.incubate.fleet.parameter_server.ir.pserver_pass import _get_optimizer_input_shape +main_program = default_main_program() + + +class TestFleetPS(unittest.TestCase): + def test_version(self): + from paddle.fluid.incubate.fleet.parameter_server import version + transpiler = version.is_transpiler() + self.assertEqual(transpiler, True) + + def test_optimizer_shape(self): + optimizers = [] + optimizers.append(("adam", "Moment1", [100, 1], [50, 1])) + optimizers.append(("adam", "Moment2", [100, 1], [50, 1])) + optimizers.append(("adagrad", "Moment", [100, 1], [50, 1])) + optimizers.append(("adamax", "Moment", [100, 1], [50, 1])) + optimizers.append(("adamax", "InfNorm", [100, 1], [50, 1])) + optimizers.append(("momentum", "Velocity", [100, 1], [50, 1])) + optimizers.append(("lars_momentum", "Velocity", [100, 1], [50, 1])) + optimizers.append(("decayed_adagrad", "Moment", [100, 1], [50, 1])) + optimizers.append(("rmsprop", "Moment", [100, 1], [50, 1])) + optimizers.append(("rmsprop", "MeanSquare", [100, 1], [50, 1])) + optimizers.append(("ftrl", "SquaredAccumulator", [100, 1], [50, 1])) + optimizers.append(("ftrl", "LinearAccumulator", [100, 1], [50, 1])) + + for attrs in optimizers: + op_type, varkey, orig_shape, param_shape = attrs + new_shape = _get_optimizer_input_shape(op_type, varkey, orig_shape, + param_shape) + self.assertListEqual(new_shape, param_shape) + + optimizers = [] + optimizers.append(("sgd", "", [100, 1], [50, 1])) + + for attrs in optimizers: + op_type, varkey, orig_shape, param_shape = attrs + new_shape = _get_optimizer_input_shape(op_type, varkey, orig_shape, + param_shape) + self.assertListEqual(new_shape, orig_shape) + + with self.assertRaises(ValueError): + optimizers = [] + optimizers.append(("new_opti", "", [100, 1], [50, 1])) + + for attrs in optimizers: + op_type, varkey, orig_shape, param_shape = attrs + _get_optimizer_input_shape(op_type, varkey, orig_shape, + param_shape) + + +if __name__ == '__main__': + unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_fleet_pyramid_hash.py b/python/paddle/fluid/tests/unittests/test_fleet_pyramid_hash.py index fb1c6988e15ee0f1c2a853ddc5fb935bd7adeb68..91e9cddd2a8dc1915d06937ae4eb3a47e8b1bbe6 100644 --- a/python/paddle/fluid/tests/unittests/test_fleet_pyramid_hash.py +++ b/python/paddle/fluid/tests/unittests/test_fleet_pyramid_hash.py @@ -13,11 +13,10 @@ # limitations under the License. import unittest -import numpy as np import paddle.fluid as fluid import paddle.fluid.incubate.fleet.base.role_maker as role_maker from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet -from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig +from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import StrategyFactory class TestPyramidHashOpApi(unittest.TestCase): @@ -59,11 +58,7 @@ class TestPyramidHashOpApi(unittest.TestCase): fleet.init(role) - strategy = DistributeTranspilerConfig() - strategy.sync_mode = False - strategy.geo_sgd_mode = True - strategy.geo_sgd_need_push_nums = 5 - + strategy = StrategyFactory.create_geo_strategy(5) optimizer = fluid.optimizer.SGD(0.1) optimizer = fleet.distributed_optimizer(optimizer, strategy) optimizer.minimize(cost) diff --git a/python/paddle/fluid/tests/unittests/test_fleet_rolemaker.py b/python/paddle/fluid/tests/unittests/test_fleet_rolemaker.py index 47aeee95921346fe61c83ff6cc2b4f6a1c7fb07e..3abad755ac1755ddd62859fae45a14e6aaf528ee 100644 --- a/python/paddle/fluid/tests/unittests/test_fleet_rolemaker.py +++ b/python/paddle/fluid/tests/unittests/test_fleet_rolemaker.py @@ -61,8 +61,7 @@ class TestCloudRoleMaker(unittest.TestCase): def test_pslib_1(self): """Test cases for pslib.""" import paddle.fluid as fluid - from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet - from paddle.fluid.incubate.fleet.parameter_server.pslib import PSLib + from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet from paddle.fluid.incubate.fleet.base.role_maker import GeneralRoleMaker try: import netifaces diff --git a/python/paddle/fluid/tests/unittests/test_fleet_rolemaker_2.py b/python/paddle/fluid/tests/unittests/test_fleet_rolemaker_2.py index 4e7de7c6ba0e861bccc550688c8bcaaf690cf34d..88a9d235855ce813ad0abc0f304eb0e8adc35ab9 100644 --- a/python/paddle/fluid/tests/unittests/test_fleet_rolemaker_2.py +++ b/python/paddle/fluid/tests/unittests/test_fleet_rolemaker_2.py @@ -32,8 +32,7 @@ class TestCloudRoleMaker2(unittest.TestCase): def test_pslib_2(self): """Test cases for pslib.""" import paddle.fluid as fluid - from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet - from paddle.fluid.incubate.fleet.parameter_server.pslib import PSLib + from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet from paddle.fluid.incubate.fleet.base.role_maker import GeneralRoleMaker from paddle.fluid.incubate.fleet.base.role_maker import RoleMakerBase try: @@ -60,10 +59,10 @@ class TestCloudRoleMaker2(unittest.TestCase): scope = fluid.Scope() with fluid.program_guard(train_program, startup_program): show = fluid.layers.data(name="show", shape=[-1, 1], \ - dtype="float32", lod_level=1, append_batch_size=False) + dtype="float32", lod_level=1, append_batch_size=False) fc = fluid.layers.fc(input=show, size=1, act=None) label = fluid.layers.data(name="click", shape=[-1, 1], \ - dtype="int64", lod_level=1, append_batch_size=False) + dtype="int64", lod_level=1, append_batch_size=False) label_cast = fluid.layers.cast(label, dtype='float32') cost = fluid.layers.log_loss(fc, label_cast) try: @@ -236,7 +235,7 @@ class TestCloudRoleMaker2(unittest.TestCase): def distributed_optimizer(self, optimizer, strategy=None): """ dummy distributed optimizer - + Args: optimizer(None): fake optimizer strategy(None): fake strategy diff --git a/python/paddle/fluid/tests/unittests/test_fleet_rolemaker_3.py b/python/paddle/fluid/tests/unittests/test_fleet_rolemaker_3.py index fe650ef0a2f3d07f3f301f5f031740ffb1bc13c3..39d3d2a2a042c74f2af0e92dd740a28ef60a5d5d 100644 --- a/python/paddle/fluid/tests/unittests/test_fleet_rolemaker_3.py +++ b/python/paddle/fluid/tests/unittests/test_fleet_rolemaker_3.py @@ -33,8 +33,7 @@ class TestCloudRoleMaker(unittest.TestCase): def test_pslib_1(self): """Test cases for pslib.""" import paddle.fluid as fluid - from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet - from paddle.fluid.incubate.fleet.parameter_server.pslib import PSLib + from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet from paddle.fluid.incubate.fleet.base.role_maker import GeneralRoleMaker try: import netifaces diff --git a/python/paddle/fluid/tests/unittests/test_fleet_unitaccessor.py b/python/paddle/fluid/tests/unittests/test_fleet_unitaccessor.py index 8e71ccf92895a54d0764acc65fb48fddd1794691..3b0e8be63d95f29ccd1da145403a7a441698fead 100644 --- a/python/paddle/fluid/tests/unittests/test_fleet_unitaccessor.py +++ b/python/paddle/fluid/tests/unittests/test_fleet_unitaccessor.py @@ -33,8 +33,7 @@ class TestFleet1(unittest.TestCase): def test_pslib_1(self): """Test cases for pslib.""" import paddle.fluid as fluid - from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet - from paddle.fluid.incubate.fleet.parameter_server.pslib import PSLib + from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet from paddle.fluid.incubate.fleet.base.role_maker import GeneralRoleMaker try: import netifaces @@ -57,13 +56,13 @@ class TestFleet1(unittest.TestCase): scope = fluid.Scope() with fluid.program_guard(train_program, startup_program): show = fluid.layers.data(name="show", shape=[-1, 1], \ - dtype="int64", lod_level=1, append_batch_size=False) + dtype="int64", lod_level=1, append_batch_size=False) emb = fluid.layers.embedding(input=show, size=[1, 1], \ - is_sparse=True, is_distributed=True, \ - param_attr=fluid.ParamAttr(name="embedding")) + is_sparse=True, is_distributed=True, \ + param_attr=fluid.ParamAttr(name="embedding")) fc = fluid.layers.fc(input=emb, size=1, act=None) label = fluid.layers.data(name="click", shape=[-1, 1], \ - dtype="int64", lod_level=1, append_batch_size=False) + dtype="int64", lod_level=1, append_batch_size=False) label_cast = fluid.layers.cast(label, dtype='float32') cost = fluid.layers.log_loss(fc, label_cast) diff --git a/python/paddle/fluid/tests/unittests/test_lookup_remote_table_op.py b/python/paddle/fluid/tests/unittests/test_lookup_remote_table_op.py deleted file mode 100644 index 6059b5e5580455e81eb2144cbaa775790e21e2e0..0000000000000000000000000000000000000000 --- a/python/paddle/fluid/tests/unittests/test_lookup_remote_table_op.py +++ /dev/null @@ -1,204 +0,0 @@ -# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# 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 __future__ import print_function - -import os -import signal -import time -import unittest -from multiprocessing import Process - -import numpy as np -import paddle.fluid as fluid -import paddle.fluid.core as core -from paddle.fluid.op import Operator -from paddle.fluid.framework import Program, program_guard -from paddle.fluid.transpiler.distribute_transpiler import DistributedMode -from dist_test_utils import * - - -def run_pserver(pserver_id, use_cuda, sync_mode): - remove_ps_flag(os.getgid()) - scope = fluid.core.Scope() - program = Program() - with fluid.scope_guard(scope): - with program_guard(program, startup_program=Program()): - # create table parameter in scope - place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() - # create and initialize Param Variable - param = scope.var('table').get_tensor() - - param_array = np.ones((10, 8)).astype("float32") - for i in range(len(param_array)): - param_array[i] *= param_array[i] * i + pserver_id * 10 - param.set(param_array, place) - - optimize_block = program._create_block(program.global_block().idx) - program.global_block().append_op( - type="listen_and_serv", - inputs={'X': []}, - outputs={}, - attrs={ - "optimize_blocks": [optimize_block], - "endpoint": '127.0.0.1:0', - "Fanin": 1, - "distributed_mode": DistributedMode.SYNC, - "grad_to_block_id": [] - }) - - exe = fluid.Executor(place) - exe.run(program) - - -class TestListenAndServOp(unittest.TestCase): - def setUp(self): - self.ps_timeout = 5 - - def _start_pserver(self, pserver_id, use_cuda, sync_mode, pserver_func): - p = Process(target=pserver_func, args=(pserver_id, use_cuda, sync_mode)) - p.daemon = True - p.start() - return p - - def _wait_ps_ready(self, pid): - start_left_time = self.ps_timeout - sleep_time = 0.5 - while True: - assert start_left_time >= 0, "wait ps ready failed" - time.sleep(sleep_time) - try: - # the listen_and_serv_op would touch a file which contains the listen port - # on the /tmp directory until it was ready to process all the RPC call. - os.stat("/tmp/paddle.%d.port" % pid) - return - except os.error: - start_left_time -= sleep_time - - def _get_pserver_port(self, pid): - with open("/tmp/paddle.%d.port" % pid, 'r') as f: - port = int(f.read().strip()) - return port - - def _run_lookup_table_op_one_pserver(self, place, port): - scope = fluid.core.Scope() - program = Program() - with fluid.scope_guard(scope): - with program_guard(program, startup_program=Program()): - # create and initialize Param Variable - param = scope.var('W').get_tensor() - param_array = np.full((10, 8), 1.0).astype("float32") - param.set(param_array, place) - - ids = scope.var('Ids').get_tensor() - ids_array = np.array([[1], [2], [5]]).astype("int64") - ids.set(ids_array, place) - ids_lod = [[0, 1, 2, 3]] - ids.set_lod(ids_lod) - - out = scope.var('Out').get_tensor() - - emaps = ['127.0.0.1:' + str(port)] - table_names = ['table'] - height_sections = [10] - - # create and run sgd operator - lookup_table_op = Operator( - "lookup_table", - W='W', - Ids='Ids', - Out='Out', - remote_prefetch=True, - epmap=emaps, - table_names=table_names, - height_sections=height_sections) - lookup_table_op.run(scope, place) - - # get and compare result - result_array = np.array(out) - - self.assertEqual(out.lod(), ids_lod) - self.assertEqual(list(result_array.shape), [len(ids_array), 8]) - for i in range(len(ids_array)): - id = ids_array[i][0] - self.assertTrue((result_array[i] == id).all()) - - def _run_lookup_table_op_two_pserver(self, place, port0, port1): - scope = fluid.core.Scope() - program = Program() - with fluid.scope_guard(scope): - with program_guard(program, startup_program=Program()): - # create and initialize Param Variable - param = scope.var('W').get_tensor() - param_array = np.full((10, 8), 1.0).astype("float32") - param.set(param_array, place) - - ids = scope.var('Ids').get_tensor() - ids_array = np.array([[1], [2], [11], [13]]).astype("int64") - ids.set(ids_array, place) - ids_lod = [[0, 2, 3, 4]] - ids.set_lod(ids_lod) - - out = scope.var('Out').get_tensor() - - emaps = ['127.0.0.1:' + str(port0), '127.0.0.1:' + str(port1)] - table_names = ['table', 'table'] - height_sections = [10, 20] - - # create and run sgd operator - lookup_table_op = Operator( - "lookup_table", - W='W', - Ids='Ids', - Out='Out', - remote_prefetch=True, - epmap=emaps, - table_names=table_names, - height_sections=height_sections) - lookup_table_op.run(scope, place) - - # get and compare result - result_array = np.array(out) - self.assertEqual(out.lod(), ids_lod) - self.assertEqual(list(result_array.shape), [len(ids_array), 8]) - for i in range(len(ids_array)): - id = ids_array[i][0] - self.assertTrue((result_array[i] == id).all()) - - def test_lookup_remote_table(self): - os.environ['PADDLE_ENABLE_REMOTE_PREFETCH'] = "1" - # run pserver on CPU in sync mode - p0 = self._start_pserver(0, False, True, run_pserver) - self._wait_ps_ready(p0.pid) - port0 = self._get_pserver_port(p0.pid) - - p1 = self._start_pserver(1, False, True, run_pserver) - self._wait_ps_ready(p1.pid) - port1 = self._get_pserver_port(p1.pid) - - places = [core.CPUPlace()] - - for place in places: - self._run_lookup_table_op_one_pserver(place, port0) - self._run_lookup_table_op_two_pserver(place, port0, port1) - - # raise SIGTERM to pserver - os.kill(p0.pid, signal.SIGINT) - p0.join() - os.kill(p1.pid, signal.SIGINT) - p1.join() - - -if __name__ == '__main__': - unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_lookup_sparse_table_op.py b/python/paddle/fluid/tests/unittests/test_lookup_sparse_table_op.py deleted file mode 100644 index a2a036e02a1c889705274fd1b9947a0b962c42b2..0000000000000000000000000000000000000000 --- a/python/paddle/fluid/tests/unittests/test_lookup_sparse_table_op.py +++ /dev/null @@ -1,118 +0,0 @@ -# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# 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 __future__ import print_function - -import unittest -import numpy as np -from op_test import OpTest -import paddle.fluid.core as core -from paddle.fluid.op import Operator - - -class TestLookupSpraseTable(unittest.TestCase): - def check_with_place(self, place): - scope = core.Scope() - - # create and initialize W Variable - table_size = 10000 - row_numel = 8 - - w_selected_rows = scope.var('W').get_selected_rows() - w_selected_rows.set_height(table_size) - w_array = np.ones((table_size, row_numel)).astype("float32") - for i in range(table_size): - w_array[i] *= i - w_tensor = w_selected_rows.get_tensor() - w_tensor.set(w_array, place) - - # create and initialize Id Variable - ids = scope.var("Ids").get_tensor() - ids_array1 = np.array([0, 2, 3, 2, 5, 0, 100]).astype("int64") - ids.set(ids_array1, place) - - # create Out Variable - out_tensor = scope.var('Out').get_tensor() - - # create and run lookup_table operator - lookup_table = Operator( - "lookup_sparse_table", - W='W', - Ids='Ids', - Out='Out', - min=-5.0, - max=10.0, - seed=10) - lookup_table.run(scope, place) - - # get result from Out - result_array1 = np.array(out_tensor) - # all(): return True if all elements of the iterable are true (or if the iterable is empty) - assert (result_array1[0] == w_array[0]).all() - assert (result_array1[1] == w_array[1]).all() - assert (result_array1[2] == w_array[2]).all() - assert (result_array1[3] == w_array[1]).all() - assert (result_array1[4] == w_array[3]).all() - assert (result_array1[5] == w_array[0]).all() - assert (result_array1[6] == w_array[4]).all() - - # create and initialize Id Variable - ids = scope.var("Ids").get_tensor() - ids_array2 = np.array([4, 2, 3, 7, 100000]).astype("int64") - ids.set(ids_array2, place) - lookup_table.run(scope, place) - - result_array2 = np.array(out_tensor) - assert (result_array2[0] == w_array[5]).all() - assert (result_array2[1] == w_array[1]).all() - assert (result_array2[2] == w_array[2]).all() - assert (result_array2[3] == w_array[6]).all() - assert (result_array2[4] == w_array[7]).all() - - # create and run lookup_table operator - test_lookup_table = Operator( - "lookup_sparse_table", - W='W', - Ids='Ids', - Out='Out', - min=-5.0, - max=10.0, - seed=10, - is_test=True) - - ids = scope.var("Ids").get_tensor() - unknown_id = [44, 22, 33] - ids_array2 = np.array([4, 2, 3, 7, 100000] + unknown_id).astype("int64") - ids.set(ids_array2, place) - test_lookup_table.run(scope, place) - - result_array2 = np.array(out_tensor) - assert (result_array2[0] == w_array[5]).all() - assert (result_array2[1] == w_array[1]).all() - assert (result_array2[2] == w_array[2]).all() - assert (result_array2[3] == w_array[6]).all() - assert (result_array2[4] == w_array[7]).all() - - for i in [5, 6, 7]: - assert np.all(result_array2[i] == 0) - - def test_w_is_selected_rows(self): - places = [core.CPUPlace()] - # currently only support CPU - for place in places: - self.check_with_place(place) - - -if __name__ == "__main__": - unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_lookup_sparse_table_split_op.py b/python/paddle/fluid/tests/unittests/test_lookup_sparse_table_split_op.py new file mode 100644 index 0000000000000000000000000000000000000000..53a415f65ea43ddbbab5aed801d38ee4584ad086 --- /dev/null +++ b/python/paddle/fluid/tests/unittests/test_lookup_sparse_table_split_op.py @@ -0,0 +1,69 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +import unittest +import numpy as np +import paddle.fluid.core as core +from paddle.fluid.op import Operator + + +class TestLookupSpraseTable(unittest.TestCase): + def check_with_place(self, place): + scope = core.Scope() + + rows = [0, 1, 2, 3, 4, 5, 6] + row_numel = 7 + + w_selected_rows = scope.var('W').get_selected_rows() + w_selected_rows.set_height(len(rows)) + w_selected_rows.set_rows(rows) + w_array = np.ones((len(rows), row_numel)).astype("float32") + for i in range(len(rows)): + w_array[i] *= i + w_tensor = w_selected_rows.get_tensor() + w_tensor.set(w_array, place) + + # create and initialize Id Variable + ids = scope.var("Ids").get_tensor() + + # create and run lookup_table operator + lookup_table = Operator( + "lookup_sparse_table_grad_split", + Grad='W', + Row={'Ids'}, + Value={'W'}, + is_entry=False, + tablename="sparse") + lookup_table.run(scope, place) + + # get result from Out + result_array1 = np.array(ids) + print(result_array1) + print("== = = == == = == ==== ==== === ") + value = scope.var("W").get_tensor() + result_array1 = np.array(value) + print(result_array1.shape) + print(result_array1) + + def test_w_is_selected_rows(self): + places = [core.CPUPlace()] + # currently only support CPU + for place in places: + self.check_with_place(place) + + +if __name__ == "__main__": + unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_nce_remote_table_op.py b/python/paddle/fluid/tests/unittests/test_nce_remote_table_op.py deleted file mode 100644 index 3692a9f30b48afe59a6ff9155ba78f4a57195cda..0000000000000000000000000000000000000000 --- a/python/paddle/fluid/tests/unittests/test_nce_remote_table_op.py +++ /dev/null @@ -1,239 +0,0 @@ -# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# 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 __future__ import print_function - -import os -import signal -import time -import unittest -from multiprocessing import Process - -import numpy as np -import paddle.fluid as fluid -import paddle.fluid.core as core -from paddle.fluid.op import Operator -from paddle.fluid.framework import Program, program_guard -from dist_test_utils import * -from paddle.fluid.transpiler.distribute_transpiler import DistributedMode - - -def nce(input, weight, bias, sample_weight, labels, num_classes, - num_sample_class): - samples = [] - sample_labels = [] - batch_size = input.shape[0] - num_true_class = labels.shape[1] - for i in range(batch_size): - w = 1 if sample_weight is None else sample_weight[i] - for label in labels[i]: - samples.append((i, label, True, w)) - sample_labels.append(label) - for num in range(num_sample_class): - samples.append((i, num, False, w)) - sample_labels.append(num) - # forward bias - sample_out = np.zeros(len(samples)).astype(np.float32) - if bias is not None: - for i in range(len(samples)): - sample_out[i] = bias[samples[i][1]] - # forward weight - for i in range(len(samples)): - sample_out[i] += np.dot(input[samples[i][0]], weight[samples[i][1]]) - - # forward activation - sample_out = 1.0 / (1.0 + np.exp(-sample_out)) - # forward cost - out = np.zeros(batch_size).astype(np.float32) - b = 1.0 / num_classes * num_sample_class - - for i in range(len(samples)): - o = sample_out[i] - cost = -np.log(o / (o + b)) if samples[i][2] else -np.log(b / (o + b)) - out[samples[i][0]] += cost * samples[i][3] - return (out[:, np.newaxis], np.array(sample_out).reshape( - batch_size, num_sample_class + num_true_class), - np.array(sample_labels).reshape(batch_size, - num_sample_class + num_true_class)) - - -def run_pserver(pserver_id, use_cuda, sync_mode): - remove_ps_flag(os.getpid()) - scope = fluid.core.Scope() - program = Program() - with fluid.scope_guard(scope): - with program_guard(program, startup_program=Program()): - # create table parameter in scope - place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() - # create and initialize Param Variable - param = scope.var('table').get_tensor() - - param_array = np.ones((5, 8)).astype("float32") - for i in range(len(param_array)): - param_array[i] *= param_array[i] * i + pserver_id * 10 + 1 - param.set(param_array, place) - - optimize_block = program._create_block(program.global_block().idx) - program.global_block().append_op( - type="listen_and_serv", - inputs={'X': []}, - outputs={}, - attrs={ - "optimize_blocks": [optimize_block], - "endpoint": '127.0.0.1:0', - "Fanin": 1, - "distributed_mode": DistributedMode.SYNC, - "grad_to_block_id": [] - }) - - exe = fluid.Executor(place) - exe.run(program) - - -class TestListenAndServOp(unittest.TestCase): - def setUp(self): - self.ps_timeout = 5 - - def _start_pserver(self, pserver_id, use_cuda, sync_mode, pserver_func): - p = Process(target=pserver_func, args=(pserver_id, use_cuda, sync_mode)) - p.daemon = True - p.start() - return p - - def _wait_ps_ready(self, pid): - start_left_time = self.ps_timeout - sleep_time = 0.5 - while True: - assert start_left_time >= 0, "wait ps ready failed" - time.sleep(sleep_time) - try: - # the listen_and_serv_op would touch a file which contains the listen port - # on the /tmp directory until it was ready to process all the RPC call. - os.stat("/tmp/paddle.%d.port" % pid) - return - except os.error: - start_left_time -= sleep_time - - def _get_pserver_port(self, pid): - with open("/tmp/paddle.%d.port" % pid, 'r') as f: - port = int(f.read().strip()) - return port - - def _run_nce_op_two_pserver(self, place, port0, port1): - scope = fluid.core.Scope() - program = Program() - with fluid.scope_guard(scope): - with program_guard(program, startup_program=Program()): - x = scope.var('Input').get_tensor() - x_array = np.random.random((4, 8)).astype("float32") - x.set(x_array, place) - # create and initialize Param Variable - param = scope.var('Weight').get_tensor() - param_array = np.zeros((5, 8)).astype("float32") - param.set(param_array, place) - - bias = scope.var('Bias').get_tensor() - bias_array = np.random.random((5, 1)).astype("float32") - bias.set(bias_array, place) - - sample_w = scope.var('SampleWeight').get_tensor() - sample_weight = np.random.random((4, 1)).astype("float32") - sample_w.set(sample_weight, place) - - label = scope.var('Label').get_tensor() - label_array = np.array([[0], [1], [4], [3]]) - label.set(label_array, place) - - cost = scope.var('Cost').get_tensor() - cost_w = np.zeros((4, 1)).astype("float32") - cost.set(cost_w, place) - - sample_l = scope.var('SampleLogits').get_tensor() - sample_l_w = np.zeros((4, 3)).astype("float32") - sample_l.set(sample_l_w, place) - - sample_la = scope.var('SampleLabels').get_tensor() - sample_la_w = np.zeros((4, 3)).astype("int") - sample_la.set(sample_la_w, place) - - emaps = ['127.0.0.1:' + str(port0), '127.0.0.1:' + str(port1)] - table_names = ['table', 'table'] - height_sections = [2, 3] - - # create and run nce operator - nce_op = Operator( - "nce", - Input='Input', - Weight='Weight', - Label='Label', - Bias='Bias', - Cost='Cost', - SampleLogits='SampleLogits', - SampleLabels='SampleLabels', - SampleWeight='SampleWeight', - num_total_classes=5, - num_neg_samples=2, - custom_neg_classes=list(range(2)), - sampler=0, - seed=0, - is_sparse=True, - remote_prefetch=True, - epmap=emaps, - table_names=table_names, - height_sections=height_sections) - - nce_op.run(scope, place) - - # get and compare result - o_cost = np.array(scope.var('Cost').get_tensor()) - o_logits = np.array(scope.var('SampleLogits').get_tensor()) - o_labels = np.array(scope.var('SampleLabels').get_tensor()) - - param_array = np.ones((5, 8)).astype("float32") - for i in range(2): - param_array[i] *= param_array[i] * i + 0 * 10 + 1 - for i in range(2, 5): - param_array[i] *= param_array[i] * i + 1 * 10 + 1 - out = nce(x_array, param_array, bias_array, sample_weight, - label_array, 5, 2) - - np.testing.assert_almost_equal(o_cost, out[0], decimal=6) - np.testing.assert_almost_equal(o_logits, out[1], decimal=6) - np.testing.assert_almost_equal(o_labels, out[2], decimal=6) - - def test_nce_op_remote(self): - os.environ['PADDLE_ENABLE_REMOTE_PREFETCH'] = "1" - # run pserver on CPU in sync mode - p0 = self._start_pserver(0, False, True, run_pserver) - self._wait_ps_ready(p0.pid) - port0 = self._get_pserver_port(p0.pid) - - p1 = self._start_pserver(1, False, True, run_pserver) - self._wait_ps_ready(p1.pid) - port1 = self._get_pserver_port(p1.pid) - - places = [core.CPUPlace()] - - for place in places: - self._run_nce_op_two_pserver(place, port0, port1) - - # raise SIGTERM to pserver - os.kill(p0.pid, signal.SIGINT) - p0.join() - os.kill(p1.pid, signal.SIGINT) - p1.join() - - -if __name__ == '__main__': - unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_ps_dispatcher.py b/python/paddle/fluid/tests/unittests/test_ps_dispatcher.py new file mode 100644 index 0000000000000000000000000000000000000000..16abb8a7da4e6e82c61a8191f9ee312b190f0c57 --- /dev/null +++ b/python/paddle/fluid/tests/unittests/test_ps_dispatcher.py @@ -0,0 +1,74 @@ +# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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 __future__ import print_function + +import unittest +from paddle.fluid.incubate.fleet.parameter_server.ir.ps_dispatcher import RoundRobin, HashName, PSDispatcher + + +class TestPsDispatcher(unittest.TestCase): + def setUp(self): + self.points = [ + "127.0.0.1:1001", "127.0.0.1:1002", "127.0.0.1:1003", + "127.0.0.1:1004" + ] + + def test_base(self): + base = PSDispatcher(self.points) + self.assertEqual(len(base.eps), 4) + base.reset() + + with self.assertRaises(NotImplementedError): + base.dispatch([]) + + def test_hash(self): + class Var: + def __init__(self, index): + self._name = "var_{}".format(index) + + def name(self): + return self._name + + xx = HashName(self.points) + self.assertEqual(len(xx.eps), 4) + xx.reset() + + vars = [] + for i in range(4): + vars.append(Var(i)) + eplist = xx.dispatch(vars) + self.assertEqual(len(eplist), 4) + + def test_round_rodin(self): + class Var: + def __init__(self, index): + self._name = "var_{}".format(index) + + def name(self): + return self._name + + xx = RoundRobin(self.points) + self.assertEqual(len(xx.eps), 4) + xx.reset() + + vars = [] + for i in range(4): + vars.append(Var(i)) + eplist = xx.dispatch(vars) + self.assertEqual(len(eplist), 4) + + +if __name__ == '__main__': + unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_pyramid_hash_op.py b/python/paddle/fluid/tests/unittests/test_pyramid_hash_op.py index e06ee69d679f0412efc8cd14883412ad811ca04e..9ffea2c565cb9d34569b2eb4e452bd5894e08c63 100644 --- a/python/paddle/fluid/tests/unittests/test_pyramid_hash_op.py +++ b/python/paddle/fluid/tests/unittests/test_pyramid_hash_op.py @@ -15,9 +15,6 @@ import unittest import numpy as np import paddle.fluid as fluid -import paddle.fluid.incubate.fleet.base.role_maker as role_maker -from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet -from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig class TestPyramidHashOpApi(unittest.TestCase): diff --git a/python/paddle/fluid/tests/unittests/test_recv_save_op.py b/python/paddle/fluid/tests/unittests/test_recv_save_op.py index 0456fdbc84650a144f0be60dd9705d426e227784..82718f683be859802288d7ffbabc09d8fc42309c 100644 --- a/python/paddle/fluid/tests/unittests/test_recv_save_op.py +++ b/python/paddle/fluid/tests/unittests/test_recv_save_op.py @@ -29,7 +29,7 @@ from paddle.fluid.op import Operator from paddle.fluid.framework import Program, program_guard from paddle.fluid.transpiler.details import VarStruct, VarsDistributed from dist_test_utils import * -from paddle.fluid.transpiler.distribute_transpiler import DistributedMode +from paddle.fluid.incubate.fleet.parameter_server.mode import DistributedMode def run_pserver(pserver_id): @@ -109,6 +109,7 @@ class TestListenAndServOp(unittest.TestCase): slice_shapes=["5,8", "5,8"], slice_varnames=["table", "table"], remote_varnames=['table', 'table'], + is_sparse=False, endpoints=emaps, file_path=model_file) @@ -180,58 +181,8 @@ class TestListenAndServOp(unittest.TestCase): np.testing.assert_equal(origin[5:10], slice1) def _save_by_io_persistables(self, place, port0, port1, dirname, var_name): - exe = fluid.Executor(place=place) - - vars_overview = VarsDistributed() - - orig_var = VarStruct( - name=var_name, - type=fluid.core.VarDesc.VarType.LOD_TENSOR, - shape=[10, 8], - dtype="float32", - lod_level=0, - persistable=True) - - slice_0_var = VarStruct( - name=var_name, - type=fluid.core.VarDesc.VarType.LOD_TENSOR, - shape=[5, 8], - dtype="float32", - lod_level=0, - persistable=True) - - slice_1_var = VarStruct( - name=var_name, - type=fluid.core.VarDesc.VarType.LOD_TENSOR, - shape=[5, 8], - dtype="float32", - lod_level=0, - persistable=True) - - vars_overview.add_distributed_var( - origin_var=orig_var, - slice_var=slice_0_var, - block_id=0, - offset=0, - is_slice=True, - vtype="RemotePrefetch", - endpoint="{}:{}".format("127.0.0.1", port0)) - - vars_overview.add_distributed_var( - origin_var=orig_var, - slice_var=slice_1_var, - block_id=1, - offset=40, - is_slice=True, - vtype="RemotePrefetch", - endpoint="{}:{}".format("127.0.0.1", port1)) - - program = Program() - program._is_distributed = True - program._is_chief = True - program._parameters_on_pservers = vars_overview - - fluid.io.save_persistables(exe, dirname, program) + self._run_nce_op_two_pserver(place, port0, port1, + os.path.join(dirname, var_name)) def test_recv_save_op_remote(self): # run pserver on CPU in sync mode diff --git a/python/paddle/fluid/transpiler/geo_sgd_transpiler.py b/python/paddle/fluid/transpiler/geo_sgd_transpiler.py index 702b355696de9cda3cf86c88d1c52e207ea85bae..5fbbedc12d0b45d39bfceed2d45d609c55bb2c22 100644 --- a/python/paddle/fluid/transpiler/geo_sgd_transpiler.py +++ b/python/paddle/fluid/transpiler/geo_sgd_transpiler.py @@ -38,7 +38,8 @@ from ..framework import Program, default_main_program, \ from .details import wait_server_ready, VarsDistributed from .details import delete_ops from ..distribute_lookup_table import find_distributed_lookup_table -from .distribute_transpiler import DistributeTranspiler, DistributeTranspilerConfig, slice_variable, same_or_split_var, ServerRuntimeConfig, DistributedMode +from .distribute_transpiler import DistributeTranspiler, DistributeTranspilerConfig, slice_variable, same_or_split_var, ServerRuntimeConfig +from paddle.fluid.incubate.fleet.parameter_server.mode import DistributedMode RPC_OP_ROLE_ATTR_NAME = op_role_attr_name = core.op_proto_and_checker_maker.kOpRoleAttrName( ) diff --git a/python/setup.py.in b/python/setup.py.in index 10325e096fb7674de1ba10bca724165b840eb14e..318f1bc9041e399365a9086db5608133d54593ea 100644 --- a/python/setup.py.in +++ b/python/setup.py.in @@ -1,6 +1,7 @@ import subprocess import os import os.path +import errno import re import shutil import sys @@ -134,6 +135,7 @@ def is_transpiler(): write_distributed_training_mode_py(filename='@PADDLE_BINARY_DIR@/python/paddle/fluid/incubate/fleet/parameter_server/version.py') + packages=['paddle', 'paddle.libs', 'paddle.utils', @@ -185,6 +187,7 @@ packages=['paddle', 'paddle.fluid.incubate.fleet.parameter_server', 'paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler', 'paddle.fluid.incubate.fleet.parameter_server.pslib', + 'paddle.fluid.incubate.fleet.parameter_server.ir', 'paddle.fluid.incubate.fleet.collective', 'paddle.fluid.incubate.fleet.utils', 'paddle.incubate.hapi',