# 加载所需的函数

import pandas as pd

import numpy as np

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.ensemble import RandomForestClassifier

data = pd.read_csv('data/phone.csv')  # 读取数据

# 处理异常值

phone_data1 = data[data['m_dep'] > 0]  # 处理手机厚度异常值

phone_data = phone_data1.drop(['price_range'],axis = 1)

phone_target = phone_data1['price_range']

# 将数据划分为训练集测试集

phone_data_train, phone_data_test, \

phone_target_train, phone_target_test = train_test_split(phone_data, 

                                                           phone_target, 

                                                           test_size = 0.3, 

                                                           random_state = 22)

# 数据标准化

stdScaler = StandardScaler().fit(phone_data_train)

phone_trainStd = stdScaler.transform(phone_data_train)

phone_testStd = stdScaler.transform(phone_data_test)

# 建立 RandomForestClassifier 模型 (随机森林)

rfc = RandomForestClassifier().fit(phone_trainStd, phone_target_train)

print('建立的 rfc 模型为：\n', rfc)

# 预测训练集结果

phone_target_pred = rfc.predict(phone_testStd)

print('预测的前 20 个结果为：\n', phone_target_pred[:20])

# 计算准确率

true = np.sum(phone_target_pred == phone_target_test)  # 求出预测和真实一样的数目

print('预测对的结果数目为：', true)

print('预测错的的结果数目为：', phone_target_test.shape[0] - true)

print('预测结果准确率为：', true / phone_target_test.shape[0])

import pandas as pd

# 读取数据集

diamond = pd.read_csv('data/diamond_price.csv', encoding='gbk')

#预处理

diamond = diamond.drop(diamond[(diamond['X(length)'] == 0) |

                              (diamond['Y(width)'] == 0) |

                              (diamond['Z(Depth)'] == 0)].index)

diamond.reset_index(inplace=True, drop=True)

diamond['price_RMB'] =  diamond['Price(in US dollars)'] * 6.50

print(diamond.shape)

# 拆分数据和标签

diamond_data = diamond.iloc[:, :-2]

diamond_target = diamond.iloc[:, -1]

# 特征列选择

# from  sklearn.linear_model import  Lasso

# data_train = (diamond_data-diamond_data.mean())/diamond_data.std()

# lasso = Lasso(alpha=1000).fit(data_train,diamond_target)

# print(lasso.coef_)

# diamond_data = diamond.iloc[:, [0,1,2,3]]

# 划分训练集和测试集

from sklearn.model_selection import train_test_split

diamond_data_train, diamond_data_test, \

diamond_target_train, diamond_target_test = \

train_test_split(diamond_data, diamond_target, test_size=0.2,random_state=2)

#

# # 标准差标准化

from sklearn.preprocessing import StandardScaler

stdScale = StandardScaler().fit(diamond_data_train,diamond_target_train)

diamond_trainScaler = stdScale.transform(diamond_data_train)

diamond_testScaler = stdScale.transform(diamond_data_test)

#定义评价函数

from sklearn.metrics import explained_variance_score,  r2_score

def test(y0,y1):

    print('回归模型的可解释方差值为：',

          explained_variance_score(y0,y1))

    print('回归模型的R方值为：',

          r2_score(y0, y1))

# 构建回归模型

from sklearn.svm import LinearSVR

# 支持向量回归

SVR_diamond = LinearSVR().fit(diamond_data_train, diamond_target_train)

y_pred1 = SVR_diamond.predict(diamond_data_test)

print("支持向量回归:")

test(diamond_target_test, y_pred1)

#梯度提升回归

from sklearn.ensemble import  GradientBoostingRegressor

GBR_diamond = GradientBoostingRegressor().fit(diamond_trainScaler, diamond_target_train)

y_pred2 = GBR_diamond.predict(diamond_testScaler)

print("梯度提升回归:")

test(diamond_target_test, y_pred2)

#回归决策树

from sklearn.tree import  DecisionTreeRegressor

DTR_diamond =  DecisionTreeRegressor().fit(diamond_trainScaler, diamond_target_train)

y_pred3 = DTR_diamond .predict(diamond_testScaler)

print("回归决策树:")

test(diamond_target_test, y_pred3)

#线性回归

from sklearn.linear_model import LinearRegression

LR_diamond =   LinearRegression().fit(diamond_trainScaler, diamond_target_train)

y_pred4 = LR_diamond .predict(diamond_testScaler)

print("线性回归:")

test(diamond_target_test, y_pred4)

#最近邻回归

from sklearn.neighbors import  KNeighborsRegressor

KNR_diamond =  KNeighborsRegressor().fit(diamond_trainScaler, diamond_target_train)

y_pred5 = DTR_diamond .predict(diamond_testScaler)

print("最近邻回归:")

test(diamond_target_test, y_pred5)