本文整理汇总了Python中scipy.maximum方法的典型用法代码示例。如果您正苦于以下问题:Python scipy.maximum方法的具体用法?Python scipy.maximum怎么用?Python scipy.maximum使用的例子?那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类scipy
的用法示例。
在下文中一共展示了scipy.maximum方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: prior_log_loss
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def prior_log_loss(frac_pos, task = 'binary.classification'):
''' Baseline log loss. For multiplr classes ot labels return the volues for each column'''
eps = 1e-15
frac_pos_ = sp.maximum (eps, frac_pos)
if (task != 'multiclass.classification'): # binary case
frac_neg = 1-frac_pos
frac_neg_ = sp.maximum (eps, frac_neg)
pos_class_log_loss_ = - frac_pos * np.log(frac_pos_)
neg_class_log_loss_ = - frac_neg * np.log(frac_neg_)
base_log_loss = pos_class_log_loss_ + neg_class_log_loss_
# base_log_loss = mvmean(base_log_loss)
# print('binary {}'.format(base_log_loss))
# In the multilabel case, the right thing i to AVERAGE not sum
# We return all the scores so we can normalize correctly later on
else: # multiclass case
fp = frac_pos_ / sum(frac_pos_) # Need to renormalize the lines in multiclass case
# Only ONE label is 1 in the multiclass case active for each line
pos_class_log_loss_ = - frac_pos * np.log(fp)
base_log_loss = np.sum(pos_class_log_loss_)
return base_log_loss
# sklearn implementations for comparison
示例2: prep_optics
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def prep_optics(SetofObjects, epsilon):
"""
Prep data set for main OPTICS loop
SetofObjects: Instantiated instance of 'setOfObjects' class
epsilon: Determines maximum object size that can be extracted. Smaller epsilons
reduce run time.
Returns modified setOfObjects tree structure
"""
for j in SetofObjects._index:
# Find smallest nonzero distance
SetofObjects._core_dist[j] = np.sort(SetofObjects.data[j,:])[1]
示例3: expandClusterOrder
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def expandClusterOrder(SetOfObjects, point, epsilon):
"""
Expands OPTICS ordered list of clustering structure
SetofObjects: Instantiated and prepped instance of 'setOfObjects' class
epsilon: Determines maximum object size that can be extracted. Smaller epsilons
reduce run time.
"""
if SetOfObjects._core_dist[point] <= epsilon:
while not SetOfObjects._processed[point]:
SetOfObjects._processed[point] = True
SetOfObjects._ordered_list.append(point)
point = set_reach_dist(SetOfObjects, point, epsilon)
else:
SetOfObjects._processed[point] = True
示例4: log_loss
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def log_loss(actual, predicted, epsilon=1e-15):
"""
Calculates and returns the log loss (error) of a set of predicted probabilities
(hint: see sklearn classifier's predict_proba methods).
Source: https://www.kaggle.com/wiki/LogarithmicLoss
In plain English, this error metric is typically used where you have to predict
that something is true or false with a probability (likelihood) ranging from
definitely true (1) to equally true (0.5) to definitely false(0).
Note: also see (and use) scikitlearn:
http://scikit-learn.org/stable/modules/generated/sklearn.metrics.log_loss.html#sklearn.metrics.log_loss
"""
predicted = sp.maximum(epsilon, predicted)
predicted = sp.minimum(1-epsilon, predicted)
ll = sum(actual*sp.log(predicted) + sp.subtract(1,actual)*sp.log(sp.subtract(1,predicted)))
ll = ll * -1.0/len(actual)
return ll
示例5: bac_metric
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def bac_metric (solution, prediction, task='binary.classification'):
''' Compute the normalized balanced accuracy. The binarization and
the normalization differ for the multi-label and multi-class case. '''
label_num = solution.shape[1]
score = np.zeros(label_num)
bin_prediction = binarize_predictions(prediction, task)
[tn,fp,tp,fn] = acc_stat(solution, bin_prediction)
# Bounding to avoid division by 0
eps = 1e-15
tp = sp.maximum (eps, tp)
pos_num = sp.maximum (eps, tp+fn)
tpr = tp / pos_num # true positive rate (sensitivity)
if (task != 'multiclass.classification') or (label_num==1):
tn = sp.maximum (eps, tn)
neg_num = sp.maximum (eps, tn+fp)
tnr = tn / neg_num # true negative rate (specificity)
bac = 0.5*(tpr + tnr)
base_bac = 0.5 # random predictions for binary case
else:
bac = tpr
base_bac = 1./label_num # random predictions for multiclass case
bac = mvmean(bac) # average over all classes
# Normalize: 0 for random, 1 for perfect
score = (bac - base_bac) / sp.maximum(eps, (1 - base_bac))
return score
示例6: binary_logloss
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def binary_logloss(p, y):
epsilon = 1e-15
p = sp.maximum(epsilon, p)
p = sp.minimum(1-epsilon, p)
res = sum(y * sp.log(p) + sp.subtract(1, y) * sp.log(sp.subtract(1, p)))
res *= -1.0/len(y)
return res
示例7: logloss
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def logloss(p, y):
epsilon = 1e-15
p = sp.maximum(epsilon, p)
p = sp.minimum(1-epsilon, p)
ll = sum(y*sp.log(p) + sp.subtract(1,y)*sp.log(sp.subtract(1,p)))
ll = ll * -1.0/len(y)
return ll
# B. Apply hash trick of the original csv row
# for simplicity, we treat both integer and categorical features as categorical
# INPUT:
# csv_row: a csv dictionary, ex: {'Lable': '1', 'I1': '357', 'I2': '', ...}
# D: the max index that we can hash to
# OUTPUT:
# x: a list of indices that its value is 1
示例8: bac_metric
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def bac_metric (solution, prediction, task='binary.classification'):
''' Compute the normalized balanced accuracy. The binarization and
the normalization differ for the multi-label and multi-class case. '''
# Convert to 2d if necessary
solution = np.array(solution, ndmin=2)
if solution.shape[1] == 1:
solution = solution.T
prediction = np.array(prediction, ndmin=2)
if prediction.shape[1] == 1:
prediction = prediction.T
# Carry on
label_num = solution.shape[1]
score = np.zeros(label_num)
bin_prediction = binarize_predictions(prediction, task)
[tn,fp,tp,fn] = acc_stat(solution, bin_prediction)
# Bounding to avoid division by 0
eps = 1e-15
tp = sp.maximum (eps, tp)
pos_num = sp.maximum (eps, tp+fn)
tpr = tp / pos_num # true positive rate (sensitivity)
if (task != 'multiclass.classification') or (label_num==1):
tn = sp.maximum (eps, tn)
neg_num = sp.maximum (eps, tn+fp)
tnr = tn / neg_num # true negative rate (specificity)
bac = 0.5*(tpr + tnr)
base_bac = 0.5 # random predictions for binary case
else:
bac = tpr
base_bac = 1./label_num # random predictions for multiclass case
bac = mvmean(bac) # average over all classes
# Normalize: 0 for random, 1 for perfect
score = (bac - base_bac) / sp.maximum(eps, (1 - base_bac))
return score
示例9: pac_metric
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def pac_metric (solution, prediction, task='binary.classification'):
''' Probabilistic Accuracy based on log_loss metric.
We assume the solution is in {0, 1} and prediction in [0, 1].
Otherwise, run normalize_array.'''
debug_flag=False
[sample_num, label_num] = solution.shape
if label_num==1: task='binary.classification'
eps = 1e-15
the_log_loss = log_loss(solution, prediction, task)
# Compute the base log loss (using the prior probabilities)
pos_num = 1.* sum(solution) # float conversion!
frac_pos = pos_num / sample_num # prior proba of positive class
the_base_log_loss = prior_log_loss(frac_pos, task)
# Alternative computation of the same thing (slower)
# Should always return the same thing except in the multi-label case
# For which the analytic solution makes more sense
if debug_flag:
base_prediction = np.empty(prediction.shape)
for k in range(sample_num): base_prediction[k,:] = frac_pos
base_log_loss = log_loss(solution, base_prediction, task)
diff = np.array(abs(the_base_log_loss-base_log_loss))
if len(diff.shape)>0: diff=max(diff)
if(diff)>1e-10:
print('Arrggh {} != {}'.format(the_base_log_loss,base_log_loss))
# Exponentiate to turn into an accuracy-like score.
# In the multi-label case, we need to average AFTER taking the exp
# because it is an NL operation
pac = mvmean(np.exp(-the_log_loss))
base_pac = mvmean(np.exp(-the_base_log_loss))
# Normalize: 0 for random, 1 for perfect
score = (pac - base_pac) / sp.maximum(eps, (1 - base_pac))
return score
示例10: log_loss
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def log_loss(solution, prediction, task = 'binary.classification'):
''' Log loss for binary and multiclass. '''
[sample_num, label_num] = solution.shape
eps = 1e-15
pred = np.copy(prediction) # beware: changes in prediction occur through this
sol = np.copy(solution)
if (task == 'multiclass.classification') and (label_num>1):
# Make sure the lines add up to one for multi-class classification
norma = np.sum(prediction, axis=1)
for k in range(sample_num):
pred[k,:] /= sp.maximum (norma[k], eps)
# Make sure there is a single label active per line for multi-class classification
sol = binarize_predictions(solution, task='multiclass.classification')
# For the base prediction, this solution is ridiculous in the multi-label case
# Bounding of predictions to avoid log(0),1/0,...
pred = sp.minimum (1-eps, sp.maximum (eps, pred))
# Compute the log loss
pos_class_log_loss = - mvmean(sol*np.log(pred), axis=0)
if (task != 'multiclass.classification') or (label_num==1):
# The multi-label case is a bunch of binary problems.
# The second class is the negative class for each column.
neg_class_log_loss = - mvmean((1-sol)*np.log(1-pred), axis=0)
log_loss = pos_class_log_loss + neg_class_log_loss
# Each column is an independent problem, so we average.
# The probabilities in one line do not add up to one.
# log_loss = mvmean(log_loss)
# print('binary {}'.format(log_loss))
# In the multilabel case, the right thing i to AVERAGE not sum
# We return all the scores so we can normalize correctly later on
else:
# For the multiclass case the probabilities in one line add up one.
log_loss = pos_class_log_loss
# We sum the contributions of the columns.
log_loss = np.sum(log_loss)
#print('multiclass {}'.format(log_loss))
return log_loss
示例11: predict
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def predict(self, X):
prediction = self.predict_method(X)
# Calibrate proba
if self.task != 'regression' and self.postprocessor!=None:
prediction = self.postprocessor.predict_proba(prediction)
# Keep only 2nd column because the second one is 1-first
if self.target_num==1 and len(prediction.shape)>1 and prediction.shape[1]>1:
prediction = prediction[:,1]
# Make sure the normalization is correct
if self.task=='multiclass.classification':
eps = 1e-15
norma = np.sum(prediction, axis=1)
for k in range(prediction.shape[0]):
prediction[k,:] /= sp.maximum(norma[k], eps)
return prediction
示例12: logloss
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def logloss(y_true, y_predicted):
epsilon = 1e-6
y_predicted = sp.maximum(epsilon, y_predicted)
y_predicted = sp.minimum(1 - epsilon, y_predicted)
ll = log_loss(y_true, y_predicted)
return ll
示例13: build_optics
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def build_optics(SetOfObjects, epsilon):
"""
Builds OPTICS ordered list of clustering structure
SetofObjects: Instantiated and prepped instance of 'setOfObjects' class
epsilon: Determines maximum object size that can be extracted. Smaller epsilons
reduce run time.
"""
for point in SetOfObjects._index:
if not SetOfObjects._processed[point]:
expandClusterOrder(SetOfObjects, point, epsilon)
示例14: set_reach_dist
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def set_reach_dist(SetOfObjects, point_index, epsilon):
"""
Sets reachability distance and ordering. This function is the primary workhorse of
the OPTICS algorithm.
SetofObjects: Instantiated and prepped instance of 'setOfObjects' class
epsilon: Determines maximum object size that can be extracted. Smaller epsilons
reduce run time. (float)
"""
row = [SetOfObjects.data[point_index,:]]
indices = np.argsort(row)
distances = np.sort(row)
if scipy.iterable(distances):
unprocessed = indices[(SetOfObjects._processed[indices] < 1)[0].T]
rdistances = scipy.maximum(distances[(SetOfObjects._processed[indices] < 1)[0].T],
SetOfObjects._core_dist[point_index])
SetOfObjects._reachability[unprocessed] = scipy.minimum(
SetOfObjects._reachability[unprocessed], rdistances)
if unprocessed.size > 0:
return unprocessed[np.argsort(np.array(SetOfObjects._reachability[
unprocessed]))[0]]
else:
return point_index
else:
return point_index
示例15: my_logloss
# 需要导入模块: import scipy [as 别名]
# 或者: from scipy import maximum [as 别名]
def my_logloss(act, pred):
epsilon = 1e-15
pred = K.maximum(epsilon, pred)
pred = K.minimum(1 - epsilon, pred)
ll = K.sum(act * K.log(pred) + (1 - act) * K.log(1 - pred))
ll = ll * -1.0 / K.shape(act)[0]
return ll