def _isotonic_regression_train(table, feature_col, label_col, increasing=True):
if feature_col == label_col:
raise BFE.from_errors([{
'0100':
'{} is deplicate in Feature column and Label column'.format(
feature_col)
}])
features = table[feature_col]
label = table[label_col]
isotonic_model = IsotonicRegression(increasing=increasing)
isotonic_model.fit(features, label)
predict = isotonic_model.predict(features)
plt.figure()
plt.plot(label, 'r.-')
plt.plot(predict, 'b.-')
plt.xlabel('Samples')
plt.legend(['True label', 'Predicted'])
fig_actual_predict = plt2MD(plt)
get_param = isotonic_model.get_params()
rb = BrtcReprBuilder()
rb.addMD(
strip_margin("""
| ## Linear Regression Result
| ### Param
| {param}
| ### Predicted vs Actual
| {image1}
""".format(image1=fig_actual_predict, param=get_param)))
model = _model_dict('isotonic_regression_model')
model['_repr_brtc_'] = rb.get()
model['feature_col'] = feature_col
model['label_col'] = label_col
model['parameters'] = get_param
model['regressor'] = isotonic_model
return {"model": model}
def IsotonicRegression_pred(y_train, predictions_train, test_preds, bin_step, y_test):
# Y Training Target sort the y_test
# X Training Data use the indexes of sorted(y_test)
# y_train_len=len(y_train)
# if bin_step<1:
# step_count = 1/bin_step
# else:
# step_count = int(math.floor(y_train_len/bin_step))
# step_element_count = int(math.floor(y_train_len/step_count))
# bin_start_indexes=np.array(range(0,step_count))*step_element_count
predictions_np = np.array(predictions_train, float)
predictions_sorted = np.sort(predictions_np)
predictions_sorted_indexes = predictions_np.argsort()
y_train_arranged = np.array(y_train, float)[predictions_sorted_indexes].ravel()
# not_binned_y_train_arranged = y_train_arranged[:]
# for index in range(len(bin_start_indexes)-1):
# pin = bin_start_indexes[index]
# pend = bin_start_indexes[index+1]
# y_train_arranged[pin:pend] = np.average(y_train_arranged[pin:pend])
# if bin_start_indexes[-1]<y_train_len:
# pin = bin_start_indexes[-1]
# pend = y_train_len
# y_train_arranged[pin:pend] = np.average(y_train_arranged[pin:pend])
ir = IsotonicRegression()
y_ir = ir.fit_transform(predictions_sorted, y_train_arranged)
y_ir_pred = ir.predict(predictions_sorted)
# print "min(y_train_arranged) :", min(y_train_arranged)
# print "max(y_train_arranged) :", max(y_train_arranged)
# print "min(predictions_sorted) :", min(predictions_sorted)
# print "max(predictions_sorted) :", max(predictions_sorted)
# print "min(test_preds) :", min(test_preds)
# print "max(test_preds) :", max(test_preds)
# if max(test_preds)>=max(y_train_arranged):
# np.arrya(test_preds>max(y_train_arranged))==True
max_indexes = np.array((np.where(test_preds > max(y_train_arranged))), int).ravel()
if len(max_indexes) != 0:
for m_i in max_indexes:
test_preds[m_i] = max(y_train_arranged)
test_preds_sorted = np.sort(np.array(test_preds))
predictions_ir = ir.predict(test_preds)
ind = np.where(np.isnan(predictions_ir))[0]
preds_test_min = np.nanmin(predictions_ir)
if len(ind) != 0:
for i in ind:
predictions_ir[i] = preds_test_min
# ==============WRITING TO CSV================
# d_train={'y_train' :np.array(y_train,float)[predictions_sorted_indexes].ravel(),
# 'y_train_bin' :np.array(y_train_arranged).ravel(),
# 'train_preds' :np.array(predictions_sorted).ravel(),
# 'train_preds_ir' :y_ir}
# df_train=pd.DataFrame(d_train)
# df_train.to_csv("train_IR.csv")
# d_test={'y_test' :np.array(y_test).ravel(),
# 'test_preds' :np.array(test_preds).ravel(),
# 'test_preds_ir' :predictions_ir}
# df_test=pd.DataFrame(d_test)
# df_test.to_csv("test_IR.csv")
# score_test_ir=ir.score(test_preds,y_test)
score_test_ir = 0
return predictions_ir, y_ir_pred, ir.get_params(deep=True), score_test_ir
dsim['disp'] = dsim['disp'] * (-1)
dsim.head()
#Convert df to numpy array
dsim_x = np.asarray(dsim['disp'])
dsim_y = np.asarray(dsim['mpg'])
#View scatter plot of x and mpg
plt.scatter(dsim['disp'], dsim['mpg'])
plt.xlabel('disp')
plt.ylabel('mpg')
plt.title('Scatterplot of x and y')
plt.show()
#Fit isotonic regression
iso_reg = IsotonicRegression()
print(iso_reg.get_params())
iso_fitted_values = iso_reg.fit_transform(dsim_x, dsim_y)
iso_predictions = iso_reg.predict(dsim_x)
print('R squared:', iso_reg.score(dsim_x, dsim_y))
#Plot the fitted line
order = dsim['disp'].sort_values().index.tolist()
plt.scatter(dsim['disp'], dsim['mpg'])
plt.plot(dsim['disp'][order], iso_fitted_values[order], color='brown')
plt.xlabel('disp')
plt.ylabel('mpg')
plt.title('Isotonic Regression')
plt.show()
'''
-------------------------------------------------------------------------------
--------------------------------Smoothing--------------------------------------
