import pandas as pd
df=pd.read_csv('hs2年，季度平均财务数据.csv')
df

df.dropna(axis=0, how='any',inplace=True)
df

df.set_index('Unnamed: 0', inplace=True) # 再将 列column 改为 index
#df
df

#数据去极值及标准化 去均值 不用写常数项
def winsorize_and_standarlize(data,qrange=[0.01,0.98],axis=0):
    '''
    input:
    data:Dataframe or series,输入数据
    qrange:list,list[0]下分位数，list[1]，上分位数，极值用分位数代替
    '''
    if isinstance(data,pd.DataFrame):
        if axis == 0:
            q_down = data.quantile(qrange[0])
            q_up = data.quantile(qrange[1])
            
            index = data.index
            col = data.columns
            print('q_up上分位数',q_up)
            print('data.mean均值',data.mean(),'ok均值')
            print('price.mean()',data['mean_price'].mean())
            for n in col:
                
                
                #去掉极端值
                data[n][data[n] > q_up[n]] = q_up[n]
                data[n][data[n] < q_down[n]] = q_down[n]
                '''
                #标准化 未用
                data[n] = (data[n] - data[n].mean())/data[n].std()
                print(n,'data[n].mean()的值为',data[n].mean())
                #data[n] = data[n].fillna(0)
                '''
        else:
            data = data.stack()
            data = data.unstack(0)
            q = data.quantile(qrange)
            index = data.index
            col = data.columns
            for n in col:
                data[n][data[n] > q[n]] = q[n]
            data = (data - data.mean())/data.std()
            data = data.stack().unstack(0)
            data = data.fillna(0)
            
    elif isinstance(data,pd.Series):
        name = data.name
        q = data.quantile(qrange)
        data[data>q] = q
        data = (data - data.mean())/data.std()
        
    return data
data_pro = winsorize_and_standarlize(df)
data_pro

price = data_pro['mean_price']
data_pro.drop(labels=['mean_price'], axis=1,inplace = True)
#df.insert(0, 'close', close)
data_pro.insert( 0, 'price', price)
#close
data_pro

df=data_pro
X= df.values[:, 1:]
Y =df.values[:, 0]
X.shape  #划分 x和标签y 

import numpy as np
import matplotlib.pyplot as plt

sampleRatio=0.2               #划分训练集和测试集各一半
m=len(X)
sampleBoundary=int(m*sampleRatio)
myshuffle=list(range(m))      #注意Python3中range()返回range对象而不是数组对象，要将其转为序列
np.random.shuffle(myshuffle)  #shuffle()函数将序列内的元素全部随机排序
#分别取出训练集和测试集的数据
train_fea= X[myshuffle[sampleBoundary:]]    #前一半数据集作为训练集
train_tar= Y[myshuffle[sampleBoundary:]]

test_fea=  X[myshuffle[:sampleBoundary]]     #后一半数据作为测试集
test_tar=  Y[myshuffle[:sampleBoundary]]
train_fea.shape

from sklearn.preprocessing import StandardScaler
ss_x = StandardScaler()
ss_y = StandardScaler()

X=train_fea
y=train_tar
Xt=test_fea
yt=test_tar
X

X= ss_x.fit_transform(X)

Xt = ss_x.transform(Xt)

X

# 导入库
import numpy as np  # numpy库
from sklearn.linear_model import BayesianRidge, LinearRegression, ElasticNet  # 批量导入要实现的回归算法
from sklearn.svm import SVR  # SVM中的回归算法
from sklearn.ensemble.gradient_boosting import GradientBoostingRegressor  # 集成算法
from sklearn.model_selection import cross_val_score  # 交叉检验
from sklearn.metrics import explained_variance_score, mean_absolute_error, mean_squared_error, r2_score  # 批量导入指标算法
import pandas as pd  # 导入pandas
import matplotlib.pyplot as plt  # 导入图形展示库

from sklearn.neural_network import MLPRegressor  # 多层线性回归
# 训练回归模型
n_folds = 8  # 设置交叉检验的次数
model_br = BayesianRidge()     # 建立贝叶斯岭回归模型对象

model_lr = LinearRegression()  # 建立普通线性回归模型对象
model_etc = ElasticNet()       # 建立弹性网络回归模型对象

model_svr = SVR()              # 建立支持向量机回归模型对象

model_gbr = GradientBoostingRegressor()  # 建立梯度增强回归模型对象  ，未用

model_mlp = MLPRegressor(solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(8, 4,2), random_state=1)

      
model_names = ['BayesianRidge', 'LinearRegression', 'SVR', 'mlp']  # 不同模型的名称列表 , 'ElasticNet' 'GBR',
model_dic = [model_br, model_lr, model_svr, model_mlp]  # 不同回归模型对象的集合  , model_gbr  , model_etc
cv_score_list = []  # 交叉检验结果列表


pre_y_list = []  # 各个回归模型  预测的y值列表

for model in model_dic:  # 读出每个回归模型对象
    scores = cross_val_score(model, X, y, cv=n_folds)  # 将每个回归模型 导入交叉检验模型中  做训练检验
    cv_score_list.append(scores)                     # 将交叉检验结果存入结果列表
    
    pre_y_list.append(model.fit(X, y).predict(Xt))  # 将回归训练中 得到的预测y 存入列表  测试集合
    
# 模型效果指标评估
n_samples, n_features = X.shape  # 总样本量,总特征数
model_metrics_name = [explained_variance_score, mean_absolute_error, mean_squared_error, r2_score]  # 回归评估指标对象集
model_metrics_list = []  # 回归评估指标列表

for i in range(len(model_names)):  # 循环 每个模型索引
    
    tmp_list = []  # 每个内循环的临时结果列表
    for m in model_metrics_name:  # 循环每个指标对象
        
        tmp_score = m(yt, pre_y_list[i])  # 计算每个回归指标结果            # 测试集合
        
        tmp_list.append(tmp_score)  # 将结果存入每个内循环的临时结果列表
        
    model_metrics_list.append(tmp_list)  # 将结果存入回归评估指标列表
    
df1 = pd.DataFrame(cv_score_list, index=model_names)  # 建立交叉检验的数据框
df2 = pd.DataFrame(model_metrics_list, index=model_names, columns=['ev', 'mae', 'mse', 'r2'])  # 建立回归指标的数据框
print('ok')

print('ok')
print ('samples: %d \t features: %d' % (n_samples, n_features))  # 打印输出样本量和特征数量


print (70 * '-')  # 打印分隔线
print ('cross validation result:')  # 打印输出 标题
print (df1)  # 打印输出 交叉检验的数据框


print (70 * '-')  # 打印分隔线
print ('regression metrics:')  # 打印输出 标题
print (df2)  # 打印输出回归指标的数据框


print (70 * '-')  # 打印分隔线
print ('short name \t full name')  # 打印输出 缩写和全名标题
print ('ev \t explained_variance')
print ('mae \t mean_absolute_error')
print ('mse \t mean_squared_error')
print ('r2 \t r2')
print (70 * '-')  # 打印分隔线

# 模型效果可视化
plt.figure()  # 创建画布
plt.plot(np.arange(Xt.shape[0]), yt, color='k', label='true y')  # 画出原始值的曲线
color_list = ['r', 'b', 'y', 'c','<', 'g']  # 颜色列表
linestyle_list = ['-', '.', 'o', 'v', '*','m']  # 样式列表
#print(pre_y_list.shape())
for i, pre_y in enumerate(pre_y_list):  # 读出通过回归模型 预测得到的索引及结果
    #print(i)
    #print(len(pre_y))
   
    plt.plot(np.arange(Xt.shape[0]), pre_y_list[i], color_list[i], label=model_names[i])  # 画出每条预测结果线
    
    
plt.title('regression result comparison')  # 标题
plt.legend(loc='upper right')            # 图例位置
plt.ylabel('real and predicted value')  # y轴标题
plt.show()  # 展示图像

from sklearn import linear_model
#使用最小二乘线性回归进行拟合，导入相应的模块
lr=linear_model.LinearRegression()

lr.fit(train_fea,train_tar)  #拟合
y_pred=lr.predict(test_fea)       #得到预测值集合y
plt.scatter(y_pred,test_tar)      #画出散点图,横轴是预测值，纵轴是真实值
plt.plot([y_pred.min(), y_pred.max()], [y_pred.min(), y_pred.max()], 'b',lw=5) #直线的起点为(y.min(),y.min()),终点是(y.max(),y.max())
plt.show()

coef=lr.coef_                #获得该回该方程的回归系数与截距
intercept=lr.intercept_
print("预测方程回归系数：",coef)
print("预测方程截距：",intercept)


score=lr.score(test_fea,test_tar)    #对得到的模型打分
print("对该模型的评分是：%.5f" %score)
#--------------------- 

train_fea1= ss_x.fit_transform(train_fea)

test_fea1 = ss_x.transform(test_fea)

test_fea1 

from sklearn import linear_model
#使用最小二乘线性回归进行拟合，导入相应的模块
lr=linear_model.LinearRegression()

lr.fit(train_fea1,train_tar)  #拟合
y_pred=lr.predict(test_fea1)       #得到预测值集合y
plt.scatter(y_pred,test_tar)      #画出散点图,横轴是预测值，纵轴是真实值
plt.plot([y_pred.min(), y_pred.max()], [y_pred.min(), y_pred.max()], 'b',lw=5) #直线的起点为(y.min(),y.min()),终点是(y.max(),y.max())
plt.show()

coef=lr.coef_                #获得该回该方程的回归系数与截距
intercept=lr.intercept_
print("预测方程回归系数：",coef)
print("预测方程截距：",intercept)


score=lr.score(test_fea1,test_tar)    #对得到的模型打分
print("对该模型的评分是：%.5f" %score)
#--------------------- 

df

df.drop(labels=['price'], axis=1,inplace = True)
#df.insert(0, 'close', close)
df