├── LSTM_Arima_MovingAverage.ipynb ├── README.md ├── ge.us.txt └── svr_regression.ipynb /README.md: -------------------------------------------------------------------------------- 1 | Print:("Hello World!") 2 | It's jjk333ee here 3 | Crypto is the way to freedom! 4 | 5 | 6 | Let‘s see whether we can expand this model to crypto project 7 | -------------------------------------------------------------------------------- /svr_regression.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 42, 6 | "metadata": { 7 | "scrolled": true 8 | }, 9 | "outputs": [ 10 | { 11 | "name": "stderr", 12 | "output_type": "stream", 13 | "text": [ 14 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 15 | " y = column_or_1d(y, warn=True)\n", 16 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 17 | " y = column_or_1d(y, warn=True)\n", 18 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 19 | " y = column_or_1d(y, warn=True)\n", 20 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 21 | " y = column_or_1d(y, warn=True)\n", 22 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 23 | " y = column_or_1d(y, warn=True)\n", 24 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 25 | " y = column_or_1d(y, warn=True)\n", 26 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 27 | " y = column_or_1d(y, warn=True)\n", 28 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 29 | " y = column_or_1d(y, warn=True)\n", 30 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/svm/base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n", 31 | " \"avoid this warning.\", FutureWarning)\n", 32 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 33 | " y = column_or_1d(y, warn=True)\n", 34 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/svm/base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n", 35 | " \"avoid this warning.\", FutureWarning)\n", 36 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 37 | " y = column_or_1d(y, warn=True)\n", 38 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/svm/base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n", 39 | " \"avoid this warning.\", FutureWarning)\n", 40 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 41 | " y = column_or_1d(y, warn=True)\n", 42 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/svm/base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n", 43 | " \"avoid this warning.\", FutureWarning)\n", 44 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 45 | " y = column_or_1d(y, warn=True)\n", 46 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/svm/base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n", 47 | " \"avoid this warning.\", FutureWarning)\n", 48 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 49 | " y = column_or_1d(y, warn=True)\n", 50 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/svm/base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n", 51 | " \"avoid this warning.\", FutureWarning)\n", 52 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py:724: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 53 | " y = column_or_1d(y, warn=True)\n", 54 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/svm/base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n", 55 | " \"avoid this warning.\", FutureWarning)\n", 56 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/ensemble/gradient_boosting.py:1450: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 57 | " y = column_or_1d(y, warn=True)\n", 58 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/ensemble/gradient_boosting.py:1450: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 59 | " y = column_or_1d(y, warn=True)\n", 60 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/ensemble/gradient_boosting.py:1450: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 61 | " y = column_or_1d(y, warn=True)\n", 62 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/ensemble/gradient_boosting.py:1450: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 63 | " y = column_or_1d(y, warn=True)\n", 64 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/ensemble/gradient_boosting.py:1450: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 65 | " y = column_or_1d(y, warn=True)\n", 66 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/ensemble/gradient_boosting.py:1450: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 67 | " y = column_or_1d(y, warn=True)\n", 68 | "/Users/lizhihao/anaconda3/lib/python3.7/site-packages/sklearn/ensemble/gradient_boosting.py:1450: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n", 69 | " y = column_or_1d(y, warn=True)\n" 70 | ] 71 | }, 72 | { 73 | "name": "stdout", 74 | "output_type": "stream", 75 | "text": [ 76 | "samples: 14058 \t features: 1\n", 77 | "----------------------------------------------------------------------\n", 78 | "cross validation result:\n", 79 | " 0 1 2 3 4 \\\n", 80 | "BayesianRidge -5088.939529 -400.942678 -57.027087 -0.010606 -6.774934 \n", 81 | "LinearRegression -5089.754514 -400.877189 -57.025838 -0.010613 -6.774860 \n", 82 | "ElasticNet -5089.489002 -400.895754 -57.026237 -0.010611 -6.774932 \n", 83 | "SVR -2987.484175 -2111.091374 -27.674393 -1.274340 -20.558920 \n", 84 | "GBR -6.052309 -0.316243 -0.407349 -1.855661 -0.492361 \n", 85 | "\n", 86 | " 5 \n", 87 | "BayesianRidge -1.360952 \n", 88 | "LinearRegression -1.361200 \n", 89 | "ElasticNet -1.361111 \n", 90 | "SVR -7.933533 \n", 91 | "GBR -0.234635 \n", 92 | "----------------------------------------------------------------------\n", 93 | "regression metrics:\n", 94 | " ev mae mse r2\n", 95 | "BayesianRidge 0.637761 5.558399 49.954678 0.637761\n", 96 | "LinearRegression 0.637761 5.558427 49.954678 0.637761\n", 97 | "ElasticNet 0.637761 5.558416 49.954678 0.637761\n", 98 | "SVR 0.196175 7.775110 153.434929 -0.112611\n", 99 | "GBR 0.997125 0.325981 0.396448 0.997125\n", 100 | "----------------------------------------------------------------------\n", 101 | "short name \t full name\n", 102 | "ev \t explained_variance\n", 103 | "mae \t mean_absolute_error\n", 104 | "mse \t mean_squared_error\n", 105 | "r2 \t r2\n", 106 | "----------------------------------------------------------------------\n" 107 | ] 108 | }, 109 | { 110 | "data": { 111 | "image/png": "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\n", 112 | "text/plain": [ 113 | "
" 114 | ] 115 | }, 116 | "metadata": { 117 | "needs_background": "light" 118 | }, 119 | "output_type": "display_data" 120 | } 121 | ], 122 | "source": [ 123 | "# 导入库\n", 124 | "import numpy as np # numpy库\n", 125 | "from sklearn.linear_model import BayesianRidge, LinearRegression, ElasticNet # 批量导入要实现的回归算法\n", 126 | "from sklearn.svm import SVR # SVM中的回归算法\n", 127 | "from sklearn.ensemble.gradient_boosting import GradientBoostingRegressor # 集成算法\n", 128 | "from sklearn.model_selection import cross_val_score # 交叉检验\n", 129 | "from sklearn.metrics import explained_variance_score, mean_absolute_error, mean_squared_error, r2_score # 批量导入指标算法\n", 130 | "import pandas as pd # 导入pandas\n", 131 | "import matplotlib.pyplot as plt # 导入图形展示库\n", 132 | "# 数据准备\n", 133 | "\n", 134 | "df = np.loadtxt('ge.us.txt', delimiter = \",\" , usecols=(0) , dtype='datetime64[us]') # 读取数据文件\n", 135 | "df_2 = np.loadtxt('ge.us.txt', delimiter = \",\" , usecols=(4) , dtype=float)\n", 136 | "#df = df.drop(['Open','High','Low','Volume','OpenInt'],axis=1)\n", 137 | "#df = df.fillna(df.bfill())\n", 138 | "#df['Date'] = pd.to_datetime(df.Date,format='%Y-%m-%d')\n", 139 | "#df.index = df['Date']\n", 140 | "raw_data = df\n", 141 | "# 分割自变量\n", 142 | "x = df\n", 143 | "y = df_2 # 分割因变量\n", 144 | "x = x.reshape(-1,1)\n", 145 | "y = y.reshape(-1,1)\n", 146 | "x = x.astype('datetime64[D]').astype(float)\n", 147 | "\n", 148 | "\n", 149 | "# 训练回归模型\n", 150 | "n_folds = 6 # 设置交叉检验的次数\n", 151 | "model_br = BayesianRidge() # 建立贝叶斯岭回归模型对象\n", 152 | "model_lr = LinearRegression() # 建立普通线性回归模型对象\n", 153 | "model_etc = ElasticNet() # 建立弹性网络回归模型对象\n", 154 | "model_svr = SVR() # 建立支持向量机回归模型对象\n", 155 | "model_gbr = GradientBoostingRegressor() # 建立梯度增强回归模型对象\n", 156 | "model_names = ['BayesianRidge', 'LinearRegression', 'ElasticNet', 'SVR', 'GBR'] # 不同模型的名称列表\n", 157 | "model_dic = [model_br, model_lr, model_etc, model_svr, model_gbr] # 不同回归模型对象的集合\n", 158 | "cv_score_list = [] # 交叉检验结果列表\n", 159 | "pre_y_list = [] # 各个回归模型预测的y值列表\n", 160 | "for model in model_dic: # 读出每个回归模型对象\n", 161 | " scores = cross_val_score(model, x, y, cv=n_folds) # 将每个回归模型导入交叉检验模型中做训练检验\n", 162 | " cv_score_list.append(scores) # 将交叉检验结果存入结果列表\n", 163 | " pre_y_list.append(model.fit(x, y).predict(x)) # 将回归训练中得到的预测y存入列表\n", 164 | "# 模型效果指标评估\n", 165 | "n_samples, n_features = x.shape # 总样本量,总特征数\n", 166 | "model_metrics_name = [explained_variance_score, mean_absolute_error, mean_squared_error, r2_score] # 回归评估指标对象集\n", 167 | "model_metrics_list = [] # 回归评估指标列表\n", 168 | "for i in range(5): # 循环每个模型索引\n", 169 | " tmp_list = [] # 每个内循环的临时结果列表\n", 170 | " for m in model_metrics_name: # 循环每个指标对象\n", 171 | " tmp_score = m(y, pre_y_list[i]) # 计算每个回归指标结果\n", 172 | " tmp_list.append(tmp_score) # 将结果存入每个内循环的临时结果列表\n", 173 | " model_metrics_list.append(tmp_list) # 将结果存入回归评估指标列表\n", 174 | "df1 = pd.DataFrame(cv_score_list, index=model_names) # 建立交叉检验的数据框\n", 175 | "df2 = pd.DataFrame(model_metrics_list, index=model_names, columns=['ev', 'mae', 'mse', 'r2']) # 建立回归指标的数据框\n", 176 | "print ('samples: %d \\t features: %d' % (n_samples, n_features)) # 打印输出样本量和特征数量\n", 177 | "print (70 * '-') # 打印分隔线\n", 178 | "print ('cross validation result:') # 打印输出标题\n", 179 | "print (df1) # 打印输出交叉检验的数据框\n", 180 | "print (70 * '-') # 打印分隔线\n", 181 | "print ('regression metrics:') # 打印输出标题\n", 182 | "print (df2) # 打印输出回归指标的数据框\n", 183 | "print (70 * '-') # 打印分隔线\n", 184 | "print ('short name \\t full name') # 打印输出缩写和全名标题\n", 185 | "print ('ev \\t explained_variance')\n", 186 | "print ('mae \\t mean_absolute_error')\n", 187 | "print ('mse \\t mean_squared_error')\n", 188 | "print ('r2 \\t r2')\n", 189 | "print (70 * '-') # 打印分隔线\n", 190 | "# 模型效果可视化\n", 191 | "plt.figure() # 创建画布\n", 192 | "plt.plot(np.arange(x.shape[0]), y, color='k', label='true y') # 画出原始值的曲线\n", 193 | "color_list = ['r', 'b', 'g', 'y', 'c'] # 颜色列表\n", 194 | "linestyle_list = ['-', '.', 'o', 'v', '*'] # 样式列表\n", 195 | "for i, pre_y in enumerate(pre_y_list): # 读出通过回归模型预测得到的索引及结果\n", 196 | " plt.plot(np.arange(x.shape[0]), pre_y_list[i], color_list[i], label=model_names[i]) # 画出每条预测结果线\n", 197 | "plt.title('regression result comparison') # 标题\n", 198 | "plt.legend(loc='upper right') # 图例位置\n", 199 | "plt.ylabel('real and predicted value') # y轴标题\n", 200 | "plt.show() # 展示图像\n", 201 | "# 模型应用\n", 202 | "#print ('regression prediction')\n", 203 | "#new_point_set = [[1.05393, 0., 8.14, 0., 0.538, 5.935, 29.3, 4.4986, 4., 307., 21., 386.85, 6.58],\n", 204 | " #[0.7842, 0., 8.14, 0., 0.538, 5.99, 81.7, 4.2579, 4., 307., 21., 386.75, 14.67],\n", 205 | " #[0.80271, 0., 8.14, 0., 0.538, 5.456, 36.6, 3.7965, 4., 307., 21., 288.99, 11.69],\n", 206 | " #[0.7258, 0., 8.14, 0., 0.538, 5.727, 69.5, 3.7965, 4., 307., 21., 390.95, 11.28]] # 要预测的新数据集\n", 207 | "#for i, new_point in enumerate(new_point_set): # 循环读出每个要预测的数据点\n", 208 | " #new_pre_y = model_gbr.predict(new_point) # 使用GBR进行预测\n", 209 | " #print ('predict for new point %d is: %.2f' % (i + 1, new_pre_y)) # 打印输出每个数据点的预测信息" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": 38, 215 | "metadata": {}, 216 | "outputs": [ 217 | { 218 | "name": "stdout", 219 | "output_type": "stream", 220 | "text": [ 221 | "(14058, 1)\n", 222 | "(14058, 1)\n" 223 | ] 224 | } 225 | ], 226 | "source": [ 227 | "import numpy as np # numpy库\n", 228 | "import pandas as pd # 导入pandas\n", 229 | "\n", 230 | "df = np.loadtxt('ge.us.txt', delimiter = \",\" , usecols=(0) , dtype='datetime64[us]') \n", 231 | "df_2 = np.loadtxt('ge.us.txt', delimiter = \",\" , usecols=(4) , dtype=float)\n", 232 | "\n", 233 | "x = df\n", 234 | "y = df_2\n", 235 | "\n", 236 | "x = x.reshape(-1,1)\n", 237 | "y = y.reshape(-1,1)\n", 238 | "\n", 239 | "print(x.shape)\n", 240 | "print(y.shape)" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": null, 246 | "metadata": {}, 247 | "outputs": [], 248 | "source": [] 249 | }, 250 | { 251 | "cell_type": "code", 252 | "execution_count": null, 253 | "metadata": {}, 254 | "outputs": [], 255 | "source": [] 256 | } 257 | ], 258 | "metadata": { 259 | "kernelspec": { 260 | "display_name": "Python 3", 261 | "language": "python", 262 | "name": "python3" 263 | }, 264 | "language_info": { 265 | "codemirror_mode": { 266 | "name": "ipython", 267 | "version": 3 268 | }, 269 | "file_extension": ".py", 270 | "mimetype": "text/x-python", 271 | "name": "python", 272 | "nbconvert_exporter": "python", 273 | "pygments_lexer": "ipython3", 274 | "version": "3.7.3" 275 | } 276 | }, 277 | "nbformat": 4, 278 | "nbformat_minor": 2 279 | } 280 | --------------------------------------------------------------------------------