def predict(self, data: List[List[str]], max_seq_len: int = 128, split_char: str = '\002', batch_size: int = 1, use_gpu: bool = False): """ Predicts the data labels. Args: data (obj:`List(List(str))`): The processed data whose each element is the list of a single text or a pair of texts. max_seq_len (:obj:`int`, `optional`, defaults to :int:`None`): If set to a number, will limit the total sequence returned so that it has a maximum length. split_char(obj:`str`, defaults to '\002'): The char used to split input tokens in token-cls task. batch_size(obj:`int`, defaults to 1): The number of batch. use_gpu(obj:`bool`, defaults to `False`): Whether to use gpu to run or not. Returns: results(obj:`list`): All the predictions labels. """ if self.task not in self._tasks_supported \ and self.task is not None: # None for getting embedding raise RuntimeError( f'Unknown task {self.task}, current tasks supported:\n' '1. seq-cls: sequence classification;\n' '2. token-cls: sequence labeling;\n' '3. None: embedding') paddle.set_device('gpu') if use_gpu else paddle.set_device('cpu') batches = self._batchify(data, max_seq_len, batch_size, split_char) results = [] self.eval() for batch in batches: input_ids, segment_ids = batch input_ids = paddle.to_tensor(input_ids) segment_ids = paddle.to_tensor(segment_ids) if self.task == 'seq-cls': probs = self(input_ids, segment_ids) idx = paddle.argmax(probs, axis=1).numpy() idx = idx.tolist() labels = [self.label_map[i] for i in idx] results.extend(labels) elif self.task == 'token-cls': probs = self(input_ids, segment_ids) batch_ids = paddle.argmax( probs, axis=2).numpy() # (batch_size, max_seq_len) batch_ids = batch_ids.tolist() token_labels = [[self.label_map[i] for i in token_ids] for token_ids in batch_ids] results.extend(token_labels) elif self.task == None: sequence_output, pooled_output = self(input_ids, segment_ids) results.append([ pooled_output.squeeze(0).numpy().tolist(), sequence_output.squeeze(0).numpy().tolist() ]) return results
def train(): global e_greed, update_num total_reward = 0 # 重置游戏状态 obs = env.reset() obs = preprocess(obs) while True: # 使用贪心策略获取游戏动作的来源 e_greed = max(0.01, e_greed - e_greed_decrement) if np.random.rand() < e_greed: # 随机生成动作 action = env.action_space() else: # 策略模型预测游戏动作 obs1 = np.expand_dims(obs, axis=0) action = policyQ(paddle.to_tensor(obs1, dtype='float32')) action = paddle.argmax(action).numpy()[0] # 执行游戏 next_obs, reward, done, info = env.step(action) next_obs = preprocess(next_obs) total_reward += reward # 记录游戏数据 rpm.append((obs, action, reward, next_obs, done)) obs = next_obs # 游戏结束 if done: break # 记录的数据打印batch_size就开始训练 if len(rpm) > batch_size: # 获取训练数据 batch_obs, batch_action, batch_reword, batch_next_obs, batch_done = rpm.sample(batch_size) # 计算损失函数 action_value = policyQ(batch_obs) action_onehot = paddle.nn.functional.one_hot(batch_action, action_dim) pred_action_value = paddle.sum(action_value * action_onehot, axis=1) batch_argmax_action = paddle.argmax(policyQ(batch_next_obs), axis=1) v = targetQ(batch_next_obs) select_v = [] for i in range(v.shape[0]): select_v.append(v[i][int(batch_argmax_action[i].numpy()[0])]) select_v = paddle.stack(select_v).squeeze() select_v.stop_gradient = True target = batch_reword + gamma * select_v * (1.0 - batch_done) cost = paddle.nn.functional.mse_loss(pred_action_value, target) # 梯度更新 cost.backward() optimizer.step() optimizer.clear_grad() # 指定的训练次数更新一次目标模型的参数 if update_num % 200 == 0: targetQ.load_dict(policyQ.state_dict()) update_num += 1 return total_reward
def decode(s_arc, s_rel, mask, tree=True): """Decode function""" mask = mask.numpy() lens = np.sum(mask, -1) # Prevent self-loops arc_preds = paddle.argmax(s_arc, axis=-1).numpy() bad = [not istree(seq[:i + 1]) for i, seq in zip(lens, arc_preds)] if tree and any(bad): arc_preds[bad] = eisner(s_arc.numpy()[bad], mask[bad]) arc_preds = paddle.to_tensor(arc_preds) rel_preds = paddle.argmax(s_rel, axis=-1) rel_preds = index_sample(rel_preds, paddle.unsqueeze(arc_preds, axis=-1)) rel_preds = paddle.squeeze(rel_preds, axis=-1) return arc_preds, rel_preds
def Slide_Infer(model, infer_data, params_path=None, save_img_path=None, threshold=0.5, name='result'): # 信息修改与读取 infer_data.out_mode = 'slide' # 滑框模式 raw_size = infer_data.raw_size # 原图大小 is_tif = infer_data.is_tif if infer_data.is_tif == True: geoinfo = infer_data.geoinfo # 数据读取器 # infer_loader = paddle.io.DataLoader(infer_data, batch_size=1) infer_loader = DataLoader(infer_data, batch_size=1) # 开始预测 if save_img_path is not None: if os.path.exists(save_img_path) == False: os.mkdir(save_img_path) model.eval() para_state_dict = paddle.load(params_path) model.set_dict(para_state_dict) # lens = len(infer_data) inf_imgs = [] # 保存块 # for idx, infer_load_data in qenumerate(infer_loader): for infer_load_data in tqdm(infer_loader): if infer_load_data is None: break img = infer_load_data pred_list = model(img) # img = paddle.concat([A_img, B_img], axis=1) # pred_list = model(img) num_class, H, W = pred_list[0].shape[1:] if num_class == 2: inf_imgs.append((paddle.argmax(pred_list[0], axis=1). \ squeeze().numpy() * 255).astype('uint8')) elif num_class == 1: inf_imgs.append(((pred_list[0] > threshold).numpy(). \ astype('uint8') * 255).reshape([H, W])) else: inf_imgs.append((paddle.argmax(pred_list[0], axis=1). \ squeeze().numpy()).astype('uint8')) # print('[Infer] ' + str(idx + 1) + '/' + str(lens)) fix_img = splicing_list(inf_imgs, raw_size) # 拼接 if is_tif == True: save_path = os.path.join(save_img_path, (name + '.tif')) save_tif(fix_img, geoinfo, save_path) else: save_path = os.path.join(save_img_path, (name + '.png')) cv2.imwrite(save_path, fix_img)
def test_basic(self): with fluid.program_guard(fluid.Program()): data = fluid.data(name="X", shape=[3, 4], dtype="float32") out = paddle.argmax(input=data) place = fluid.CPUPlace() exe = fluid.Executor(place) np_input = np.random.rand(3, 4).astype("float32") expected_result = np.argmax(np_input, axis=1) result, = exe.run(feed={"X": np_input}, fetch_list=[out]) self.assertEqual((result == expected_result).all(), True) with fluid.program_guard(fluid.Program()): data = fluid.data(name="X", shape=[3, 4], dtype="float32") out = paddle.argmax(input=data, axis=0) place = fluid.CPUPlace() exe = fluid.Executor(place) np_input = np.random.rand(3, 4).astype("float32") expected_result = np.argmax(np_input, axis=0) result = exe.run(feed={"X": np_input}, fetch_list=[out]) self.assertEqual((result == expected_result).all(), True) with fluid.program_guard(fluid.Program()): data = fluid.data(name="X", shape=[3, 4], dtype="float32") out = paddle.argmax(input=data, dtype="int32") place = fluid.CPUPlace() exe = fluid.Executor(place) np_input = np.random.rand(3, 4).astype("float32") expected_result = np.argmax(np_input, axis=1).astype(np.int32) result = exe.run(feed={"X": np_input}, fetch_list=[out]) self.assertEqual((result == expected_result).all(), True) with fluid.program_guard(fluid.Program()): data1 = fluid.data(name="X", shape=[3, 4], dtype="float32") data2 = fluid.data(name="Y", shape=[3], dtype="int64") out = paddle.argmax(input=data, out=data2) place = fluid.CPUPlace() exe = fluid.Executor(place) result = exe.run( feed={"X": np.random.rand(3, 4).astype("float32")}, fetch_list=[data2, out]) self.assertEqual((result[0] == result[1]).all(), True)
def main(): # 初始化游戏 env = flappyBird.GameState() # 图像输入形状和动作维度 obs_dim = resize_shape[0] action_dim = env.action_dim # 创建模型 model = Model(obs_dim, action_dim) model.load_dict(paddle.load(save_model_path)) model.eval() # 开始游戏 obs = env.reset() episode_reward = 0 done = False # 游戏未结束执行一直执行游戏 while not done: obs = preprocess(obs) obs = np.expand_dims(obs, axis=0) obs = paddle.to_tensor(obs, dtype='float32') action = model(obs) action = paddle.argmax(action).numpy()[0] obs, reward, done, info = env.step(action, is_train=False) episode_reward += reward print("最终得分为:{:.2f}".format(episode_reward))
def inference(model_file, word2id_dict, text_list: list): """前向推理""" vocab_size = len(word2id_dict) embedding_size = 256 max_seq_len = 128 sentiment_classifier = SentimentClassifier(embedding_size, vocab_size, num_steps=max_seq_len, num_layers=1) params_dict = paddle.load(model_file) # sentiment_classifier.set_state_dict(params_dict) sentiment_classifier.load_dict(params_dict) sentiment_classifier.eval() inputs = [] for char in text_list: if char: inputs.append(word2id_dict[char] if char in word2id_dict else word2id_dict['[oov]']) if len(inputs) > max_seq_len: inputs = inputs[:max_seq_len] if len(inputs) < max_seq_len: for _ in range(max_seq_len - len(inputs)): inputs.append(word2id_dict['[pad]']) # 数据补齐 inputs = paddle.to_tensor([inputs]) pred = sentiment_classifier(inputs) labels = paddle.argmax(pred, axis=-1) return labels.numpy()
def _forward(self): feats = self.backbone(self.inputs) hrnet_outputs = self.final_conv(feats[0]) if self.training: return self.loss(hrnet_outputs, self.inputs) elif self.deploy: outshape = hrnet_outputs.shape max_idx = paddle.argmax(hrnet_outputs.reshape( (outshape[0], outshape[1], outshape[2] * outshape[3])), axis=-1) return hrnet_outputs, max_idx else: if self.flip: self.inputs['image'] = self.inputs['image'].flip([3]) feats = self.backbone(self.inputs) output_flipped = self.final_conv(feats[0]) output_flipped = self.flip_back(output_flipped.numpy(), self.flip_perm) output_flipped = paddle.to_tensor(output_flipped.copy()) if self.shift_heatmap: output_flipped[:, :, :, 1:] = output_flipped.clone()[:, :, :, 0:-1] hrnet_outputs = (hrnet_outputs + output_flipped) * 0.5 imshape = (self.inputs['im_shape'].numpy() )[:, ::-1] if 'im_shape' in self.inputs else None center = self.inputs['center'].numpy( ) if 'center' in self.inputs else np.round(imshape / 2.) scale = self.inputs['scale'].numpy( ) if 'scale' in self.inputs else imshape / 200. outputs = self.post_process(hrnet_outputs, center, scale) return outputs
def compute(self, pred, label, ignore_index): pred = paddle.argmax(pred, 1) active_acc = label.reshape([-1]) != ignore_index active_pred = pred.masked_select(active_acc) active_labels = label.masked_select(active_acc) correct = active_pred.equal(active_labels) return correct
def forward(self, ipt): # 卷积 + ReLU + BN x = self.conv1(ipt) x = paddle.nn.functional.relu(x) x = self.bn1(x) # 卷积 + ReLU + BN x = self.conv2(x) x = paddle.nn.functional.relu(x) x = self.bn2(x) # 卷积 + ReLU x = self.conv3(x) x = paddle.nn.functional.relu(x) # 将3维特征转换为2维特征 - 此处可以使用reshape代替 x = paddle.tensor.flatten(x, 2) # 全连接 + ReLU x = self.linear(x) x = paddle.nn.functional.relu(x) # 双向LSTM - [0]代表取双向结果,[1][0]代表forward结果,[1][1]代表backward结果,详细说明可在官方文档中搜索'LSTM' x = self.lstm(x)[0] # 输出层 - Shape = (Batch Size, Max label len, Signal) x = self.linear2(x) # 在计算损失时ctc-loss会自动进行softmax,所以在预测模式中需额外做softmax获取标签概率 if self.is_infer: # 输出层 - Shape = (Batch Size, Max label len, Prob) x = paddle.nn.functional.softmax(x) # 转换为标签 x = paddle.argmax(x, axis=-1) return x
def update(self, logits, labels): """ Update the states based on the current mini-batch prediction results. Args: logits (Tensor): The predicted value is a Tensor with shape [batch_size, seq_len, num_classes] and type float32 or float64. labels (Tensor): The ground truth value is a 2D Tensor, its shape is [batch_size, seq_len] and type is int64. """ probs = paddle.argmax(logits, axis=-1) probs = probs.numpy() labels = labels.numpy() assert probs.shape[0] == labels.shape[0] assert probs.shape[1] == labels.shape[1] for i in range(probs.shape[0]): start, end = 1, probs.shape[1] while end > start: if labels[i][end - 1] != 0: break end -= 1 prob, label = probs[i][start:end], labels[i][start:end] for y_pred, y in zip(prob, label): if y_pred == y: self.tp[y] = self.tp.get(y, 0) + 1 else: self.fp[y_pred] = self.fp.get(y_pred, 0) + 1 self.fn[y] = self.fn.get(y, 0) + 1
def forward_test(self, src): bs = paddle.shape(src)[0] if self.encoder is not None: src = self.positional_encoding(paddle.transpose(src, [1, 0, 2])) memory = self.encoder(src) else: memory = paddle.transpose(paddle.squeeze(src, 2), [2, 0, 1]) dec_seq = paddle.full((bs, 1), 2, dtype=paddle.int64) dec_prob = paddle.full((bs, 1), 1., dtype=paddle.float32) for len_dec_seq in range(1, 25): dec_seq_embed = paddle.transpose(self.embedding(dec_seq), [1, 0, 2]) dec_seq_embed = self.positional_encoding(dec_seq_embed) tgt_mask = self.generate_square_subsequent_mask( paddle.shape(dec_seq_embed)[0]) output = self.decoder(dec_seq_embed, memory, tgt_mask=tgt_mask, memory_mask=None, tgt_key_padding_mask=None, memory_key_padding_mask=None) dec_output = paddle.transpose(output, [1, 0, 2]) dec_output = dec_output[:, -1, :] word_prob = F.softmax(self.tgt_word_prj(dec_output), axis=1) preds_idx = paddle.argmax(word_prob, axis=1) if paddle.equal_all( preds_idx, paddle.full(paddle.shape(preds_idx), 3, dtype='int64')): break preds_prob = paddle.max(word_prob, axis=1) dec_seq = paddle.concat( [dec_seq, paddle.reshape(preds_idx, [-1, 1])], axis=1) dec_prob = paddle.concat( [dec_prob, paddle.reshape(preds_prob, [-1, 1])], axis=1) return [dec_seq, dec_prob]
def compute(self, pred, label, *args): """ Compute the top-k (maxinum value in `topk`) indices. Args: pred (Tensor): The predicted value is a Tensor with dtype float32 or float64. Shape is [batch_size, d0, ..., dN]. label (Tensor): The ground truth value is Tensor with dtype int64. Shape is [batch_size, d0, ..., 1], or [batch_size, d0, ..., num_classes] in one hot representation. Return: Tensor: Correct mask, a tensor with shape [batch_size, topk]. """ pred = paddle.argsort(pred, descending=True) pred = paddle.slice(pred, axes=[len(pred.shape) - 1], starts=[0], ends=[self.maxk]) if (len(label.shape) == 1) or \ (len(label.shape) == 2 and label.shape[-1] == 1): # In static mode, the real label data shape may be different # from shape defined by paddle.static.InputSpec in model # building, reshape to the right shape. label = paddle.reshape(label, (-1, 1)) elif label.shape[-1] != 1: # one-hot label label = paddle.argmax(label, axis=-1, keepdim=True) correct = pred == label return paddle.cast(correct, dtype='float32')
def pbtPredict_Callback(self): __img, img_array = [], [ ] # 将图像统一从qimage->pil image -> np.array [1, 1, 28, 28] # 获取qimage格式图像 if self.mode == MODE_MNIST: __img = self.lbDataArea.pixmap() # label内若无图像返回None if __img == None: # 无图像则用纯黑代替 # __img = QImage(224, 224, QImage.Format_Grayscale8) __img = ImageQt.ImageQt( Image.fromarray(np.uint8(np.zeros([224, 224])))) else: __img = __img.toImage() elif self.mode == MODE_WRITE: __img = self.paintBoard.getContentAsQImage() # 转换成pil image类型处理 pil_img = ImageQt.fromqimage(__img) pil_img = pil_img.resize((28, 28), Image.ANTIALIAS) img_array = np.array(pil_img.convert('L')).reshape(1, 1, 28, 28) img = normalize(img_array) img = paddle.Tensor(img) __result = network(img) argmax__result = paddle.argmax(__result).numpy() self.result[0] = argmax__result[0] # 置信度 m = F.sigmoid(__result).numpy() self.result[1] = m[0][self.result[0]] self.lbResult.setText("%d" % (self.result[0])) self.lbCofidence.setText("%.8f" % (self.result[1]))
def farthest_point_sample(xyz, npoint): """ Input: xyz: pointcloud data, [B, N, 3] npoint: number of samples Return: centroids: sampled pointcloud index, [B, npoint] """ B, N, C = xyz.shape centroids = paddle.zeros([B, npoint]) distance = paddle.ones([B, N]) farthest = paddle.randint(0, N, (B,)) batch_indices = paddle.arange(B) for i in range(npoint): centroids[:, i] = farthest xyz_np = xyz.numpy() batch_indices_np = batch_indices.numpy().astype('int64') farthest_np = farthest.numpy().astype('int64') centroid = xyz_np[batch_indices_np, farthest_np, :] centroid = paddle.to_tensor(centroid).unsqueeze(1) dist = paddle.sum((xyz - centroid) ** 2, -1) mask = dist < distance distance_np = distance.numpy() dist_np = dist.numpy() mask_np = mask.numpy() distance_np[mask_np] = dist_np[mask_np] distance = paddle.to_tensor(distance_np) farthest = paddle.argmax(distance, -1) return centroids
def paddle_argmax(name: str, x, axis): import paddle paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype='float32') out = paddle.argmax(x=node_x, axis=axis) out = paddle.cast(out, np.float32) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) # startup program will call initializer to initialize the parameters. exe.run(paddle.static.default_startup_program()) outs = exe.run(feed={'x': x}, fetch_list=[out]) saveModel(name, exe, feedkeys=['x'], fetchlist=[out], inputs=[x], outputs=[outs[0]], target_dir=sys.argv[1]) return outs[0]
def train(): global e_greed, update_num total_reward = 0 # 重置游戏状态 obs = env.reset() obs = preprocess(obs) while True: # 使用贪心策略获取游戏动作的来源 e_greed = max(0.01, e_greed - e_greed_decrement) if np.random.rand() < e_greed: # 随机生成动作 action = env.action_space() else: # 策略模型预测游戏动作 obs1 = np.expand_dims(obs, axis=0) action = policyQ(paddle.to_tensor(obs1, dtype='float32')) action = paddle.argmax(action).numpy()[0] # 执行游戏 next_obs, reward, done, info = env.step(action) next_obs = preprocess(next_obs) n_step_buffer.append((obs, action, reward, next_obs, done)) if len(n_step_buffer) > n_step: n_step_reward = sum([n_step_buffer[i][2]*(gamma**i) for i in range(n_step)]) total_reward += n_step_reward n_step_obs, n_step_action, _, n_step_next_obs, n_step_done = n_step_buffer.pop(0) rpm.append((n_step_obs, n_step_action, n_step_reward, n_step_next_obs, n_step_done)) obs = next_obs # 游戏结束 if done: while len(n_step_buffer) > 0: n_step_reward = sum([n_step_buffer[i][2] * (gamma ** i) for i in range(len(n_step_buffer))]) n_step_obs, n_step_action, _, n_step_next_obs, n_step_done = n_step_buffer.pop(0) rpm.append((n_step_obs, n_step_action, n_step_reward, n_step_next_obs, n_step_done)) break # 记录的数据打印batch_size就开始训练 if len(rpm) > batch_size: # 获取训练数据 batch_obs, batch_action, batch_reword, batch_next_obs, batch_done = rpm.sample(batch_size) # 计算损失函数 action_value = policyQ(batch_obs) action_onehot = paddle.nn.functional.one_hot(batch_action, action_dim) pred_action_value = paddle.sum(action_value * action_onehot, axis=1) best_v = targetQ(batch_next_obs) best_v = paddle.max(best_v, axis=1) best_v.stop_gradient = True target = batch_reword + gamma ** n_step * best_v * (1.0 - batch_done) cost = paddle.nn.functional.mse_loss(pred_action_value, target) # 梯度更新 cost.backward() optimizer.step() optimizer.clear_grad() # 指定的训练次数更新一次目标模型的参数 if update_num % 200 == 0: targetQ.load_dict(policyQ.state_dict()) update_num += 1 return total_reward
def main(): # 初始化游戏 env = DinoGame() # 图像输入形状和动作维度 obs_dim = env.observation_space.shape[0] action_dim = env.action_space.n # 创建模型 model = Model(obs_dim, action_dim) model.load_dict(paddle.load(save_model_path)) model.eval() # 开始游戏 obs = env.reset() episode_reward = 0 done = False last_time = time.time() # 游戏未结束执行一直执行游戏 while not done: obs = np.expand_dims(obs, axis=0) obs = paddle.to_tensor(obs, dtype='float32') action = model(obs) action = paddle.argmax(action).numpy()[0] obs, reward, done, info = env.step(action) episode_reward += reward # 防止截图太快 # fps_now = 1 / (time.time() - last_time) # if fps_now > FPS: # time.sleep(1 / FPS - 1 / fps_now) # last_time = time.time() print("最终得分为:{:.2f}".format(episode_reward))
def forward(self, inputs): x = self.bn1(inputs) x = paddle.reshape(x, [1, 3 * 16 * 16]) x = self.fc1(x) x = paddle.fluid.layers.unsqueeze(input=x, axes=[2]) x = self.relu1(x) y = paddle.fluid.layers.fill_constant(x.shape, dtype=paddle.float32, value=1) # x = paddle.stack([x, y], axis=3) x = paddle.slice(x, axes=[0], starts=[0], ends=[1]) x = paddle.exp(x) # y += paddle.fluid.layers.uniform_random(y.shape) y = paddle.expand(y, shape=[1, 768, 768, 2]) x = paddle.expand(x, shape=[1, 768, 768, 2]) out = paddle.concat([x, y]) out = self.dp(out) out = channel_shuffle(out, 2) out1, out2 = paddle.split(out, num_or_sections=2, axis=1) outshape = out1.shape max_idx = paddle.argmax(out1.reshape( (outshape[0], outshape[1], outshape[2] * outshape[3])), axis=-1) out2 = out2.reshape( (outshape[0], outshape[1], outshape[2] * outshape[3])) res, _ = self.lstm(out2) return res, max_idx
def forward(self, input_ids, end_id): output, cached_kvs = self.model(input_ids, use_cache=True, cache=None) src_ids = input_ids nid = paddle.argmax(output[:, -1, :], axis=-1).reshape([-1, 1]) src_ids = paddle.concat([src_ids, nid], axis=1) cur_len = 0 while (cur_len < self.max_predict_len): output, cached_kvs = self.model( nid, use_cache=True, cache=cached_kvs) nid = paddle.argmax(output[:, -1, :], axis=-1).reshape([-1, 1]) src_ids = paddle.concat([src_ids, nid], axis=1) cur_len += 1 if paddle.max(nid) == end_id: break return src_ids
def soft_nms(box_scores, score_threshold, sigma=0.5, top_k=-1): """Soft NMS implementation. References: https://arxiv.org/abs/1704.04503 https://github.com/facebookresearch/Detectron/blob/master/detectron/utils/cython_nms.pyx Args: box_scores (N, 5): boxes in corner-form and probabilities. score_threshold: boxes with scores less than value are not considered. sigma: the parameter in score re-computation. scores[i] = scores[i] * exp(-(iou_i)^2 / simga) top_k: keep top_k results. If k <= 0, keep all the results. Returns: picked_box_scores (K, 5): results of NMS. """ picked_box_scores = [] while box_scores.size(0) > 0: max_score_index = paddle.argmax(box_scores[:, 4]) cur_box_prob = paddle.to_tensor(box_scores[max_score_index, :]) picked_box_scores.append(cur_box_prob) if len(picked_box_scores) == top_k > 0 or box_scores.size(0) == 1: break cur_box = cur_box_prob[:-1] box_scores[max_score_index, :] = box_scores[-1, :] box_scores = box_scores[:-1, :] ious = iou_of(cur_box.unsqueeze(0), box_scores[:, :-1]) box_scores[:, -1] = box_scores[:, -1] * paddle.exp(-(ious * ious) / sigma) box_scores = box_scores[box_scores[:, -1] > score_threshold, :] if len(picked_box_scores) > 0: return paddle.stack(picked_box_scores) else: return paddle.to_tensor([])
def predict_fn(data, label): """predict_fn for input gradients based interpreters, for image classification models only. Args: data ([type]): [description] label ([type]): can be None. Returns: [type]: [description] """ import paddle assert len(data.shape) == 4 # [bs, h, w, 3] with paddle.no_grad(): logits = self.paddle_model(paddle.to_tensor(data)) # get logits, [bs, num_c] probas = paddle.nn.functional.softmax(logits, axis=1) # get probabilities. pred = paddle.argmax(probas, axis=1) # get predictions. if label is None: label = pred.numpy() # label is an integer. if output == 'logit': return logits.numpy(), label else: return probas.numpy(), label
def evaluate(model, metric, data_loader, do_pred=False): model.eval() if not do_pred: metric.reset() for batch in data_loader: input_ids, segment_ids, labels = batch logits = model(input_ids, segment_ids) correct = metric.compute(logits, labels) metric.update(correct) accu = metric.accumulate() print("accu: %f" % (accu)) else: res = {} for batch in data_loader: input_ids, segment_ids, qas_id = batch logits = model(input_ids, segment_ids) qas_id = qas_id.numpy() preds = paddle.argmax(logits, axis=1).numpy() for i in range(len(preds)): res[str( qas_id[i])] = data_loader.dataset.get_labels()[preds[i]] with open('prediction.json', "w") as writer: writer.write(json.dumps(res, ensure_ascii=False, indent=4) + "\n") model.train()
def ctc_greedy_decoder(probs_seq, vocabulary, blank=0): """CTC贪婪(最佳路径)解码器。 由最可能的令牌组成的路径被进一步后处理 删除连续的重复和所有的空白。 :param probs_seq: 每个词汇表上概率的二维列表字符。 每个元素都是浮点概率列表为一个字符。 :type probs_seq: list :param vocabulary: 词汇表 :type vocabulary: list :param blank: 空白索引 :type blank: int :return: 解码结果字符串 :rtype: baseline """ # 尺寸验证 for probs in probs_seq: if not len(probs) == len(vocabulary): raise ValueError("probs_seq 尺寸与词汇不匹配") # argmax以获得每个时间步长的最佳指标 max_index_list = paddle.argmax(probs_seq, -1).numpy() # 删除连续的重复索引 index_list = [index_group[0] for index_group in groupby(max_index_list)] # 删除空白索引 index_list = [index for index in index_list if index != blank] # 将索引列表转换为字符串 return ''.join([vocabulary[index] for index in index_list])
def aug_inference(model, im, ori_shape, transforms, scales=1.0, flip_horizontal=False, flip_vertical=False, is_slide=False, stride=None, crop_size=None): """ Infer with augmentation. Args: model (paddle.nn.Layer): model to get logits of image. im (Tensor): the input image. ori_shape (list): Origin shape of image. transforms (list): Transforms for image. scales (float|tuple|list): Scales for resize. Default: 1. flip_horizontal (bool): Whether to flip horizontally. Default: False. flip_vertical (bool): Whether to flip vertically. Default: False. is_slide (bool): Whether to infer by sliding wimdow. Default: False. crop_size (tuple|list). The size of sliding window, (w, h). It should be probided if is_slide is True. stride (tuple|list). The size of stride, (w, h). It should be probided if is_slide is True. Returns: Tensor: Prediction of image with shape (1, 1, h, w) is returned. """ if isinstance(scales, float): scales = [scales] elif not isinstance(scales, (tuple, list)): raise TypeError( '`scales` expects float/tuple/list type, but received {}'.format( type(scales))) final_logit = 0 h_input, w_input = im.shape[-2], im.shape[-1] flip_comb = flip_combination(flip_horizontal, flip_vertical) for scale in scales: h = int(h_input * scale + 0.5) w = int(w_input * scale + 0.5) im = F.interpolate(im, (h, w), mode='bilinear') for flip in flip_comb: im_flip = tensor_flip(im, flip) logit = inference(model, im_flip, is_slide=is_slide, crop_size=crop_size, stride=stride) logit = tensor_flip(logit, flip) logit = F.interpolate(logit, (h_input, w_input), mode='bilinear') logit = F.softmax(logit, axis=1) final_logit = final_logit + logit pred = reverse_transform(final_logit, ori_shape, transforms, mode='bilinear') pred = paddle.argmax(pred, axis=1, keepdim=True, dtype='int32') return pred
def predict(model, data, tokenizer, label_map, batch_size=1): """ Predicts the data labels. Args: model (obj:`paddle.nn.Layer`): A model to classify texts. data (obj:`List(Example)`): The processed data whose each element is a Example (numedtuple) object. A Example object contains `text`(word_ids) and `se_len`(sequence length). tokenizer(obj:`PretrainedTokenizer`): This tokenizer inherits from :class:`~paddlenlp.transformers.PretrainedTokenizer` which contains most of the methods. Users should refer to the superclass for more information regarding methods. label_map(obj:`dict`): The label id (key) to label str (value) map. batch_size(obj:`int`, defaults to 1): The number of batch. Returns: results(obj:`dict`): All the predictions labels. """ examples = [] for text_pair in data: query_input_ids, query_segment_ids, title_input_ids, title_segment_ids = convert_example( text_pair, tokenizer, label_list=label_map.values(), max_seq_length=args.max_seq_length, is_test=True) examples.append((query_input_ids, query_segment_ids, title_input_ids, title_segment_ids)) # Seperates data into some batches. batches = [ examples[idx:idx + batch_size] for idx in range(0, len(examples), batch_size) ] batchify_fn = lambda samples, fn=Tuple( Pad(axis=0, pad_val=tokenizer.pad_token_id), # query_input Pad(axis=0, pad_val=tokenizer.pad_token_type_id), # query_segment Pad(axis=0, pad_val=tokenizer.pad_token_id), # title_input Pad(axis=0, pad_val=tokenizer.pad_token_type_id), # tilte_segment ): [data for data in fn(samples)] results = [] model.eval() for batch in batches: query_input_ids, query_segment_ids, title_input_ids, title_segment_ids = batchify_fn( batch) query_input_ids = paddle.to_tensor(query_input_ids) query_segment_ids = paddle.to_tensor(query_segment_ids) title_input_ids = paddle.to_tensor(title_input_ids) title_segment_ids = paddle.to_tensor(title_segment_ids) probs = model(query_input_ids, title_input_ids, query_token_type_ids=query_segment_ids, title_token_type_ids=title_segment_ids) idx = paddle.argmax(probs, axis=1).numpy() idx = idx.tolist() labels = [label_map[i] for i in idx] results.extend(labels) return results
def forward(self, text, text_pair=None): _, pooled_output = self.ernie(text, text_pair) pooled_output = self.dropout(pooled_output) logits = self.classifier(pooled_output) predictions = paddle.argmax(logits, axis=-1) return logits, predictions
def forward(self, text, text_pair=None): sequence_output, _ = self.ernie(text, text_pair) sequence_output = self.dropout(sequence_output) logits = self.classifier(sequence_output) predictions = paddle.argmax(logits, axis=-1) return logits, predictions
def do_predict(): paddle.set_device(args.device) tokenizer = ErnieTokenizer.from_pretrained("ernie-1.0") label_map = load_dict(args.tag_path) id2label = {val: key for key, val in label_map.items()} model = ErnieForTokenClassification.from_pretrained("ernie-1.0", num_classes=len(label_map)) no_entity_label = "O" ignore_label = len(label_map) print("============start predict==========") if not args.init_ckpt or not os.path.isfile(args.init_ckpt): raise Exception("init checkpoints {} not exist".format(args.init_ckpt)) else: state_dict = paddle.load(args.init_ckpt) model.set_dict(state_dict) print("Loaded parameters from %s" % args.init_ckpt) # load data from predict file sentences = read_by_lines(args.predict_data) # origin data format sentences = [json.loads(sent) for sent in sentences] encoded_inputs_list = [] for sent in sentences: sent = sent["text"].replace(" ", "\002") input_ids, token_type_ids, seq_len = convert_example_to_feature([list(sent), []], tokenizer, max_seq_len=args.max_seq_len, is_test=True) encoded_inputs_list.append((input_ids, token_type_ids, seq_len)) batchify_fn = lambda samples, fn=Tuple( Pad(axis=0, pad_val=tokenizer.vocab[tokenizer.pad_token], dtype='int32'), # input_ids Pad(axis=0, pad_val=tokenizer.vocab[tokenizer.pad_token], dtype='int32'), # token_type_ids Stack(dtype='int64') # sequence lens ): fn(samples) # Seperates data into some batches. batch_encoded_inputs = [encoded_inputs_list[i: i + args.batch_size] for i in range(0, len(encoded_inputs_list), args.batch_size)] results = [] model.eval() for batch in batch_encoded_inputs: input_ids, token_type_ids, seq_lens = batchify_fn(batch) input_ids = paddle.to_tensor(input_ids) token_type_ids = paddle.to_tensor(token_type_ids) logits = model(input_ids, token_type_ids) probs = F.softmax(logits, axis=-1) probs_ids = paddle.argmax(probs, -1).numpy() probs = probs.numpy() for p_list, p_ids, seq_len in zip(probs.tolist(), probs_ids.tolist(), seq_lens.tolist()): prob_one = [p_list[index][pid] for index, pid in enumerate(p_ids[1: seq_len - 1])] label_one = [id2label[pid] for pid in p_ids[1: seq_len - 1]] results.append({"probs": prob_one, "labels": label_one}) assert len(results) == len(sentences) for sent, ret in zip(sentences, results): sent["pred"] = ret sentences = [json.dumps(sent, ensure_ascii=False) for sent in sentences] write_by_lines(args.predict_save_path, sentences) print("save data {} to {}".format(len(sentences), args.predict_save_path))
def train_iter(self, *inputs, **kwargs): current_iter = kwargs['current_iter'] total_iters = kwargs['total_iters'] if self.target_decay_method == 'cosine': self.m = 1 - (1 - self.base_m) * (1 + math.cos( math.pi * current_iter / total_iters)) / 2.0 # 47.0 elif self.target_decay_method == 'fixed': self.m = self.base_m # 55.7 else: raise NotImplementedError if self.prob_moving_type == 'fixed': self.pos_prob = self.max_use_other_prob elif self.prob_moving_type == 'linear': self.pos_prob = self.max_use_other_prob * current_iter / total_iters else: raise NotImplementedError use_other = self.sample() if paddle.distributed.get_world_size() > 1: paddle.distributed.broadcast(use_other, src=0) # self.update_target_network() img_a, img_b = inputs a1 = self.predictor(self.towers[0](img_a)) a1 = nn.functional.normalize(a1, axis=1) b1 = self.towers[1](img_b) b1 = nn.functional.normalize(b1, axis=1) b1.stop_gradient = True if bool(use_other): with paddle.no_grad(): similarities = paddle.matmul( b1, self.queue.clone().detach()).detach() indices = paddle.argmax(similarities, axis=1).detach() c = paddle.gather(self.queue.clone().detach(), indices, axis=1) c = paddle.transpose(c, perm=[1, 0]).detach() c.stop_gradient = True a2 = self.predictor(self.towers[0](img_b)) a2 = nn.functional.normalize(a2, axis=1) if not bool(use_other): b2 = self.towers[1](img_a) b2 = nn.functional.normalize(b2, axis=1) b2.stop_gradient = True if bool(use_other): outputs = self.head(a1, c, a2, c) else: outputs = self.head(a1, b1, a2, b2) with paddle.no_grad(): self._dequeue_and_enqueue(b1) return outputs