def negSamplingLossAndGradient(centerWordVec, outsideWordIdx, outsideVectors, dataset, K=10): negSampleWordIndices = getNegativeSamples(outsideWordIdx, dataset, K) indices = [outsideWordIdx] + negSampleWordIndices v_c = centerWordVec #(W,) o = outsideWordIdx U = outsideVectors #VxW u_o = U[o] u_k = U[negSampleWordIndices] loss = 0.0 gradCenterVec = np.zeros(v_c.shape) gradOutsideVecs = np.zeros(U.shape) z = sigmoid(np.dot(u_o, v_c)) z_k = sigmoid(-np.dot(u_k, v_c)) loss += -np.log(z) loss += -np.sum(np.log(z_k)) gradCenterVec += (z - 1) * u_o gradCenterVec -= np.dot((z_k - 1), u_k) gradOutsideVecs[o] += (z - 1) * v_c for i, ind in enumerate(negSampleWordIndices): gradOutsideVecs[ind] += (1 - z_k[i]) * v_c return loss, gradCenterVec, gradOutsideVecs
def forward(self, input, lamda, plasticity): input = input.expand(input.data.shape[0], 3, 28, 28) out1 = sigmoid(self.g_conv1_d, plasticity) * self.conv1(input) + \ sigmoid(self.g_conv1_t, plasticity) * self.conv1(input) feature = sigmoid(self.g_conv2_d, plasticity) * self.conv2(out1) + \ sigmoid(self.g_conv2_t, plasticity) * self.conv2(out1) feature = feature.view(-1, 48 * 4 * 4) class_prediction = self.feature_classifier(feature) reverse_feature = ReverseLayer.apply(feature, lamda) domain_prediction = self.domain_classifier(reverse_feature) return class_prediction, domain_prediction
def predict(loader, model): mask_dict = {} progress_bar = tqdm(iterable=enumerate(loader), total=len(loader), desc=f"Inference", ncols=0) with torch.set_grad_enabled(False): for i, data in progress_bar: images = data["img"].to(device) batch = tta(model, images) for img, probability in zip(data["image_name"], batch.cpu().detach().numpy()): for i, prop in enumerate(probability): mask_dict[img + str(i)] = sigmoid(prop).astype(np.float32) return mask_dict
def predict_proba(self,IVs,is_ad_hoc=False): # compute soft label IVs = self._convert_iv(IVs) # w = self.w # conditional_accuracy = self.conditional_accuracy n,p = IVs.shape if self.use_canonical: # use canonical parameters pos_posterior = np.zeros(n) neg_posterior = np.zeros(n) for clique in self.prob_dict: iv_index_in_clique = [x for x in range(len(clique)) if list(clique)[x]!= str(p)] iv_index_in_IVs = np.array(list(clique))[iv_index_in_clique].astype(int) assignment = np.zeros([n,len(clique)]).astype(int) assignment[:,iv_index_in_clique] = IVs[:,iv_index_in_IVs]+1 pos_assignment = np.copy(assignment) neg_assignment = np.copy(assignment) pos_assignment[:,list(clique).index(str(p))] = 2 neg_assignment[:,list(clique).index(str(p))] = 0 del assignment # find the index of the assignment pos_assignment_single_index = multi_index_to_index(pos_assignment) neg_assignment_single_index = multi_index_to_index(neg_assignment) # update positve posterior pos_posterior = pos_posterior + self.prob_dict[clique]["prob"][pos_assignment_single_index] # update negative posterior neg_posterior = neg_posterior + self.prob_dict[clique]["prob"][neg_assignment_single_index] Zprob = sigmoid(-(neg_posterior+np.log(self.class_balance_im[0]))+(pos_posterior+np.log(self.class_balance_im[1]))) else: raise NotImplementedError("set use_cannonical=True in training!") return Zprob
def sigmoid_forward(X): out = util.sigmoid(X) cache = out return out, cache
def im_detect(net, im): im = im.astype(np.float32, copy=False) im = cv2.resize(im, (int(cfg.IMAGE_WIDTH), int(cfg.IMAGE_HEIGHT))) im = im - cfg.PIXEL_MEANS im_ = np.transpose(im, (2, 0, 1)) im_ = im_[np.newaxis, ...] conv1_shadow = np.zeros((1, 64, 192, 624), dtype=np.float32) net_time = Timer() npy_time = Timer() # reshape network inputs net_time.tic() net.blobs['data'].reshape(*(im_.shape)) net.blobs['conv1_shadow'].reshape(*(conv1_shadow.shape)) # do forward forward_kwargs = {'data': im_.astype(np.float32, copy = False), \ 'conv1_shadow': conv1_shadow} blobs_outs = net.forward(**forward_kwargs) net_time.toc() npy_time.tic() pred_class_probs = blobs_outs['pred_class_probs'] pred_conf = blobs_outs['pred_conf'] pred_box_delta = blobs_outs['pred_box_delta'] # For pred class probs part pred_class_probs = np.transpose(pred_class_probs, (0, 2, 3, 1)) pred_class_probs = np.reshape(pred_class_probs, (cfg.NUM_ANCHORS, 3)) pred_class_sft_probs = softmax(pred_class_probs) pred_class_sft_probs = np.reshape(pred_class_sft_probs, (-1, cfg.NUM_ANCHORS, cfg.NUM_CLASSES)) # For pred conf part pred_conf = np.transpose(pred_conf, (0, 2, 3, 1)) pred_conf = np.reshape(pred_conf, (-1, cfg.NUM_ANCHORS)) pred_sgm_conf = sigmoid(pred_conf) # For pred box delta pred_box_delta = np.transpose(pred_box_delta, (0, 2, 3, 1)) pred_box_delta = np.reshape(pred_box_delta, (-1, cfg.NUM_ANCHORS, 4)) delta_x = pred_box_delta[:, :, 0] delta_y = pred_box_delta[:, :, 1] delta_w = pred_box_delta[:, :, 2] delta_h = pred_box_delta[:, :, 3] # Get anchors ANCHORS = set_anchors() anchor_x = ANCHORS[:, 0] anchor_y = ANCHORS[:, 1] anchor_w = ANCHORS[:, 2] anchor_h = ANCHORS[:, 3] box_center_x = anchor_x + delta_x * anchor_w box_center_y = anchor_y + delta_y * anchor_h box_width = anchor_w * np.exp(delta_w) box_height = anchor_h * np.exp(delta_h) # convert (centerx, centery, w, h) into (xmin, ymin, xmax, ymax) xmins, ymins, xmaxs, ymaxs = bbox_transform([box_center_x, box_center_y, \ box_width, box_height]) # clip bounding boxes xmins, ymins, xmaxs, ymaxs = clip_box([xmins, ymins, xmaxs, ymaxs]) # convert (xmin, ymin, xmax, ymax) into (centerx, centery, w, h) bbox = bbox_transform_inv([xmins, ymins, xmaxs, ymaxs]) det_bbox = np.array(bbox) det_bbox = np.transpose(det_bbox, (1, 2, 0)) # get probs det_probs = np.multiply(pred_class_sft_probs, \ np.reshape(pred_sgm_conf, (-1, cfg.NUM_ANCHORS, 1))) det_probs_max = np.max(np.reshape(det_probs, (-1, 3)), axis=1) det_probs_max = np.reshape(det_probs_max, (1, -1)) # get class det_class = np.argmax(det_probs, 2) # filter bounding boxes with nms final_boxes, final_probs, final_class = filter_prediction(det_bbox[0], \ det_probs_max[0], det_class[0]) # filter bounding boxes with probability threshold keep_idx = [idx for idx in range(len(final_probs))\ if final_probs[idx] > cfg.DRAW_THRESHOLD] final_boxes = [final_boxes[idx] for idx in keep_idx] final_probs = [final_probs[idx] for idx in keep_idx] final_class = [final_class[idx] for idx in keep_idx] npy_time.toc() print('net time: {:.3f}, npy time: {:.3f}'.format(net_time.average_time, npy_time.average_time)) return final_boxes, final_probs, final_class
def act_fn(self, x): return sigmoid(x) def deriv_act_fn(self, x): return deriv_sigmoid(x)