def predict_with_keras_model(model_weights: List, x: np.ndarray) -> np.ndarray: try: pred = softmax(np.dot(x, model_weights[0]) + model_weights[1]) except IndexError as e: pred = softmax(np.dot(x, model_weights[0])) return np.argmax(pred, axis=1)
def correct_preds_for_insides(preds, spans_coords, logits, insides, mapping, inverse_mapping): for i in range(len(preds)): for j in range(len(preds)): if spans_coords[j][0] >= spans_coords[i][0] and spans_coords[j][ 1] <= spans_coords[i][1]: if spans_coords[j][0] != spans_coords[i][0] or spans_coords[j][ 1] != spans_coords[i][1]: def_i = preds[i] def_j = preds[j] log = softmax([logits[i]])[0] login = softmax([logits[j]])[0] def_prob_i = log[inverse_mapping[preds[i]]] def_prob_j = login[inverse_mapping[preds[j]]] while preds[j] not in insides.get(preds[i], []): if log[inverse_mapping[preds[i]]] > login[ inverse_mapping[preds[j]]]: values = np.sort(login)[-2:] if values[1] / (values[0] + 1e-6) > 1.4: preds[i] = def_i preds[j] = def_j break login[inverse_mapping[preds[j]]] = 0 preds[j] = mapping[np.argmax(login)] else: values = np.sort(log)[-2:] if values[1] / (values[0] + 1e-6) > 1.4: preds[i] = def_i preds[j] = def_j break log[inverse_mapping[preds[i]]] = 0 preds[i] = mapping[np.argmax(log)] return preds
def ensemble(scores1, scores2): ss1 = scores1.sum(axis=0).reshape([1, -1]) ss2 = scores2.sum(axis=0).reshape([1, -1]) ss1 = softmax(ss1) ss2 = softmax(ss2) final_scores = ss1 + ss2 final_pred = np.argmax(final_scores) return final_pred
def rpotts(X, model): features, A = X n_classes = len(model.classes_) n_sites = features.shape[0] n_neighbors = A.sum(axis=1).reshape(-1, 1) R = np.random.uniform(size=(n_sites, 1)) lower = np.empty((n_sites, 1)) upper = np.empty((n_sites, 1)) betas = model.coef_[:, :-1] eta = model.coef_[:, -1:] p = safe_sparse_dot(features, betas.T, dense_output=True) p += model.intercept_ p_nonspatial = np.hstack((p, np.zeros((features.shape[0], 1)))) p_nonspatial -= logsumexp(p_nonspatial, axis=1)[:, np.newaxis] p_nonspatial = np.exp(p_nonspatial, p_nonspatial) _target = model.lbin.transform i = 0 while not np.array_equal(upper, lower): R = np.hstack((np.random.uniform(size=R.shape), R)) print(upper.sum(), lower.sum()) lower[:] = 0 upper[:] = n_classes - 1 for r in R.T: r = r.reshape(-1, 1) upper_multi = _target(upper) upper_spatial = safe_sparse_dot(A, (upper_multi - p_nonspatial))[:, :-1]/n_neighbors upper_spatial[np.isnan(upper_spatial)] = 0 upper_p = p + (eta.T * np.array(upper_spatial)) upper_p = softmax(np.hstack((upper_p, np.zeros((features.shape[0], 1))))) upper_p = upper_p.cumsum(axis=1) lower_multi = _target(lower) lower_spatial = safe_sparse_dot(A, (lower_multi - p_nonspatial))[:, :-1]/n_neighbors lower_spatial[np.isnan(lower_spatial)] = 0 lower_p = p + (eta.T * np.array(lower_spatial)) lower_p = softmax(np.hstack((lower_p, np.zeros((features.shape[0], 1))))) lower_p = lower_p.cumsum(axis=1) upper = (upper_p > r).argmax(axis = 1) lower = (lower_p > r).argmax(axis = 1) return lower.reshape(-1, 1)
def get_sensitivity_map(self, model, image, class_index, patch_size, color, use_softmax=False, use_old_confidence=False): """ Compute sensitivity map on a given image for a specific class index. Args: model (tf.keras.Model): tf.keras model to inspect image: class_index (int): Index of targeted class patch_size (int): Size of patch to apply on the image use_softmax (bool): should a softmax be used on the predictions of the model use_old_confidence (bool): compute the saliency map with original_confidence - prediction, or 1 - prediction Returns: np.ndarray: Sensitivity map with shape (H, W, 3) """ sensitivity_map = np.zeros( ( math.ceil(image.shape[0] / patch_size), math.ceil(image.shape[1] / patch_size), ) ) patches = [ custom_apply_grey_patch(image, top_left_x, top_left_y, patch_size, color=color) for index_x, top_left_x in enumerate(range(0, image.shape[0], patch_size)) for index_y, top_left_y in enumerate(range(0, image.shape[1], patch_size)) ] coordinates = [ (index_y, index_x) for index_x in range( sensitivity_map.shape[1] ) for index_y in range( sensitivity_map.shape[0] ) ] pred = model.predict(np.expand_dims(image, axis=0)) if use_softmax: pred = softmax(pred) original_pred = np.squeeze(pred)[class_index] for (index_y, index_x), patch in zip( coordinates, patches ): prediction = model.predict(np.expand_dims(patch, axis=0)) if use_softmax: confidence = np.squeeze(softmax(prediction))[class_index] else: confidence = np.squeeze(prediction)[class_index] if use_old_confidence: sensitivity_map[index_y, index_x] = original_pred - confidence else: sensitivity_map[index_y, index_x] = 1 - confidence return cv2.resize(sensitivity_map, image.shape[0:2])
def finalize_metrics(self, ks=(1, 2)): """ Calculate and log the final ensembled metrics. ks (tuple): list of top-k values for topk_accuracies. For example, ks = (1, 5) correspods to top-1 and top-5 accuracy. """ if self.isDemo: preds_numpy = self.video_preds.clone() normalize = np.array(softmax(preds_numpy.cpu().numpy())) jogging_label = 21 sort_p = [] for p in normalize: sort_p.append(sorted(p, reverse=True)) propability = np.transpose( np.array(softmax(preds_numpy.cpu().numpy()))) for i, v in enumerate(propability[jogging_label]): top1_v = sort_p[i][0] top2_v = sort_p[i][1] if v == top1_v or v == top2_v: propability[jogging_label][ i] = propability[jogging_label][i] / (top1_v + top2_v) cwd = os.getcwd() tmp_dir = os.path.join(cwd, "tmp") if not os.path.exists(tmp_dir): os.mkdir(tmp_dir) out_dir = os.path.join(tmp_dir, "probability.npy") np.save(out_dir, propability[jogging_label]) if not all(self.clip_count == self.num_clips): logger.warning("clip count {} ~= num clips {}".format( self.clip_count, self.num_clips)) logger.warning(self.clip_count) num_topks_correct = metrics.topks_correct(self.video_preds, self.video_labels, ks) topks = [(x / self.video_preds.size(0)) * 100.0 for x in num_topks_correct] #binary = [ # (x / self.video_preds.size(0)) * 100.0 for x in binary_correct #] assert len({len(ks), len(topks)}) == 1 stats = {"split": "test_final"} for k, topk in zip(ks, topks): stats["top{}_acc".format(k)] = "{:.{prec}f}".format(topk, prec=2)
def classifier_predict_proba(X, estimator, skip_attr_set_idxs=[]): log_odds_vector = EBMUtils.decision_function( X, estimator.attribute_sets_, estimator.attribute_set_models_, estimator.intercept_, skip_attr_set_idxs) log_odds_trans = np.c_[-log_odds_vector, log_odds_vector] scores = softmax(log_odds_trans, copy=True) return scores
def predict_proba(self, X): """Predict proba using softmax. Parameters ---------- X : ndarray, shape (n_matrices, n_channels, n_channels) Set of SPD matrices. Returns ------- prob : ndarray, shape (n_matrices, n_classes) Probabilities for each class. """ n_matrices, _, _ = X.shape dist = self._predict_distances(X) idx = np.argsort(dist) dist_sorted = np.take_along_axis(dist, idx, axis=1) neighbors_classes = self.classmeans_[idx] probas = softmax(-dist_sorted[:, 0:self.n_neighbors]**2) prob = np.zeros((n_matrices, len(self.classes_))) for m in range(n_matrices): for il, ll in enumerate(self.classes_): prob[m, il] = np.sum( probas[m, neighbors_classes[m, 0:self.n_neighbors] == ll]) return prob
def eval_fn(data_loader, model, device): model.eval() losses = AverageMeter() tk0 = tqdm(data_loader, total=len(data_loader)) yt, yp = [], [] for bi, d in enumerate(tk0): ids = d['ids'] mask = d['mask'] label = d['label'] ids = ids.to(device, dtype=torch.long) label = label.to(device, dtype=torch.long) mask = mask.to(device, dtype=torch.long) with torch.no_grad(): k = model(input_ids=ids, attention_mask=mask, labels=label) loss = k['loss'] logits = k['logits'] # loss, logits = model(input_ids=ids, attention_mask=mask, labels=label) logits = logits.detach().cpu().numpy() preds = softmax(logits) pred_labels = np.argmax(preds, axis=1).flatten() ground_labels = label.to('cpu').numpy() # print("predict label:", pred_labels.tolist(), ";actual label:", ground_labels.tolist()) yt = yt + ground_labels.tolist() yp = yp + pred_labels.tolist() losses.update(loss.item(), ids.size(0)) tk0.set_postfix(loss=losses.avg) return f1_score(yt, yp)
def read_prediction_logit_file(path): prediction = read_tsv_file(path) prediction = softmax([[float(i[0]), float(i[1])] for i in prediction]) prediction = [i[0] for i in prediction] return prediction
def injectFaultSoftmax(a): "Function to call injectFault on Softmax" logging.debug("Calling Operator Softmax " + getArgs(a)) res = softmax(a) # Use the implementation from the sklearn library res = condPerturb(Ops.SOFTMAX, res) if logReturn: logging.debug("\tReturning from Softmax " + str(res) ) return res
def predict_proba(self, X_INT_ID): # Check is fit had been called check_is_fitted(self, ['X_', 'y_']) # Input validation # X = check_array(X) n2v_id_col = self.n2v_manager.label_id_colname n2v_label_col = self.n2v_manager.label_colname X_ = self.feat_df_.loc[X_INT_ID, :] if n2v_id_col in X_: X_.drop(columns=n2v_id_col, inplace=True) if n2v_label_col in X_: X_.drop(columns=n2v_label_col, inplace=True) if hasattr(self.classifier, "predict_proba"): y_ = self.classifier.predict_proba(X_) return y_ else: decision = self.decision_function(X_) if decision.ndim == 1: # Workaround for multi_class="multinomial" and binary outcomes # which requires softmax prediction with only a 1D decision. decision_2d = np.c_[-decision, decision] else: decision_2d = decision return softmax(decision_2d, copy=False)
def eval_fitness_simulate(env, part, Nx0=5, Kmax=1000, Nmc=1, gamma=0.95, show=False): obs_space = env.observation_space.shape[0] action_space = env.action_space.n Nx0_rewards = [] for i_Nx0 in range(Nx0): # observation = env.reset() # save_point_env = np.copy.deepcopy(env) Nmc_rewards = [] for i_Nmc in range(Nmc): # env = save_point_env observation = env.reset() t_rewards = [] for t in range(Kmax): if show: env.render() part_matrix_w = np.reshape(part[:-action_space],(action_space,obs_space)) part_matrix_b = part[-action_space:] prob_weights = softmax([part_matrix_w.dot(observation)+part_matrix_b]).ravel() # decide action action = np.random.choice(range(len(prob_weights)), p=prob_weights) observation, reward, done, info = env.step(action) t_rewards.append(reward) if done: Nmc_rewards.append( discount_and_normalize_rewards( t_rewards, gamma, norm=False )[0] ) break Nx0_rewards.append( np.mean(Nmc_rewards) ) return (np.mean(Nx0_rewards),)
def generate_explanation(self, stacked_frames, model, radius, raw_diff=False, neuron_selection=False): """ Generates an explanation the prediction of a CNN Args: stacked_frames: input of which the prediction will be explained model: the model which should be explained radius: the radius of the blur raw_diff: use the raw difference of the confidence values or the euklidean disatance Returns: scores: The saliency map which functions as explanantion """ # d: density of scores (if d==1, then get a score for every pixel... # if d==2 then every other, which is 25% of total pixels for a 2D image) d = radius # r: radius of blur r = radius my_input = np.expand_dims(stacked_frames, axis=0) original_output = model.predict(my_input) x = stacked_frames.shape[0] y = stacked_frames.shape[1] scores = np.zeros((int((x - 1) / d) + 1, int( (y - 1) / d) + 1)) # saliency scores S(t,i,j) for i in range(0, x, d): for j in range(0, y, d): mask = self.get_mask(center=[i, j], size=[x, y], r=r) stacked_mask = np.zeros(shape=stacked_frames.shape) for idx in range(stacked_frames.shape[2]): stacked_mask[:, :, idx] = mask masked_input = np.expand_dims(greydanus_explainer.occlude( stacked_frames, stacked_mask), axis=0) masked_output = model.predict(masked_input) if raw_diff: if neuron_selection is not False: action_index = neuron_selection else: action_index = np.argmax(original_output) scores[int(i / d), int(j / d)] = 1 - np.squeeze( softmax(masked_output))[action_index] else: scores[int(i / d), int(j / d)] = ( pow(original_output - masked_output, 2).sum() * 0.5) pmax = scores.max() scores = Image.fromarray(scores).resize(size=[x, y], resample=Image.BILINEAR) scores = pmax * scores / np.array(scores).max() return scores
def calcDerivative(self): input = self.getInput(postForward=True) sx = softmax(input) s = sx.reshape(-1, 1) partial = np.diagflat(s) - np.dot(s, s.T) dydx = np.dot(self.backInput, partial) return dydx
def to_softmax(logits): num_classes = logits.shape[1] if num_classes == 1: scores = expit(logits) else: scores = softmax(logits) return scores
def act(self, round, prev_state, prev_action, reward, new_state, too_slow): if round > self.game_duration - self.score_scope: # cancel exploration during "money-time" self.use_softmax_sampling = False self.epsilon = 0 new_state_repr = self.state_proc.get_state_repr(new_state) if prev_state is not None: prev_state_repr = self.state_proc.get_state_repr(prev_state) self.memory.add(prev_state_repr, bp.Policy.ACTIONS.index(prev_action), reward, new_state_repr, 0) if self.use_softmax_sampling: return np.random.choice( bp.Policy.ACTIONS, p=softmax( self.model.predict(new_state_repr[np.newaxis]) / self.epsilon).squeeze()) else: # use epsilon-greedy if np.random.rand() < self.epsilon: return np.random.choice(bp.Policy.ACTIONS) else: prediction = self.model.predict(new_state_repr[np.newaxis])[0] action = bp.Policy.ACTIONS[np.argmax(prediction)] return action
def decode_output(self, logits, doc_blocks): outputs = [] for jdx, preds in enumerate(logits): output = {} blocks = doc_blocks[jdx] for idx, label in enumerate(self.label_order): if label in ['author', 'date', 'breadcrumbs']: top_k = 10 scores = softmax([preds[:, idx]])[0] ind = np.argpartition(preds[:, idx], -top_k)[-top_k:] result = [(fix_encoding(str_cast(blocks[idx].text)), scores[idx]) for idx in ind if scores[idx] > self.cls_threshold] # sort values by confidence output[label] = sorted(result, key=lambda x: x[1], reverse=True) else: mask = expit(preds[:, idx]) > self.binary_threshold ctx = fix_encoding( str_cast(b'\n'.join([b.text for b in blocks[mask]]))) if len(ctx) == 0: ctx = None output[label] = ctx outputs.append(output) return outputs
def analyze(path): from keras.models import load_model start = datetime.now() tok = Tokenizer(num_words=MAX_WORDS) vocab = pd.read_csv( os.path.realpath(__file__)[:-11] + '/data/java/vocab.csv') tok.fit_on_texts(vocab.input) root = os.path.realpath(__file__)[:-11] + "/data/java/checkpoints/" h5_ls, vuln_models = os.listdir(root), {} for h5 in h5_ls: progress = str(h5_ls.index(h5) + 1) + "/" + str(len(h5_ls)) print("\x1b[33m(" + progress + ") - Loading " + h5[:-3] + "...\x1b[m") vuln_models[h5[:-3]] = load_model(root + h5) jfile = JavaClass(path) for method in jfile.methods: print("\n\x1b[33mEvaluating " + method.name + "()...\x1b[m") metrics, i = [], 0 for vuln_model in vuln_models: pred = float(vuln_models[vuln_model].predict( Javalect._embed(tok, str(method.tokens())))[0][0]) metrics.append(pred) soft_metrics = list(softmax(np.asarray([metrics]))[0]) print(" p-risk p-dist vulnerability") for vuln_model in vuln_models: print(" " + _fmt(metrics, i) + " " + _fmt(soft_metrics, i) + " " + vuln_model) i += 1 print("\n\x1b[33mAnalyzed " + str(len(jfile.methods)) + " methods against " + str(len(h5_ls)) + " vulnerabilities in " + str(datetime.now() - start) + "\x1b[m.")
def generate_action(env, prev_action, observation, w, b): # index = np.random.randn(env.action_space.n) # index[2] = np.abs(index[2]) # Favor main engine over the others: # return np.argmax(index) prob_weights = softmax([w.dot(observation) + b]).ravel() action = np.random.choice(range(len(prob_weights)), p=prob_weights) return action
def predict_proba(self, X): """Predict class probabilities for X. The predicted class probabilities of an input sample is computed. Parameters ---------- X : array-like or sparse matrix of shape = [n_samples, n_features] The input samples. Returns ------- p : array of shape = [n_samples, n_classes]. The class probabilities of the input samples. """ if self.n_classes_ <= 2: proba = self.estimator.predict_proba(X) proba = np.c_[1 - proba, proba] else: proba = np.zeros((X.shape[0], self.n_classes_)) for i, clf in enumerate(self.estimators): class_proba = clf.predict_proba(X) proba[:, i] = class_proba #In honest I don't understand which is better # softmax or normalized sigmoid for calc probability. if self.calc_prob == "Sigmoid": proba = sigmoid(proba) normalizer = proba.sum(axis=1)[:, np.newaxis] normalizer[normalizer == 0.0] = 1.0 proba /= normalizer else: proba = softmax(proba) return proba
def test_calibration_multiclass(method, ensemble, seed): def multiclass_brier(y_true, proba_pred, n_classes): Y_onehot = np.eye(n_classes)[y_true] return np.sum((Y_onehot - proba_pred) ** 2) / Y_onehot.shape[0] # Test calibration for multiclass with classifier that implements # only decision function. clf = LinearSVC(random_state=7) X, y = make_blobs( n_samples=500, n_features=100, random_state=seed, centers=10, cluster_std=15.0 ) # Use an unbalanced dataset by collapsing 8 clusters into one class # to make the naive calibration based on a softmax more unlikely # to work. y[y > 2] = 2 n_classes = np.unique(y).shape[0] X_train, y_train = X[::2], y[::2] X_test, y_test = X[1::2], y[1::2] clf.fit(X_train, y_train) cal_clf = CalibratedClassifierCV(clf, method=method, cv=5, ensemble=ensemble) cal_clf.fit(X_train, y_train) probas = cal_clf.predict_proba(X_test) # Check probabilities sum to 1 assert_allclose(np.sum(probas, axis=1), np.ones(len(X_test))) # Check that the dataset is not too trivial, otherwise it's hard # to get interesting calibration data during the internal # cross-validation loop. assert 0.65 < clf.score(X_test, y_test) < 0.95 # Check that the accuracy of the calibrated model is never degraded # too much compared to the original classifier. assert cal_clf.score(X_test, y_test) > 0.95 * clf.score(X_test, y_test) # Check that Brier loss of calibrated classifier is smaller than # loss obtained by naively turning OvR decision function to # probabilities via a softmax uncalibrated_brier = multiclass_brier( y_test, softmax(clf.decision_function(X_test)), n_classes=n_classes ) calibrated_brier = multiclass_brier(y_test, probas, n_classes=n_classes) assert calibrated_brier < 1.1 * uncalibrated_brier # Test that calibration of a multiclass classifier decreases log-loss # for RandomForestClassifier clf = RandomForestClassifier(n_estimators=30, random_state=42) clf.fit(X_train, y_train) clf_probs = clf.predict_proba(X_test) uncalibrated_brier = multiclass_brier(y_test, clf_probs, n_classes=n_classes) cal_clf = CalibratedClassifierCV(clf, method=method, cv=5, ensemble=ensemble) cal_clf.fit(X_train, y_train) cal_clf_probs = cal_clf.predict_proba(X_test) calibrated_brier = multiclass_brier(y_test, cal_clf_probs, n_classes=n_classes) assert calibrated_brier < 1.1 * uncalibrated_brier
def get_batch_scores(bx, bt): with torch.no_grad(): bx = nn.utils.rnn.pad_sequence(bx, batch_first=True, padding_value=0).to(self.device) bt = nn.utils.rnn.pad_sequence(bt, batch_first=True, padding_value=1).to(self.device) outputs = self.model(bx, bt, (bx != 0)) logits = outputs[0].to('cpu').numpy() b_scores = softmax(logits) scores.extend(b_scores[:, 1].tolist())
def get_proba(self, z): mus = self.get_mus() z = np.array(z).reshape(-1, 1) if self.prior is None: log_prior = 0 else: log_prior = self.log_prior return softmax(log_prior - np.abs(mus - z))
def predict_proba(self, X): check_is_fitted(self) decision = self.decision_function(X) if self.classes_.size == 2: proba = expit(decision) return np.vstack([1-proba, proba]).T else: return softmax(decision)
def tpr(outputs, labels): outputs = np.round(softmax(np.array([outputs]))) labels = np.array([labels]) outputs = list(outputs[0]) labels = list(labels[0]) fpr, tpr, thresholds = metrics.roc_curve(labels, outputs) tpr = np.nanmean(tpr) return tpr
def _compute_stds_and_averages(self, X, weights): z = np.dot(X, weights[0]) stds = weights[1::3] averages = weights[2::3] for alpha, beta, w in zip(stds, averages, weights[3::3]): a = self.saving_batch_normalization(z, alpha, beta) a_r = relu(a) z = np.dot(a_r, w) return softmax(z)
def classifier_predict_proba(X, feature_groups, model, intercept): log_odds_vector = EBMUtils.decision_function(X, feature_groups, model, intercept) # Handle binary classification case -- softmax only works with 0s appended if log_odds_vector.ndim == 1: log_odds_vector = np.c_[np.zeros(log_odds_vector.shape), log_odds_vector] return softmax(log_odds_vector)
def apply_activation(self, in_arr, activation): if activation == "sigmoid": return 1.0 / (1 + np.exp(-in_arr)) elif activation == "relu": out_arr = np.maximum(0, in_arr) return out_arr elif activation == "softmax": return softmax(in_arr) elif activation == 'tanh': return np.tanh(in_arr)
def predict_proba(self, X): if self._strategy == 'ova': scores = self.score_samples(X) smin = np.min(scores, axis=-1, keepdims=True) smax = np.max(scores, axis=-1, keepdims=True) scores = (scores - smin) / (smax - smin) proba = softmax(scores) elif self._strategy == 'all': proba = self.score_samples(X) return proba
def classifier_predict_proba(X, estimator, skip_attr_set_idxs=[]): log_odds_vector = EBMUtils.decision_function( X, estimator.attribute_sets_, estimator.attribute_set_models_, estimator.intercept_, skip_attr_set_idxs, ) log_odds_trans = np.c_[-log_odds_vector, log_odds_vector] scores = softmax(log_odds_trans, copy=True) return scores
def predict_proba(self, X): """Predict proba using softmax. Parameters ---------- X : ndarray, shape (n_trials, n_channels, n_channels) ndarray of SPD matrices. Returns ------- prob : ndarray, shape (n_trials, n_classes) the softmax probabilities for each class. """ return softmax(-self._predict_distances(X))
def predict_proba(self, X): """ Predict class probabilities for X. The predicted class probabilities of an input sample are computed. Parameters ---------- X : array-like or sparse matrix of shape = [n_samples, n_features] The input samples. Returns ------- p : array of shape = [n_samples, n_classes]. The class probabilities of the input samples. The order of the classes corresponds to that in the attribute classes_. """ if self._fitted is None: raise NotFittedError(_NOT_FITTED_ERROR_DESC) X = check_array(X, accept_sparse=True) n_features = X.shape[1] if self._n_features != n_features: raise ValueError("Number of features of the model must " "match the input. Model n_features is %s and " "input n_features is %s " % (self._n_features, n_features)) if self._n_classes == 2: y = self._estimators[0].predict_proba(X) y = _sigmoid(y) y = np.c_[y, 1 - y] else: y = np.zeros((X.shape[0], self._n_classes)) for i, clf in enumerate(self._estimators): class_proba = clf.predict_proba(X) y[:, i] = class_proba # In honest, I don't understand which is better # softmax or normalized sigmoid for calc probability. if self.calc_prob == "sigmoid": y = _sigmoid(y) normalizer = np.sum(y, axis=1)[:, np.newaxis] normalizer[normalizer == 0.0] = 1.0 y /= normalizer else: y = softmax(y) return y
def predict_proba(self, X): """ Predict class probabilities for X. The predicted class probabilities of an input sample are computed. Parameters ---------- X : array-like or sparse matrix of shape = [n_samples, n_features] The input samples. Returns ------- p : array of shape = [n_samples, n_classes]. The class probabilities of the input samples. The order of the classes corresponds to that in the attribute classes_. """ if not hasattr(self, '_fitted') or not self._fitted: raise NotFittedError(NOT_FITTED_ERROR_DESC) X = check_array(X, accept_sparse=True) self._check_n_features(X.shape[1]) if self._n_classes == 2: y = self._estimators[0].predict(X) y = sigmoid(y) y = np.c_[y, 1 - y] else: y = np.zeros((X.shape[0], self._n_classes)) for i, clf in enumerate(self._estimators): class_proba = clf.predict(X) y[:, i] = class_proba if self.calc_prob == "sigmoid": y = sigmoid(y) normalizer = np.sum(y, axis=1)[:, np.newaxis] normalizer[normalizer == 0.0] = 1.0 y /= normalizer else: y = softmax(y) return y
def _predict_proba(lr, X): pred = safe_sparse_dot(X, lr.coef_.T) if hasattr(lr, "intercept_"): pred += lr.intercept_ return softmax(pred)
def test_softmax(): rng = np.random.RandomState(0) X = rng.randn(3, 5) exp_X = np.exp(X) sum_exp_X = np.sum(exp_X, axis=1).reshape((-1, 1)) assert_array_almost_equal(softmax(X), exp_X / sum_exp_X)