如何用Python在10分钟内建立一个预测模型

1. 如何用Python在10分钟内建立一个预测模型

　　预测模型的分解过程
　　我总是集中于投入有质量的时间在建模的初始阶段，比如，假设生成、头脑风暴、讨论或理解可能的结果范围。所有这些活动都有助于我解决问题，并最终让我设计出更强大的商业解决方案。为什么你要在前面花费这段时间，这有充分的理由：
　　你有足够的时间投入并且你是无经验的（这是有影响的）
　　你不带有其它数据观点或想法的偏见（我总是建议，在深入研究数据之前做假设生成）
　　在后面的阶段，你会急于完成该项目而没有能力投入有质量的时间了。
　　这个阶段需要投入高质量时间，因此我没有提及时间表，不过我建议你把它作为标准的做法。这有助于你建立建立更好地预测模型，在后面的阶段的只需较少的迭代工作。让我们来看看建立第一个模型的剩余阶段的时间表：
　　数据描述性分析——50%的时间
　　数据预处理（缺失值和异常值修复）——40%的时间
　　数据建模——4%的时间
　　性能预测——6%的时间
　　让我们一步一步完成每个过程（每一步投入预测的时间）：
　　阶段1：描述性分析/数据探索
　　在我刚开始成为数据科学家的时候，数据探索占据了我大量的时间。不过，随着时间的推移，我已经把大量的数据操作自动化了。由于数据准备占据建立第一个模型工作量的50%，自动化的好处是显而易见的。
　　这是我们的第一个基准模型，我们去掉任何特征设计。因此，描述分析所需的时间仅限于了解缺失值和直接可见的大的特征。在我的方法体系中，你将需要2分钟来完成这一步（假设，100000个观测数据集）。
　　我的第一个模型执行的操作：
　　确定ID，输入特征和目标特征
　　确定分类和数值特征
　　识别缺失值所在列
　　阶段2：数据预处理（缺失值处理）
　　有许多方法可以解决这个问题。对于我们的第一个模型，我们将专注于智能和快速技术来建立第一个有效模型。
　　为缺失值创建假标志：有用，有时缺失值本身就携带了大量的信息。
　　用均值、中位数或其它简单方法填补缺失值：均值和中位数填补都表现良好，大多数人喜欢用均值填补但是在有偏分布的情况下我建议使用中位数。其它智能的方法与均值和中位数填补类似，使用其它相关特征填补或建立模型。比如，在Titanic生存挑战中，你可以使用乘客名字的称呼，比如：“Mr.”, “Miss.”,”Mrs.”,”Master”，来填补年龄的缺失值，这对模型性能有很好的影响。
　　填补缺失的分类变量：创建一个新的等级来填补分类变量，让所有的缺失值编码为一个单一值比如，“New_Cat”，或者，你可以看看频率组合，使用高频率的分类变量来填补缺失值。
　　由于数据处理方法如此简单，你可以只需要3到4分钟来处理数据。
　　阶段3：数据建模
　　根据不同的业务问题，我推荐使用GBM或RandomForest技术的任意一种。这两个技术可以极其有效地创建基准解决方案。我已经看到数据科学家通常把这两个方法作为他们的第一个模型同时也作为最后一个模型。这最多用去4到5分钟。
　　阶段4：性能预测
　　有各种各样的方法可以验证你的模型性能，我建议你将训练数据集划分为训练集和验证集（理想的比例是70：30）并且在70%的训练数据集上建模。现在，使用30%的验证数据集进行交叉验证并使用评价指标进行性能评估。最后需要1到2分钟执行和记录结果。
　　本文的目的不是赢得比赛，而是建立我们自己的基准。让我们用python代码来执行上面的步骤，建立你的第一个有较高影响的模型。
　　让我们开始付诸行动
　　首先我假设你已经做了所有的假设生成并且你擅长使用python的基本数据科学操作。我用一个数据科学挑战的例子来说明。让我们看一下结构：
　　步骤1：导入所需的库，读取测试和训练数据集。
　　#导入pandas、numpy包，导入LabelEncoder、random、RandomForestClassifier、GradientBoostingClassifier函数
　　import pandas as pd
　　import numpy as np
　　fromsklearn.preprocessing import LabelEncoder
　　import random
　　fromsklearn.ensemble import RandomForestClassifier
　　from sklearn.ensembleimport GradientBoostingClassifier
　　#读取训练、测试数据集
　　train=pd.read_csv('C:/Users/AnalyticsVidhya/Desktop/challenge/Train.csv')
　　test=pd.read_csv('C:/Users/AnalyticsVidhya/Desktop/challenge/Test.csv')
　　#创建训练、测试数据集标志
　　train='Train'
　　test='Test'
　　fullData =pd.concat(,axis=0) #联合训练、测试数据集
　　步骤2：该框架的第二步并不需要用到python，继续下一步。
　　步骤3：查看数据集的列名或概要
　　fullData.columns # 显示所有的列名称
　　fullData.head(10) #显示数据框的前10条记录
　　fullData.describe() #你可以使用describe()函数查看数值域的概要
　　步骤4：确定a)ID变量 b)目标变量 c)分类变量 d)数值变量 e)其他变量。
　　ID_col =
　　target_col =
　　cat_cols =
　　num_cols= list(set(list(fullData.columns))-set(cat_cols)-set(ID_col)-set(target_col)-set(data_col))
　　other_col= #为训练、测试数据集设置标识符
　　步骤5：识别缺失值变量并创建标志
　　fullData.isnull().any()#返回True或False，True意味着有缺失值而False相反
　　num_cat_cols = num_cols+cat_cols # 组合数值变量和分类变量
　　#为有缺失值的变量创建一个新的变量
　　# 对缺失值标志为1，否则为0
　　for var in num_cat_cols:
　　if fullData.isnull().any()=True:
　　fullData=fullData.isnull()*1
　　步骤6：填补缺失值
　　#用均值填补数值缺失值
　　fullData = fullData.fillna(fullData.mean(),inplace=True)
　　#用-9999填补分类变量缺失值
　　fullData = fullData.fillna(value = -9999)
　　步骤7：创建分类变量的标签编码器，将数据集分割成训练和测试集，进一步，将训练数据集分割成训练集和测试集。
　　#创建分类特征的标签编码器
　　for var in cat_cols:
　　number = LabelEncoder()
　　fullData = number.fit_transform(fullData.astype('str'))
　　#目标变量也是分类变量，所以也用标签编码器转换
　　fullData = number.fit_transform(fullData.astype('str'))
　　train=fullData='Train']
　　test=fullData='Test']
　　train = np.random.uniform(0, 1, len(train)) <= .75
　　Train, Validate = train=True], train=False]
　　步骤8：将填补和虚假（缺失值标志）变量传递到模型中，我使用随机森林来预测类。
　　features=list(set(list(fullData.columns))-set(ID_col)-set(target_col)-set(other_col))
　　x_train = Train.values
　　y_train = Train.values
　　x_validate = Validate.values
　　y_validate = Validate.values
　　x_test=test.values
　　random.seed(100)
　　rf = RandomForestClassifier(n_estimators=1000)
　　rf.fit(x_train, y_train)
　　步骤9：检查性能做出预测
　　status = rf.predict_proba(x_validate)
　　fpr, tpr, _ = roc_curve(y_validate, status)
　　roc_auc = auc(fpr, tpr)
　　print roc_auc
　　final_status = rf.predict_proba(x_test)
　　test=final_status
　　test.to_csv('C:/Users/Analytics Vidhya/Desktop/model_output.csv',columns=)
　　现在可以提交了！

2. 如何用Python在10分钟内树立一个预测模型

所谓预测模型我理解是机器学习的监督式算法。 常用的有 K 近邻， 决策树， 朴素贝叶斯等。 举例： 使用k近邻算法预测一个女的是不是美女： 我们抽取特征值：
身高，体重，三围等。 你先设置一些经验数据，例如： A: 165CM 50KG, 23 32,31 美 B 150 60KG 23 23 23 丑 现在输入 C 163 45 25 30 30 选择K =3， 算法会找经验数据中和这个数据最接近的三个 值，判断这三个对象是 美 还是丑。 如果2，3个美，则预测为美。否则为丑。 
对应的python代码在网上都有，估计20-30 行吧。 自己找找。

3. 如何用Python在10分钟内建立一个预测模型

所谓预测模型我理解是机器学习的监督式算法。
常用的有 K 近邻， 决策树， 朴素贝叶斯等。
举例：
使用k近邻算法预测一个女的是不是美女：
我们抽取特征值： 身高，体重，三围等。
你先设置一些经验数据，例如：
A:  165CM 50KG, 23 32,31  美
B    150    60KG   23 23 23  丑

现在输入
C   163 45 25 30 30 

 选择K =3， 算法会找经验数据中和这个数据最接近的三个 值，判断这三个对象是 美 还是丑。
如果2，3个美，则预测为美。否则为丑。

对应的python代码在网上都有，估计20-30 行吧。
自己找找。

4. 如何用Python在10分钟内建立一个预测模型

　　有各种各样的方法可以验证你模型性能，建议你将训练数据集划分为训练集和验证集（理想的比例是7030并且在70%训练数据集上建模。现在使用30%验证数据集进行交叉验证并使用评价指标进行性能评估。最后需要12分钟执行和记录结果。
　　本文的目的不是赢得竞赛，而是建立我自己的基准。让我用python代码来执行上面的方法，建立你第一个有较高影响的模型。

5. 如何用Python在10分钟内建立一个预测模型

Python用户数量上涨及其本身的简洁性，使得这个工具包对数据科学世界的Python专家们变得有意义。本文将帮助你更快更好地建立第一个预测模型。
绝大多数优秀的数据科学家和kagglers建立自己的第一个有效模型并快速提交。这不仅仅有助于他们领先于排行榜，而且提供了问题的基准解决方案。

6. python 时间序列模型中forecast和predict的区别

举一个例子吧，比如月度的数据，就是周期为12，它有季节影响。 先对其1阶12步差分，通过看acf pac f看是简单加法模型，还是乘法季节模型 如果是乘法模型那就要对季节部分模拟arima模型 季节部分的arima是以周期位置的acf pacf

7. python 时间序列数据 怎么预测

时间序列预测分析就是利用过去一段时间内某事件时间的特征来预测未来一段时间内该事件的特征。这是一类相对比较复杂的预测建模问题，和回归分析模型的预测不同
时间序列模型是依赖于事件发生的先后顺序的，同样大小的值改变顺序后输入模型产生的结果是不同的。

8. 如何在Python中用LSTM网络进行时间序列预测

时间序列模型
时间序列预测分析就是利用过去一段时间内某事件时间的特征来预测未来一段时间内该事件的特征。这是一类相对比较复杂的预测建模问题，和回归分析模型的预测不同，时间序列模型是依赖于事件发生的先后顺序的，同样大小的值改变顺序后输入模型产生的结果是不同的。举个栗子：根据过去两年某股票的每天的股价数据推测之后一周的股价变化；根据过去2年某店铺每周想消费人数预测下周来店消费的人数等等
RNN 和 LSTM 模型
时间序列模型最常用最强大的的工具就是递归神经网络（recurrent neural network, RNN）。相比与普通神经网络的各计算结果之间相互独立的特点，RNN的每一次隐含层的计算结果都与当前输入以及上一次的隐含层结果相关。通过这种方法，RNN的计算结果便具备了记忆之前几次结果的特点。
典型的RNN网路结构如下：右侧为计算时便于理解记忆而产开的结构。简单说，x为输入层，o为输出层，s为隐含层，而t指第几次的计算；V,W,U为权重，其中计算第t次的隐含层状态时为St = f(U*Xt + W*St-1)，实现当前输入结果与之前的计算挂钩的目的。对RNN想要更深入的了解可以戳这里。
RNN的局限：由于RNN模型如果需要实现长期记忆的话需要将当前的隐含态的计算与前n次的计算挂钩，即St = f(U*Xt + W1*St-1 + W2*St-2 + ... + Wn*St-n)，那样的话计算量会呈指数式增长，导致模型训练的时间大幅增加，因此RNN模型一般直接用来进行长期记忆计算。
LSTM模型LSTM（Long Short-Term Memory）模型是一种RNN的变型，最早由Juergen Schmidhuber提出的。经典的LSTM模型结构如下：LSTM的特点就是在RNN结构以外添加了各层的阀门节点。阀门有3类：遗忘阀门（forget gate），输入阀门（input gate）和输出阀门（output gate）。这些阀门可以打开或关闭，用于将判断模型网络的记忆态（之前网络的状态）在该层输出的结果是否达到阈值从而加入到当前该层的计算中。如图中所示，阀门节点利用sigmoid函数将网络的记忆态作为输入计算；如果输出结果达到阈值则将该阀门输出与当前层的的计算结果相乘作为下一层的输入（PS：这里的相乘是在指矩阵中的逐元素相乘）；如果没有达到阈值则将该输出结果遗忘掉。每一层包括阀门节点的权重都会在每一次模型反向传播训练过程中更新。更具体的LSTM的判断计算过程如下图所示：LSTM模型的记忆功能就是由这些阀门节点实现的。当阀门打开的时候，前面模型的训练结果就会关联到当前的模型计算，而当阀门关闭的时候之前的计算结果就不再影响当前的计算。因此，通过调节阀门的开关我们就可以实现早期序列对最终结果的影响。而当你不不希望之前结果对之后产生影响，比如自然语言处理中的开始分析新段落或新章节，那么把阀门关掉即可。（对LSTM想要更具体的了解可以戳这里）下图具体演示了阀门是如何工作的：通过阀门控制使序列第1的输入的变量影响到了序列第4,6的的变量计算结果。黑色实心圆代表对该节点的计算结果输出到下一层或下一次计算；空心圆则表示该节点的计算结果没有输入到网络或者没有从上一次收到信号。
Python中实现LSTM模型搭建
Python中有不少包可以直接调用来构建LSTM模型，比如pybrain, kears, tensorflow, cikit-neuralnetwork等（更多戳这里）。这里我们选用keras。（PS：如果操作系统用的linux或者mac，强推Tensorflow！！！）
因为LSTM神经网络模型的训练可以通过调整很多参数来优化，例如activation函数，LSTM层数，输入输出的变量维度等，调节过程相当复杂。这里只举一个最简单的应用例子来描述LSTM的搭建过程。
应用实例
基于某家店的某顾客的历史消费的时间推测该顾客前下次来店的时间。具体数据如下所示：
消费时间2015-05-15 14:03:512015-05-15 15:32:462015-06-28 18:00:172015-07-16 21:27:182015-07-16 22:04:512015-09-08 14:59:56....
具体操作：1. 原始数据转化首先需要将时间点数据进行数值化。将具体时间转化为时间段用于表示该用户相邻两次消费的时间间隔，然后再导入模型进行训练是比较常用的手段。转化后的数据如下：
消费间隔04418054....
2.生成模型训练数据集（确定训练集的窗口长度）这里的窗口指需要几次消费间隔用来预测下一次的消费间隔。这里我们先采用窗口长度为3， 即用t-2, t-1,t次的消费间隔进行模型训练，然后用t+1次间隔对结果进行验证。数据集格式如下：X为训练数据，Y为验证数据。PS： 这里说确定也不太合适，因为窗口长度需要根据模型验证结果进行调整的。
X1    X2    X3    Y0    44    18    044    18    0    54....    
注：直接这样预测一般精度会比较差，可以把预测值Y根据数值bin到几类，然后用转换成one-hot标签再来训练会比较好。比如如果把Y按数值范围分到五类（1：0-20，2：20-40，3：40-60，4：60-80，5：80-100）上式可化为：
X1    X2    X3    Y0    44    18    044    18    0    4... 
Y转化成one-hot以后则是(关于one-hot编码可以参考这里)
1    0    0    0    00    0    0    0    1...
3. 网络模型结构的确定和调整这里我们使用python的keras库。（用java的同学可以参考下deeplearning4j这个库）。网络的训练过程设计到许多参数的调整：比如
需要确定LSTM模块的激活函数（activation fucntion）（keras中默认的是tanh）；
确定接收LSTM输出的完全连接人工神经网络（fully-connected artificial neural network）的激活函数（keras中默认为linear）；
确定每一层网络节点的舍弃率（为了防止过度拟合（overfit）），这里我们默认值设定为0.2；
确定误差的计算方式，这里我们使用均方误差（mean squared error）；
确定权重参数的迭代更新方式，这里我们采用RMSprop算法，通常用于RNN网络。
确定模型训练的epoch和batch size（关于模型的这两个参数具体解释戳这里）一般来说LSTM模块的层数越多（一般不超过3层，再多训练的时候就比较难收敛），对高级别的时间表示的学习能力越强；同时，最后会加一层普通的神经网路层用于输出结果的降维。典型结构如下：如果需要将多个序列进行同一个模型的训练，可以将序列分别输入到独立的LSTM模块然后输出结果合并后输入到普通层。结构如下：

4. 模型训练和结果预测将上述数据集按4:1的比例随机拆分为训练集和验证集，这是为了防止过度拟合。训练模型。然后将数据的X列作为参数导入模型便可得到预测值，与实际的Y值相比便可得到该模型的优劣。
实现代码
时间间隔序列格式化成所需的训练集格式
import pandas as pdimport numpy as npdef create_interval_dataset(dataset, look_back):   """    :param dataset: input array of time intervals    :param look_back: each training set feature length    :return: convert an array of values into a dataset matrix.    """   dataX, dataY = [], []    for i in range(len(dataset) - look_back):       dataX.append(dataset[i:i+look_back])       dataY.append(dataset[i+look_back])    return np.asarray(dataX), np.asarray(dataY)df = pd.read_csv("path-to-your-time-interval-file")    dataset_init = np.asarray(df)    # if only 1 columndataX, dataY = create_interval_dataset(dataset, lookback=3)    # look back if the training set sequence length这里的输入数据来源是csv文件，如果输入数据是来自数据库的话可以参考这里
LSTM网络结构搭建
import pandas as pdimport numpy as npimport randomfrom keras.models import Sequential, model_from_jsonfrom keras.layers import Dense, LSTM, Dropoutclass NeuralNetwork():   def __init__(self, **kwargs):       """        :param **kwargs: output_dim=4: output dimension of LSTM layer; activation_lstm='tanh': activation function for LSTM layers; activation_dense='relu': activation function for Dense layer; activation_last='sigmoid': activation function for last layer; drop_out=0.2: fraction of input units to drop; np_epoch=10, the number of epoches to train the model. epoch is one forward pass and one backward pass of all the training examples; batch_size=32: number of samples per gradient update. The higher the batch size, the more memory space you'll need; loss='mean_square_error': loss function; optimizer='rmsprop'        """       self.output_dim = kwargs.get('output_dim', 8)        self.activation_lstm = kwargs.get('activation_lstm', 'relu')        self.activation_dense = kwargs.get('activation_dense', 'relu')        self.activation_last = kwargs.get('activation_last', 'softmax')    # softmax for multiple output       self.dense_layer = kwargs.get('dense_layer', 2)     # at least 2 layers       self.lstm_layer = kwargs.get('lstm_layer', 2)        self.drop_out = kwargs.get('drop_out', 0.2)        self.nb_epoch = kwargs.get('nb_epoch', 10)        self.batch_size = kwargs.get('batch_size', 100)        self.loss = kwargs.get('loss', 'categorical_crossentropy')        self.optimizer = kwargs.get('optimizer', 'rmsprop')        def NN_model(self, trainX, trainY, testX, testY):       """        :param trainX: training data set        :param trainY: expect value of training data        :param testX: test data set        :param testY: epect value of test data        :return: model after training        """       print "Training model is LSTM network!"       input_dim = trainX[1].shape[1]       output_dim = trainY.shape[1] # one-hot label       # print predefined parameters of current model:       model = Sequential()        # applying a LSTM layer with x dim output and y dim input. Use dropout parameter to avoid overfitting       model.add(LSTM(output_dim=self.output_dim,                      input_dim=input_dim,                      activation=self.activation_lstm,                      dropout_U=self.drop_out,                      return_sequences=True))        for i in range(self.lstm_layer-2):           model.add(LSTM(output_dim=self.output_dim,                      input_dim=self.output_dim,                      activation=self.activation_lstm,                      dropout_U=self.drop_out,                      return_sequences=True))        # argument return_sequences should be false in last lstm layer to avoid input dimension incompatibility with dense layer       model.add(LSTM(output_dim=self.output_dim,                      input_dim=self.output_dim,                      activation=self.activation_lstm,                      dropout_U=self.drop_out))        for i in range(self.dense_layer-1):           model.add(Dense(output_dim=self.output_dim,                       activation=self.activation_last))       model.add(Dense(output_dim=output_dim,                       input_dim=self.output_dim,                       activation=self.activation_last))        # configure the learning process       model.compile(loss=self.loss, optimizer=self.optimizer, metrics=['accuracy'])        # train the model with fixed number of epoches       model.fit(x=trainX, y=trainY, nb_epoch=self.nb_epoch, batch_size=self.batch_size, validation_data=(testX, testY))        # store model to json file       model_json = model.to_json()        with open(model_path, "w") as json_file:           json_file.write(model_json)        # store model weights to hdf5 file       if model_weight_path:            if os.path.exists(model_weight_path):               os.remove(model_weight_path)           model.save_weights(model_weight_path) # eg: model_weight.h5       return model这里写的只涉及LSTM网络的结构搭建，至于如何把数据处理规范化成网络所需的结构以及把模型预测结果与实际值比较统计的可视化，就需要根据实际情况做调整了。