def receive_blocks(self, package: IPack): self.__global_weights -= package.content reply = NormalPack( Parameter_Server, self.__global_weights.astype( GlobalSettings.get_params(Low_Precision_Server))) return netEncapsulation(package.node_id, reply)
def update_blocks( self, block_weight: BlockWeight) -> netEncapsulation[NormalPack]: package = NormalPack( self.node_id, block_weight.content.astype( GlobalSettings.get_params(Full_Precision_Client))) return netEncapsulation(Parameter_Server, package)
def receive_blocks(self, content: dict): """ SGQ receive a quantized matrix and returns the grad diff for the client :param content: :return: """ # decode data data = SGQPackage.decode(content) # get working node state last_state = self.Weights_Last_Received[data.node_id] # update global state self.Global_State = self.Global_State + data.content() # get grad diff grad_diff = self.Global_State - last_state # encode data data_rtn = SGQPackage(grad_diff) # update state buffer self.Weights_Last_Received[ data.node_id] = last_state + data_rtn.content() # for DEBUG error = np.sum(self.Weights_Last_Received[data.node_id] - self.Global_State) if error > SGQServer.__max_error: SGQServer.__max_error = error print("Error:", error) # return return netEncapsulation(data.node_id, data_rtn.encode())
def update_blocks( self, block_weight: BlockWeight) -> netEncapsulation[QuantizedPack]: package = QuantizedPack( self.node_id, *quantize(block_weight.content, QuantizedClient.codex)) return netEncapsulation(Parameter_Server, package)
def update_blocks(self, block_weight: BlockWeight): """ Update weights to parameter server :param block_weight: :return: """ content = block_weight.content pkg = SGQPackage(content, self.node_id) return netEncapsulation(Parameter_Server, pkg.encode())
def update_blocks( self, block_weight: BlockWeight ) -> Union[Iterable[netEncapsulation], netEncapsulation, None]: self.__local_turn += 1 if self.__local_turn >= self.__TURN: return netEncapsulation(Parameter_Server, (self.node_id, block_weight.content)) else: self.set_result(block_weight.content)
def receive_blocks(self, package: IPack) -> netEncapsulation[IPack]: delta_w = package.decode(DC_QSGDServer.codex) ggw_t = np.multiply(np.multiply(self.__gw_t, self.__gw_t), delta_w) gw_t_tau = self.__gw_t + self.__lambda * ggw_t self.set_result(gw_t_tau - delta_w, lambda x, y: x + y if x is not None else y) return netEncapsulation( Parameter_Server, QuantizedPack(self.node_id, gw_t_tau, DC_QSGDClient.codex))
def receive_blocks(self, package: IPack): grad = package.content self.__global_weights -= grad self.__vt = self.__beta * self.__vt + np.square(grad) * (1 - self.__beta) reply = QuantizedPack( Parameter_Server, *Q_w(self.__global_weights, QuantizedParaServer.q_space, np.sqrt(self.__vt))) return netEncapsulation(package.node_id, reply)
def receive_blocks( self, content: Tuple[int, ndarray] ) -> Union[Iterable[netEncapsulation], netEncapsulation, None]: """ PA Server receive a json_dict and send back a request :param content: :return: """ # update global current state self.Current_Weights = self.Current_Weights - content[1] return netEncapsulation(content[0], (-1, self.Current_Weights))
def update_blocks( self, block_weight: BlockWeight ) -> netEncapsulation[Tuple[int, ndarray]]: """ Try collect all blocks. """ self.BlockWeights[block_weight.block_id] = block_weight.content self.check_for_combine() send_to = GlobalSettings.get_default().get_adversary( block_weight.block_id) return netEncapsulation(send_to, (block_weight.block_id, block_weight.content))
def receive_blocks(self, package: IPack): if isinstance(package, QuantizedPack): self.__global_weights -= package.decode(DC_QSGDClient.codex) self.__weights_states[package.node_id] = self.__global_weights elif isinstance(package, SignalPack): # returns Q(w_t+\tau - w_t) if not isinstance(self.__global_weights, np.ndarray): reply = SignalPack(Parameter_Server) else: reply = QuantizedPack( Parameter_Server, self.__global_weights - self.__weights_states.get(package.node_id, 0), DC_QSGDServer.codex) return netEncapsulation(package.node_id, reply)
def receive_blocks( self, content: Tuple[int, ndarray] ) -> Union[Iterable[netEncapsulation], netEncapsulation, None]: """ PA Server receive a json_dict and send back a request :param content: :return: """ # update global current state self.Bak_Weights_Node[content[0]] = content[1] if len(self.Bak_Weights_Node) == GlobalSettings.get_default( ).node_count: global_weight = np.mean(list(self.Bak_Weights_Node.values()), axis=0) self.dispose() return netEncapsulation(GlobalSettings.get_default().nodes, (Parameter_Server, global_weight))
def receive_blocks( self, content: Tuple[int, ndarray] ) -> Union[Iterable[netEncapsulation], netEncapsulation, None]: """ PA Server receive a json_dict and send back a request :param content: :return: """ # get last state of working node last_state = self.Bak_Weights_Node.get(content[0], 0) # update global current state self.Current_Weights = self.Current_Weights + content[1] # get difference grad_diff = self.Current_Weights - last_state # update last state of working node self.Bak_Weights_Node[content[0]] = self.Current_Weights return netEncapsulation(content[0], (-1, grad_diff))
def update_blocks( self, block_weight: BlockWeight ) -> netEncapsulation[Dict[str, np.ndarray]]: print('Weights delta received.') print('from block: {}'.format(block_weight.block_id)) print('It has a content with shape: {}'.format( block_weight.content.shape)) # 获取没有该数据的节点 send_to = GlobalSettings.get_default().get_adversary( block_weight.block_id) # 我们使用 'data' 字符串来标记我们的梯度内容 pkg = {'data': block_weight.content} # 记录本机梯度 self.__global_weights += block_weight.content self.__current_recv += 1 # 检查是否接受完所有数据 self.__do_grad_average() # 发送梯度 return netEncapsulation(send_to, pkg)
def receive_blocks( self, content: Tuple[int, np.ndarray] ) -> Union[Iterable[netEncapsulation], netEncapsulation]: """ Adaptive DC-ASGD algorithm. """ content_square = np.multiply(content[1], content[1]) # Update weights with delay-compensation delay = np.multiply( content_square, self.Weights_init - self.Bak_Weights_Node[content[0]]) self.Weights_init = self.Weights_init - self.Learn_Rate * ( content[1] + self.Lambda_T * delay) self.Mean_Square = self.Mean_Square_M * self.Mean_Square + ( 1 - self.Mean_Square_M) * content_square self.Lambda_T = self.Lambda_T / np.sqrt(self.Mean_Square + self.Mean_Square_Epsilon) # Send back updated weights self.Bak_Weights_Node[content[0]] = self.Weights_init return netEncapsulation(content[0], (-1, self.Weights_init))
def receive_blocks(self, content: dict): pkg = TQNPackage.decode(content) self.__global_weights -= pkg.content() return netEncapsulation( pkg.node_id, TQNPackage(self.__global_weights, Parameter_Server).encode())
def receive_blocks(self, package: IPack): self.__global_weights -= package.content reply = NormalPack(Parameter_Server, self.__global_weights) return netEncapsulation(package.node_id, reply)
def receive_blocks(self, package: IPack): self.__global_weights -= package.decode(QuantizedClient.codex) reply = QuantizedPack(Parameter_Server, self.__global_weights, QuantizedParaServer.codex) return netEncapsulation(package.node_id, reply)
def update_blocks( self, block_weight: BlockWeight ) -> Union[Iterable[netEncapsulation], netEncapsulation, None]: return netEncapsulation(Parameter_Server, (self.node_id, block_weight.content))
def receive_blocks(self, package: IPack): self.__global_weights -= package.content reply = QuantizedPack(Parameter_Server, *binarize(self.__global_weights)) return netEncapsulation(package.node_id, reply)
def update_blocks(self, block_weight: BlockWeight): return netEncapsulation( Parameter_Server, TQNPackage(block_weight.content, self.node_id).encode())
def update_blocks(self, block_weight: BlockWeight) -> netEncapsulation[IPack]: self.__gw_t = block_weight.content return netEncapsulation(Parameter_Server, SignalPack(self.node_id))