Python源码示例：sklearn.metrics.median_absolute_error()
示例1
def test_regression_metrics_at_limits():
assert_almost_equal(mean_squared_error([0.], [0.]), 0.00, 2)
assert_almost_equal(mean_squared_log_error([0.], [0.]), 0.00, 2)
assert_almost_equal(mean_absolute_error([0.], [0.]), 0.00, 2)
assert_almost_equal(median_absolute_error([0.], [0.]), 0.00, 2)
assert_almost_equal(max_error([0.], [0.]), 0.00, 2)
assert_almost_equal(explained_variance_score([0.], [0.]), 1.00, 2)
assert_almost_equal(r2_score([0., 1], [0., 1]), 1.00, 2)
assert_raises_regex(ValueError, "Mean Squared Logarithmic Error cannot be "
"used when targets contain negative values.",
mean_squared_log_error, [-1.], [-1.])
assert_raises_regex(ValueError, "Mean Squared Logarithmic Error cannot be "
"used when targets contain negative values.",
mean_squared_log_error, [1., 2., 3.], [1., -2., 3.])
assert_raises_regex(ValueError, "Mean Squared Logarithmic Error cannot be "
"used when targets contain negative values.",
mean_squared_log_error, [1., -2., 3.], [1., 2., 3.])
示例2
def mae_cv(self, cv):
"""
This method performs cross-validation over median absolute error.
Parameters
----------
* cv : integer
The number of cross validation folds to perform
Returns
-------
Returns a scores of the k-fold median absolute error.
"""
mae = metrics.make_scorer(metrics.median_absolute_error)
result = cross_validate(self.reg, self.X,
self.y, cv=cv,
scoring=(mae))
return self.get_test_score(result)
示例3
def print_evaluation_metrics(trained_model, trained_model_name, X_test, y_test):
print('--------- For Model: ', trained_model_name, ' ---------\n')
predicted_values = trained_model.predict(X_test)
print("Mean absolute error: ",
metrics.mean_absolute_error(y_test, predicted_values))
print("Median absolute error: ",
metrics.median_absolute_error(y_test, predicted_values))
print("Mean squared error: ", metrics.mean_squared_error(
y_test, predicted_values))
print("R2: ", metrics.r2_score(y_test, predicted_values))
plt.scatter(y_test, predicted_values, color='black')
# plt.plot(x, y_pred, color='blue', linewidth=3)
plt.title(trained_model_name)
plt.xlabel('$y_{test}$')
plt.ylabel('$y_{predicted}/y_{test}$')
plt.savefig('%s.png' %trained_model_name, bbox_inches='tight')
print("---------------------------------------\n")
示例4
def print_evaluation_metrics2(trained_model, trained_model_name, X_test, y_test):
print('--------- For Model: ', trained_model_name, ' --------- (Train Data)\n')
predicted_values = trained_model.predict(X_test)
print("Mean absolute error: ",
metrics.mean_absolute_error(y_test, predicted_values))
print("Median absolute error: ",
metrics.median_absolute_error(y_test, predicted_values))
print("Mean squared error: ", metrics.mean_squared_error(
y_test, predicted_values))
print("R2: ", metrics.r2_score(y_test, predicted_values))
plt.scatter(y_test, predicted_values/y_test, color='black')
# plt.plot(x, y_pred, color='blue', linewidth=3)
plt_name = trained_model_name + " (Train Data)"
plt.title(plt_name)
plt.xlabel('$y_{test}$')
plt.ylabel('$y_{predicted}/y_{test}$')
plt.savefig('%s.png' %plt_name, bbox_inches='tight')
print("---------------------------------------\n")
示例5
def eval_metrics_on(predictions, labels):
'''
assuming this is a regression task; labels are continuous-valued floats
returns most regression-related scores for the given predictions/targets as a dictionary:
r2, mean_abs_error, mse, rmse, median_absolute_error, explained_variance_score
'''
if len(labels[0])==2: #labels is list of data/labels pairs
labels = np.concatenate([l[1] for l in labels])
predictions = predictions[:,0]
r2 = metrics.r2_score(labels, predictions)
mean_abs_error = np.abs(predictions - labels).mean()
mse = ((predictions - labels)**2).mean()
rmse = np.sqrt(mse)
median_absolute_error = metrics.median_absolute_error(labels, predictions) # robust to outliers
explained_variance_score = metrics.explained_variance_score(labels, predictions) # best score = 1, lower is worse
return {'r2':r2, 'mean_abs_error':mean_abs_error, 'mse':mse, 'rmse':rmse,
'median_absolute_error':median_absolute_error,
'explained_variance_score':explained_variance_score}
示例6
def test_corrupted_regression(loss, weighting):
reg = RobustWeightedEstimator(
SGDRegressor(),
loss=loss,
max_iter=50,
weighting=weighting,
k=4,
c=None,
random_state=rng,
)
reg.fit(X_rc, y_rc)
score = median_absolute_error(reg.predict(X_rc), y_rc)
assert score < 0.2
示例7
def test_regression_metrics(n_samples=50):
y_true = np.arange(n_samples)
y_pred = y_true + 1
assert_almost_equal(mean_squared_error(y_true, y_pred), 1.)
assert_almost_equal(mean_squared_log_error(y_true, y_pred),
mean_squared_error(np.log(1 + y_true),
np.log(1 + y_pred)))
assert_almost_equal(mean_absolute_error(y_true, y_pred), 1.)
assert_almost_equal(median_absolute_error(y_true, y_pred), 1.)
assert_almost_equal(max_error(y_true, y_pred), 1.)
assert_almost_equal(r2_score(y_true, y_pred), 0.995, 2)
assert_almost_equal(explained_variance_score(y_true, y_pred), 1.)
示例8
def score(self,
actual: np.array,
predicted: np.array,
sample_weight: typing.Optional[np.array] = None,
labels: typing.Optional[np.array] = None,
**kwargs) -> float:
return median_absolute_error(actual, predicted)
示例9
def mae_upper_boundary(self, upper_boundary):
y_pred = self.reg.predict(self.X)
if metrics.median_absolute_error(self.y, y_pred) > upper_boundary:
return False
return True
示例10
def cross_val_mae_result(self, reg, cv=3):
y_pred = cross_val_predict(reg, self.X, self.y)
return metrics.median_absolute_error(self.y, y_pred)
示例11
def mae_result(self, reg):
y_pred = reg.predict(self.X)
return metrics.median_absolute_error(self.y, y_pred)
示例12
def mae_upper_boundary(upper_boundary):
y_pred = self.reg.predict(self.X)
if metrics.median_absolute_error(self.y, y_pred) > upper_boundary:
return False
return True
示例13
def compute(labels, pred_scores):
return median_absolute_error(labels, pred_scores)
示例14
def gini_meae(truth, predictions):
score = median_absolute_error(truth, predictions)
return score
示例15
def gini_meae(truth, predictions):
score = median_absolute_error(truth, predictions)
return score
示例16
def print_evaluation_metrics(trained_model, trained_model_name, X_test, y_test):
print('--------- For Model: ', trained_model_name, ' ---------\n')
predicted_values = trained_model.predict(X_test)
print("Mean absolute error: ",
metrics.mean_absolute_error(y_test, predicted_values))
print("Median absolute error: ",
metrics.median_absolute_error(y_test, predicted_values))
print("Mean squared error: ", metrics.mean_squared_error(
y_test, predicted_values))
print("R2: ", metrics.r2_score(y_test, predicted_values))
示例17
def print_evaluation_metrics2(trained_model, trained_model_name, X_test, y_test):
print('--------- For Model: ', trained_model_name, ' --------- (Train Data)\n')
predicted_values = trained_model.predict(X_test)
print("Mean absolute error: ",
metrics.mean_absolute_error(y_test, predicted_values))
print("Median absolute error: ",
metrics.median_absolute_error(y_test, predicted_values))
print("Mean squared error: ", metrics.mean_squared_error(
y_test, predicted_values))
print("R2: ", metrics.r2_score(y_test, predicted_values))
示例18
def _score_median_absolute_error(self):
return median_absolute_error(self._y_test, self._y_predicted)
示例19
def test_regression_metrics(n_samples=50):
y_true = np.arange(n_samples)
y_pred = y_true + 1
assert_almost_equal(mean_squared_error(y_true, y_pred), 1.)
assert_almost_equal(mean_squared_log_error(y_true, y_pred),
mean_squared_error(np.log(1 + y_true),
np.log(1 + y_pred)))
assert_almost_equal(mean_absolute_error(y_true, y_pred), 1.)
assert_almost_equal(median_absolute_error(y_true, y_pred), 1.)
assert_almost_equal(r2_score(y_true, y_pred), 0.995, 2)
assert_almost_equal(explained_variance_score(y_true, y_pred), 1.)
示例20
def test_regression_metrics_at_limits():
assert_almost_equal(mean_squared_error([0.], [0.]), 0.00, 2)
assert_almost_equal(mean_squared_log_error([0.], [0.]), 0.00, 2)
assert_almost_equal(mean_absolute_error([0.], [0.]), 0.00, 2)
assert_almost_equal(median_absolute_error([0.], [0.]), 0.00, 2)
assert_almost_equal(explained_variance_score([0.], [0.]), 1.00, 2)
assert_almost_equal(r2_score([0., 1], [0., 1]), 1.00, 2)
assert_raises_regex(ValueError, "Mean Squared Logarithmic Error cannot be "
"used when targets contain negative values.",
mean_squared_log_error, [-1.], [-1.])
示例21
def kmeans(X_train, y_train, X_val, y_val):
n_clusters = 8
kmeans = KMeans(n_clusters=n_clusters, random_state=0, verbose=0, n_jobs=int(0.8*n_cores)).fit(X_train)
c_train = kmeans.predict(X_train)
c_pred = kmeans.predict(X_val)
centroids = kmeans.cluster_centers_
y_val_stats = None
predicted_values = None
y_train_stats = None
labels_stats = None
for i in range(n_clusters):
print('--------analyzing cluster %d--------' %i)
train_mask = c_train==i
std_train = np.std(y_train[train_mask])
mean_train = np.mean(y_train[train_mask])
print("# examples & price mean & std for training set within cluster %d is:(%d, %.2f, %.2f)" %(i, train_mask.sum(), np.float(mean_train), np.float(std_train)))
pred_mask = c_pred==i
std_pred = np.std(y_val[pred_mask])
mean_pred = np.mean(y_val[pred_mask])
print("# examples & price mean & std for validation set within cluster %d is:(%d, %.2f, %.2f)" %(i, pred_mask.sum(), np.float(mean_pred), np.float(std_pred)))
if pred_mask.sum() == 0:
print('Zero membered test set! Skipping the test and training validation.')
continue
#LinearModelRidge(X_train[train_mask], y_train[train_mask], X_val[pred_mask], y_val[pred_mask])
regr = Ridge(alpha = 7) #7
regr.fit(X_train[train_mask], y_train[train_mask])
labels_pred = regr.predict(X_train[train_mask].values)
y_pred = regr.predict(X_val[pred_mask].values)
if (y_val_stats is None):
y_val_stats = copy.deepcopy(y_val[pred_mask])
y_train_stats = copy.deepcopy(y_train[train_mask])
predicted_values = copy.deepcopy(y_pred)
labels_stats = copy.deepcopy(labels_pred)
else:
y_val_stats = y_val_stats.append(y_val[pred_mask])
y_train_stats = y_train_stats.append(y_train[train_mask])
predicted_values = np.append(predicted_values, y_pred)
labels_stats = np.append(labels_stats, labels_pred)
print('--------Finished analyzing cluster %d--------' %i)
print("Mean absolute error: ",
metrics.mean_absolute_error(y_val_stats, predicted_values))
print("Median absolute error: ",
metrics.median_absolute_error(y_val_stats, predicted_values))
print("Mean squared error: ", metrics.mean_squared_error(
y_val_stats, predicted_values))
print("R2: ", metrics.r2_score(y_val_stats, predicted_values))
print('------------TRAIN--------------------')
print("Mean absolute error: ",
metrics.mean_absolute_error(y_train_stats, labels_stats))
print("Median absolute error: ",
metrics.median_absolute_error(y_train_stats, labels_stats))
print("Mean squared error: ", metrics.mean_squared_error(
y_train_stats, labels_stats))
print("R2: ", metrics.r2_score(y_train_stats, labels_stats))
return c_pred, centroids
示例22
def save_prediction(model, loader, dataset, args):
model.eval()
csv_writer = csv.writer(open(args.checkpoint_dir + 'prediction_' +
args.model_name + '.csv', 'w'))
csv_writer.writerow(['ingr1', 'ingr1_cate', 'ingr2', 'ingr2_cate', 'prediction', 'target'])
tar_set = []
pred_set = []
ingr2category = pickle.load(open(args.ingr2category_dir, 'rb'))
for d_idx, (d1, d1_r, d1_c, d1_l, d2, d2_r, d2_c, d2_l, score) in enumerate(loader):
# Run model for getting predictions
outputs = model(d1_r.cuda(), d1_c.cuda(), d1_l, d2_r.cuda(), d2_c.cuda(), d2_l)
predictions = outputs[2].data.cpu().numpy()
targets = score.data.tolist()
tar_set += list(targets)
pred_set += list(predictions)
for a1, a2, a3, a4 in zip(d1, d2, predictions, targets):
csv_writer.writerow([a1, ingr2category[a1], a2, ingr2category[a2], a3, a4])
# Print progress
if d_idx % args.print_step == 0 or d_idx == len(loader) - 1:
_progress = '{}/{} saving unknwon predictions..'.format(
d_idx + 1, len(loader))
LOGGER.info(_progress)
mse = mean_squared_error(tar_set, pred_set)
rmse = sqrt(mse)
mae = mean_absolute_error(tar_set, pred_set)
mae2 = median_absolute_error(tar_set, pred_set)
corr = np.corrcoef(tar_set, pred_set)[0][1]
ev = explained_variance_score(tar_set, pred_set)
r2 = r2_score(tar_set, pred_set)
LOGGER.info('Loss\tMSE\tMAE\tMAE2\tCorr\tEV\t\tR2')
LOGGER.info('{:.4f}\t{:.4f}\t{:.4f}\t{:.4f}\t{:.4f}\t{:.4f}\t{:.4f}'.format(
rmse, mse, mae, mae2, corr, ev, r2))
# Outputs pred scores for new pair dataset
