def apply_anchors_ver1(pred: np.ndarray, stride: int, anchor: List[Tuple[int]], xyscale: float) -> np.ndarray: assert len(pred.shape) == 3 assert pred.shape[2] == 255 # align the axes to (x, y, anchor, data) pred = pred.reshape((*pred.shape[:2], 3, 85)) # calc grid of anchor box anchor_grid = np.array(anchor)[np.newaxis, np.newaxis, :, :] grid = np.meshgrid(np.arange(pred.shape[1]), np.arange(pred.shape[0])) grid = np.stack(grid, axis=-1)[:, :, np.newaxis, :] # xy: min_x, min_y # wh: width, height # conf: confidence score of the bounding box # prob: probability for each category xy, wh, conf, prob = np.split(pred, (2, 4, 5), axis=-1) # apply anchor xy = ((sigmoid(xy) * xyscale) - (0.5 * (xyscale - 1)) + grid) * stride wh = np.exp(wh) * anchor_grid conf = sigmoid(conf) prob = sigmoid(prob) # concat bbox = np.concatenate([xy, wh, conf, prob], axis=-1) # expand all anchors bbox = np.reshape(bbox, (-1, 85)) return bbox
def backprop(self, x, y): """Return a tuple ``(nabla_b, nabla_w)`` representing the gradient for the cost function C_x. ``nabla_b`` and ``nabla_w`` are layer-by-layer lists of numpy arrays, similar to ``self.biases`` and ``self.weights``.""" nabla_b = [np.zeros(b.shape) for b in self.biases] nabla_w = [np.zeros(w.shape) for w in self.weights] # feedforward activation = x activations = [x] # list to store all the activations, layer by layer zs = [] # list to store all the z vectors, layer by layer for b, w in zip(self.biases, self.weights): z = np.dot(w, activation) + b zs.append(z) activation = sigmoid(z) activations.append(activation) # backward pass delta = self.cost_derivative(activations[-1], y) * \ sigmoid_prime(zs[-1]) nabla_b[-1] = delta nabla_w[-1] = np.dot(delta, activations[-2].transpose()) # Note that the variable l in the loop below is used a little # differently to the notation in Chapter 2 of the book. Here, # l = 1 means the last layer of neurons, l = 2 is the # second-last layer, and so on. It's a renumbering of the # scheme in the book, used here to take advantage of the fact # that Python can use negative indices in lists. for l in range(2, self.num_layers): z = zs[-l] sp = sigmoid_prime(z) delta = np.dot(self.weights[-l + 1].transpose(), delta) * sp nabla_b[-l] = delta nabla_w[-l] = np.dot(delta, activations[-l - 1].transpose()) return (nabla_b, nabla_w)
def on_batch_end(self, state: State): # print(type(state.model)) # if not isinstance(state.model, tta.wrappers.SegmentationTTAWrapper): # print("Not instance of tta") # exit() for prob in state.batch_out["logits"]: for probability in prob: probability = probability.detach().cpu().numpy() if probability.shape != (350, 525): probability = cv2.resize( probability, dsize=(525, 350), interpolation=cv2.INTER_LINEAR ) prediction, num_predict = post_process( sigmoid(probability), threshold=self.threshold, min_size=self.min_size, ) if num_predict == 0: self.pred_distr[-1] += 1 self.encoded_pixels[self.image_id] = "" else: self.pred_distr[self.image_id % 4] += 1 r = mask2rle(prediction) self.encoded_pixels[self.image_id] = r self.image_id += 1
def run_test_epoch(self): self.model.eval() test_preds = np.zeros((len(self.test_loader.dataset))) with torch.no_grad(): for i, (x_batch,) in enumerate(self.test_loader): y_pred = self.model(x_batch).detach() test_preds[i * self.batch_size:(i + 1) * self.batch_size] = sigmoid(y_pred.cpu().numpy())[:, 0] return test_preds
def backprop_matrix(self, x, y): """Return a tuple ``(nabla_b, nabla_w)`` representing the gradient for the cost function C. ``nabla_b`` and ``nabla_w`` are layer-by-layer lists of numpy arrays, similar to ``self.biases`` and ``self.weights``. x.shape() is (mini_batch_size,input_dim) y.shape() is (mini_batch_size,output_dim)""" nabla_b = [np.zeros(b.shape) for b in self.biases] nabla_w = [np.zeros(w.shape) for w in self.weights] # feedforward y = np.transpose(y) x = np.transpose(x) # activation.shape=(neutron_num_of_pre_layer, mini_batch_size) activation = x activations = [x] # list to store all the activations, layer by layer zs = [] # list to store all the z vectors, layer by layer for b, w in zip(self.biases, self.weights): # w.shape=(neutron_num_of_current_layer,neutron_num_of_pre_layer) # b.shape=(neutron_num_of_current_layer,1) # z.shape=(neutron_num_of_current_layer,mini_batch_size) z = np.einsum('ij,jk', w, activation) + b # b can be broadcasted zs.append(z) activation = sigmoid(z) activations.append(activation) # backward pass # delta.shape=(neutron_num_of_current_layer,mini_batch_size) delta = self.cost_derivative(activations[-1], y) * \ sigmoid_prime(zs[-1]) # nabla_b.shape=(neutron_num_of_current_layer,mini_batch_size) nabla_b[-1] = delta.sum(1)[:, np.newaxis] # nabla_w=(neutron_num_of_current_layer,neutron_num_of_pre_layer) nabla_w[-1] = np.dot(delta, activations[-2].transpose()) # Note that the variable l in the loop below is used a little # differently to the notation in Chapter 2 of the book. Here, # l = 1 means the last layer of neurons, l = 2 is the # second-last layer, and so on. It's a renumbering of the # scheme in the book, used here to take advantage of the fact # that Python can use negative indices in lists. for l in range(2, self.num_layers): z = zs[-l] # sp (cur,bat) sp = sigmoid_prime(z) # weights.T (pre,cur) # delta (cur,bat) # sp (pre,bat) delta = np.dot(self.weights[-l + 1].transpose(), delta) * sp # delta (pre,bat) nabla_b[-l] = delta.sum(1)[:, np.newaxis] nabla_w[-l] = np.dot(delta, activations[-l - 1].transpose()) # nabla_w (cur,pre) # nabla_b (cur,bat) return (nabla_b, nabla_w)
def run_validation_epoch(self): self.model.eval() avg_val_loss = 0. valid_preds = np.zeros((len(self.valid_loader.dataset))) with torch.no_grad(): for i, (x_batch, y_batch) in enumerate(self.valid_loader): y_pred = self.model(x_batch).detach() avg_val_loss += self.loss(y_pred, y_batch).item() / len(self.valid_loader) valid_preds[i * self.batch_size:(i + 1) * self.batch_size] = sigmoid(y_pred.cpu().numpy())[:, 0] search_result = threshold_search(self.y_val.cpu().numpy(), valid_preds) val_f1, val_threshold = search_result['f1'], search_result['threshold'] return valid_preds, avg_val_loss, val_f1
def evaluate(model, valid_loader, loss_fn, valid_preds_fold, feats, kfold_X_valid_features): model.eval() avg_val_loss = 0. for i, (x_batch, y_batch, index) in enumerate(valid_loader): if feats: f = kfold_X_valid_features[index] y_pred = model([x_batch, f]).detach() else: y_pred = model(x_batch).detach() avg_val_loss += loss_fn(y_pred, y_batch).item() / len(valid_loader) valid_preds_fold[index] = sigmoid(y_pred.cpu().numpy())[:, 0] return avg_val_loss, valid_preds_fold
def test(model, test_loader, train_preds, valid_idx, test_preds, valid_preds_fold, test_preds_fold, splits, feats, test_features): for i, (x_batch, ) in enumerate(test_loader): if feats: f = test_features[i * batch_size:(i + 1) * batch_size] y_pred = model([x_batch, f]).detach() else: y_pred = model(x_batch).detach() test_preds_fold[i * batch_size:(i + 1) * batch_size] = sigmoid( y_pred.cpu().numpy())[:, 0] train_preds[valid_idx] = valid_preds_fold test_preds += test_preds_fold / len(splits) return test_preds
def on_stage_end(self, state: State): class_params = {} for class_id in range(4): print(class_id) attempts = [] for t in range(0, 100, 10): t /= 100 for ms in [ 0, 1000, 5000, 10000, 11000, 14000, 15000, 16000, 18000, 19000, 20000, 21000, 23000, 25000, 27000, ]: masks = [] for i in range(class_id, len(self.probabilities), 4): probability = self.probabilities[i] predict, num_predict = post_process(sigmoid(probability), t, ms) masks.append(predict) d = [] for i, j in zip(masks, self.valid_masks[class_id::4]): d.append(single_dice_coef(y_pred_bin=i, y_true=j)) attempts.append((t, ms, np.mean(d))) attempts_df = pd.DataFrame(attempts, columns=["threshold", "size", "dice"]) attempts_df = attempts_df.sort_values("dice", ascending=False) print(attempts_df.head()) best_threshold = attempts_df["threshold"].values[0] best_size = attempts_df["size"].values[0] class_params[class_id] = (best_threshold, best_size) np.save("./logs/class_params.npy", class_params)
def apply_anchors_ver2(pred: np.ndarray, stride: int, anchor: List[Tuple[int]], xyscale: float) -> np.ndarray: assert len(pred.shape) == 3 assert pred.shape[2] == 255 # align the axes to (x, y, anchor, data) pred = pred.reshape((*pred.shape[:2], 3, 85)) # calc grid of anchor box anchor_grid = np.array(anchor)[np.newaxis, np.newaxis, :, :] grid = np.meshgrid(np.arange(pred.shape[1]), np.arange(pred.shape[0])) grid = np.stack(grid, axis=-1)[:, :, np.newaxis, :] # apply anchor pred = sigmoid(pred) pred[..., :2] = ((pred[..., :2] * xyscale) - (0.5 * (xyscale - 1)) + grid) * stride pred[..., 2:4] = ((pred[..., 2:4] * xyscale)**2) * anchor_grid # expand all anchors bbox = np.reshape(pred, (-1, 85)) return bbox
def on_batch_end(self, state: State): preds_write = [False, False, False, False] allow = True for prob in state.batch_out["logits"]: for probability in prob: probability = probability.detach().cpu().numpy() probability = sigmoid(probability) pseudo_label = np.copy(probability) ones_condition = (pseudo_label < self.low_threshold) | ( pseudo_label > self.high_threshold ) pseudo_label[ones_condition] = 1 pseudo_label[~ones_condition] = 0 val = ( pseudo_label.sum() * 100 / (pseudo_label.shape[0] * pseudo_label.shape[1]) ) if val < self.good_pixel_threshold: allow = False preds_write[self.image_id % 4] = ( probability, self.sub.iloc[self.image_id]["Image_Label"], ) self.image_id += 1 if self.image_id % 4 == 0: if allow: for probability_new, name in preds_write: self.names_pl.append(name) predict_pl, num_predict_pl = post_process( probability_new, self.activation_threshold, self.mask_size_threshold, ) if num_predict_pl == 0: self.encoded_pixels_pl.append("") else: r_pl = mask2rle(predict_pl) self.encoded_pixels_pl.append(r_pl) allow = True
def infer(model, testloader, class_params, output_path): encoded_pixels = [] pred_distr = {-1: 0, 0: 0, 1: 0, 2: 0, 3: 0} image_id = 0 model.eval() with torch.no_grad(): for images, _ in tqdm.tqdm(testloader, total=len(testloader)): masks = model(images) for mask in masks: mask = mask.cpu().detach().numpy() if mask.shape != (350, 525): mask = cv2.resize( mask, dsize=(525, 350), interpolation=cv2.INTER_LINEAR ) mask, num_predict = post_process( sigmoid(mask), class_params[image_id % 4][0], class_params[image_id % 4][1], ) if num_predict == 0: pred_distr[-1] += 1 encoded_pixels.append("") else: pred_distr[image_id % 4] += 1 r = mask2rle(mask) encoded_pixels.append(r) image_id += 1 print( f"empty={pred_distr[-1]} fish={pred_distr[0]} flower={pred_distr[1]} gravel={pred_distr[2]} sugar={pred_distr[3]}" ) non_empty = pred_distr[0] + pred_distr[1] + pred_distr[2] + pred_distr[3] all = non_empty + pred_distr[-1] sub = pd.read_csv(f"{output_path}/sample_submission.csv") sub["EncodedPixels"] = encoded_pixels sub.to_csv( f"submission_{round(non_empty/all, 3)}.csv", columns=["Image_Label", "EncodedPixels"], index=False, )
def forward(self, batch): self.X = np.array(sigmoid(x) for x in batch) return self.X
def feedforward(self, a): for w, b in zip(self.weights, self.biases): a = sigmoid(np.dot(w, a) + b) return a
if __name__ == '__main__': df = utils.get_ts_data() il_sr = df.loc['Israel'] il_sr_nozeros = utils.rm_zeros(il_sr) n_days = il_sr_nozeros.size x_days = list(range(n_days)) l_guess = 0.65 * 9 * (10**6) k_guess = 1.0 x0_guess = n_days if n_days <= 60 else n_days / 2 params_opt, _ = utils.estimate_sigmoid_params(x_days, il_sr_nozeros.values, [l_guess, k_guess, x0_guess]) opt_l, opt_k, opt_x0 = params_opt x_range = np.linspace(0, n_days + 3, 1000) # opt_x0 * 2 print(opt_l) plt.figure() plt.plot(range(n_days), il_sr_nozeros, label='Data', marker='o') plt.plot(x_range, utils.sigmoid(x_range, *params_opt), 'r-', ls='-', label="Sigmoid Fit") plt.legend() plt.show()
from src.utils import L_ex, sigmoid, roc_curve, get_path path = get_path(__file__) + '/..' w = np.array([-410.6073, 0.1494, 4.4185]) idxs = [L_ex.index(f) for f in ['sdE5', 'V11', 'E9']] Xf = D_ex[:, idxs] num_tests = 5 results = [] for i in range(num_tests): test_rows = np.random.random_integers(0, D_ex.shape[0]-1, 1e5) X = Xf[test_rows, :] y = D_ex[test_rows, 2] lin = np.dot(X, w) probs = sigmoid(lin) fpr, tpr, thresholds = roc_curve(y, probs, thresholds=np.linspace(0,1,1e3)) results.append(auc(fpr, tpr)) json_path = '{0}/data/hard-coded-results-{1}-tests.json'.format(path, num_tests) with open(json_path, 'w') as f: json.dump(results, f, indent=4)
def __call__(self, input): """Forward pass of the logistic classifier. args: input (np.array) : row matrix of samples """ return sigmoid(np.dot(input, self.weights))