调用预测函数python,预测函数控制

python的调用函数怎么用？

注意代码格式

目前创新互联已为上1000+的企业提供了网站建设、域名、虚拟主机、网站托管运营、企业网站设计、凤翔网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。

python以缩进为标准 而不是像Java 以分号分隔

函数调用需要 写在main函数内

仔细检查你的代码格式和语法

希望可以帮助你  请采纳  谢谢

如何用 Python 构建神经网络择时模型

import math

import random

random.seed(0)

def rand(a,b): #随机函数

return (b-a)*random.random()+a

def make_matrix(m,n,fill=0.0):#创建一个指定大小的矩阵

mat = []

for i in range(m):

mat.append([fill]*n)

return mat

#定义sigmoid函数和它的导数

def sigmoid(x):

return 1.0/(1.0+math.exp(-x))

def sigmoid_derivate(x):

return x*(1-x) #sigmoid函数的导数

class BPNeuralNetwork:

def __init__(self):#初始化变量

self.input_n = 0

self.hidden_n = 0

self.output_n = 0

self.input_cells = []

self.hidden_cells = []

self.output_cells = []

self.input_weights = []

self.output_weights = []

self.input_correction = []

self.output_correction = []

#三个列表维护：输入层，隐含层，输出层神经元

def setup(self,ni,nh,no):

self.input_n = ni+1 #输入层+偏置项

self.hidden_n = nh #隐含层

self.output_n = no #输出层

#初始化神经元

self.input_cells = [1.0]*self.input_n

self.hidden_cells= [1.0]*self.hidden_n

self.output_cells= [1.0]*self.output_n

#初始化连接边的边权

self.input_weights = make_matrix(self.input_n,self.hidden_n) #邻接矩阵存边权：输入层-隐藏层

self.output_weights = make_matrix(self.hidden_n,self.output_n) #邻接矩阵存边权：隐藏层-输出层

#随机初始化边权：为了反向传导做准备---随机初始化的目的是使对称失效

for i in range(self.input_n):

for h in range(self.hidden_n):

self.input_weights[i][h] = rand(-0.2 , 0.2) #由输入层第i个元素到隐藏层第j个元素的边权为随机值

for h in range(self.hidden_n):

for o in range(self.output_n):

self.output_weights[h][o] = rand(-2.0, 2.0) #由隐藏层第i个元素到输出层第j个元素的边权为随机值

#保存校正矩阵，为了以后误差做调整

self.input_correction = make_matrix(self.input_n , self.hidden_n)

self.output_correction = make_matrix(self.hidden_n,self.output_n)

#输出预测值

def predict(self,inputs):

#对输入层进行操作转化样本

for i in range(self.input_n-1):

self.input_cells[i] = inputs[i] #n个样本从0~n-1

#计算隐藏层的输出，每个节点最终的输出值就是权值*节点值的加权和

for j in range(self.hidden_n):

total = 0.0

for i in range(self.input_n):

total+=self.input_cells[i]*self.input_weights[i][j]

# 此处为何是先i再j，以隐含层节点做大循环，输入样本为小循环，是为了每一个隐藏节点计算一个输出值，传输到下一层

self.hidden_cells[j] = sigmoid(total) #此节点的输出是前一层所有输入点和到该点之间的权值加权和

for k in range(self.output_n):

total = 0.0

for j in range(self.hidden_n):

total+=self.hidden_cells[j]*self.output_weights[j][k]

self.output_cells[k] = sigmoid(total) #获取输出层每个元素的值

return self.output_cells[:] #最后输出层的结果返回

#反向传播算法：调用预测函数，根据反向传播获取权重后前向预测，将结果与实际结果返回比较误差

def back_propagate(self,case,label,learn,correct):

#对输入样本做预测

self.predict(case) #对实例进行预测

output_deltas = [0.0]*self.output_n #初始化矩阵

for o in range(self.output_n):

error = label[o] - self.output_cells[o] #正确结果和预测结果的误差：0,1，-1

output_deltas[o]= sigmoid_derivate(self.output_cells[o])*error#误差稳定在0~1内

#隐含层误差

hidden_deltas = [0.0]*self.hidden_n

for h in range(self.hidden_n):

error = 0.0

for o in range(self.output_n):

error+=output_deltas[o]*self.output_weights[h][o]

hidden_deltas[h] = sigmoid_derivate(self.hidden_cells[h])*error

#反向传播算法求W

#更新隐藏层-输出权重

for h in range(self.hidden_n):

for o in range(self.output_n):

change = output_deltas[o]*self.hidden_cells[h]

#调整权重：上一层每个节点的权重学习*变化+矫正率

self.output_weights[h][o] += learn*change + correct*self.output_correction[h][o]

#更新输入-隐藏层的权重

for i in range(self.input_n):

for h in range(self.hidden_n):

change = hidden_deltas[h]*self.input_cells[i]

self.input_weights[i][h] += learn*change + correct*self.input_correction[i][h]

self.input_correction[i][h] = change

#获取全局误差

error = 0.0

for o in range(len(label)):

error = 0.5*(label[o]-self.output_cells[o])**2 #平方误差函数

return error

def train(self,cases,labels,limit=10000,learn=0.05,correct=0.1):

for i in range(limit): #设置迭代次数

error = 0.0

for j in range(len(cases)):#对输入层进行访问

label = labels[j]

case = cases[j]

error+=self.back_propagate(case,label,learn,correct) #样例，标签，学习率，正确阈值

def test(self): #学习异或

cases = [

[0, 0],

[0, 1],

[1, 0],

[1, 1],

] #测试样例

labels = [[0], [1], [1], [0]] #标签

self.setup(2,5,1) #初始化神经网络：输入层，隐藏层，输出层元素个数

self.train(cases,labels,10000,0.05,0.1) #可以更改

for case in cases:

print(self.predict(case))

if __name__ == '__main__':

nn = BPNeuralNetwork()

nn.test()

python函数调用

inname = r"C:\Python27\esri.shp"

outname = "outname.cst"

# 在此处调用该函数。函数体定义必须放在调用以前。可以通过import

read_ESRT_……(file = inname, fileOut = outname)

# 这两个参数只是字符串而已，指明你的文件路径。注意在python中，若有 \ 号，则最好使用 \\ 双斜杠，或者如上例，加上前缀 r

python如何定义和调用函数

1、函数定义

①使用def关键字定义函数

②

def 函数名(参数1.参数2.参数3...):

"""文档字符串，docstring，用来说明函数的作用"""

#函数体

return 表达式

注释的作用：说明函数是做什么的，函数有什么功能。

③遇到冒号要缩进，冒号后面所有的缩进的代码块构成了函数体，描述了函数是做什么的，即函数的功能是什么。Python函数的本质与数学中的函数的本质是一致的。

2、函数调用

①函数必须先定义，才能调用，否则会报错。

②无参数时函数的调用：函数名()，有参数时函数的调用：函数名(参数1.参数2.……)

③不要在定义函数的时候在函数体里面调用本身，否则会出不来，陷入循环调用。

④函数需要调用函数体才会被执行，单纯的只是定义函数是不会被执行的。

⑤Debug工具中Step into进入到调用的函数里，Step Into My Code进入到调用的模块里函数。

python中怎么调用函数

大部分函数都长这样：函数名（参数）

要调用函数就直接使用函数名加参数就可以了。

python gradientboostingregressor可以做预测吗

可以

最近项目中涉及基于Gradient Boosting Regression 算法拟合时间序列曲线的内容，利用python机器学习包 scikit-learn 中的GradientBoostingRegressor完成

因此就学习了下Gradient Boosting算法，在这里分享下我的理解

Boosting 算法简介

Boosting算法，我理解的就是两个思想：

1）“三个臭皮匠顶个诸葛亮”，一堆弱分类器的组合就可以成为一个强分类器；

2）“知错能改，善莫大焉”，不断地在错误中学习，迭代来降低犯错概率

当然，要理解好Boosting的思想，首先还是从弱学习算法和强学习算法来引入：

1）强学习算法：存在一个多项式时间的学习算法以识别一组概念，且识别的正确率很高；

2）弱学习算法：识别一组概念的正确率仅比随机猜测略好；

Kearns Valiant证明了弱学习算法与强学习算法的等价问题，如果两者等价，只需找到一个比随机猜测略好的学习算法，就可以将其提升为强学习算法。

那么是怎么实现“知错就改”的呢？

Boosting算法，通过一系列的迭代来优化分类结果，每迭代一次引入一个弱分类器，来克服现在已经存在的弱分类器组合的shortcomings

在Adaboost算法中，这个shortcomings的表征就是权值高的样本点

而在Gradient Boosting算法中,这个shortcomings的表征就是梯度

无论是Adaboost还是Gradient Boosting，都是通过这个shortcomings来告诉学习器怎么去提升模型，也就是“Boosting”这个名字的由来吧

Adaboost算法

Adaboost是由Freund 和 Schapire在1997年提出的，在整个训练集上维护一个分布权值向量W,用赋予权重的训练集通过弱分类算法产生分类假设（基学习器）y(x),然后计算错误率,用得到的错误率去更新分布权值向量w,对错误分类的样本分配更大的权值,正确分类的样本赋予更小的权值。每次更新后用相同的弱分类算法产生新的分类假设,这些分类假设的序列构成多分类器。对这些多分类器用加权的方法进行联合,最后得到决策结果。

其结构如下图所示：

前一个学习器改变权重w，然后再经过下一个学习器，最终所有的学习器共同组成最后的学习器。

如果一个样本在前一个学习器中被误分，那么它所对应的权重会被加重，相应地，被正确分类的样本的权重会降低。

这里主要涉及到两个权重的计算问题：

1）样本的权值

1 没有先验知识的情况下,初始的分布应为等概分布,样本数目为n,权值为1/n

2 每一次的迭代更新权值，提高分错样本的权重

2）弱学习器的权值

1 最后的强学习器是通过多个基学习器通过权值组合得到的。

2 通过权值体现不同基学习器的影响,正确率高的基学习器权重高。实际上是分类误差的一个函数

Gradient Boosting

和Adaboost不同，Gradient Boosting 在迭代的时候选择梯度下降的方向来保证最后的结果最好。

损失函数用来描述模型的“靠谱”程度，假设模型没有过拟合，损失函数越大，模型的错误率越高

如果我们的模型能够让损失函数持续的下降，则说明我们的模型在不停的改进，而最好的方式就是让损失函数在其梯度方向上下降。

下面这个流程图是Gradient Boosting的经典图了，数学推导并不复杂，只要理解了Boosting的思想，不难看懂

这里是直接对模型的函数进行更新，利用了参数可加性推广到函数空间。

训练F0-Fm一共m个基学习器，沿着梯度下降的方向不断更新ρm和am

GradientBoostingRegressor实现

python中的scikit-learn包提供了很方便的GradientBoostingRegressor和GBDT的函数接口，可以很方便的调用函数就可以完成模型的训练和预测

GradientBoostingRegressor函数的参数如下：

class sklearn.ensemble.GradientBoostingRegressor(loss='ls', learning_rate=0.1, n_estimators=100, subsample=1.0, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_depth=3, init=None, random_state=None, max_features=None, alpha=0.9, verbose=0, max_leaf_nodes=None, warm_start=False, presort='auto')[source]¶

loss: 选择损失函数，默认值为ls(least squres)

learning_rate: 学习率，模型是0.1

n_estimators: 弱学习器的数目，默认值100

max_depth: 每一个学习器的最大深度，限制回归树的节点数目，默认为3

min_samples_split: 可以划分为内部节点的最小样本数，默认为2

min_samples_leaf: 叶节点所需的最小样本数，默认为1

……

可以参考

官方文档里带了一个很好的例子，以500个弱学习器，最小平方误差的梯度提升模型，做波士顿房价预测，代码和结果如下：

1 import numpy as np 2 import matplotlib.pyplot as plt 3  4 from sklearn import ensemble 5 from sklearn import datasets 6 from sklearn.utils import shuffle 7 from sklearn.metrics import mean_squared_error 8  9 ###############################################################################10 # Load data11 boston = datasets.load_boston()12 X, y = shuffle(boston.data, boston.target, random_state=13)13 X = X.astype(np.float32)14 offset = int(X.shape[0] * 0.9)15 X_train, y_train = X[:offset], y[:offset]16 X_test, y_test = X[offset:], y[offset:]17 18 ###############################################################################19 # Fit regression model20 params = {'n_estimators': 500, 'max_depth': 4, 'min_samples_split': 1,21           'learning_rate': 0.01, 'loss': 'ls'}22 clf = ensemble.GradientBoostingRegressor(**params)23 24 clf.fit(X_train, y_train)25 mse = mean_squared_error(y_test, clf.predict(X_test))26 print("MSE: %.4f" % mse)27 28 ###############################################################################29 # Plot training deviance30 31 # compute test set deviance32 test_score = np.zeros((params['n_estimators'],), dtype=np.float64)33 34 for i, y_pred in enumerate(clf.staged_predict(X_test)):35     test_score[i] = clf.loss_(y_test, y_pred)36 37 plt.figure(figsize=(12, 6))38 plt.subplot(1, 2, 1)39 plt.title('Deviance')40 plt.plot(np.arange(params['n_estimators']) + 1, clf.train_score_, 'b-',41          label='Training Set Deviance')42 plt.plot(np.arange(params['n_estimators']) + 1, test_score, 'r-',43          label='Test Set Deviance')44 plt.legend(loc='upper right')45 plt.xlabel('Boosting Iterations')46 plt.ylabel('Deviance')47 48 ###############################################################################49 # Plot feature importance50 feature_importance = clf.feature_importances_51 # make importances relative to max importance52 feature_importance = 100.0 * (feature_importance / feature_importance.max())53 sorted_idx = np.argsort(feature_importance)54 pos = np.arange(sorted_idx.shape[0]) + .555 plt.subplot(1, 2, 2)56 plt.barh(pos, feature_importance[sorted_idx], align='center')57 plt.yticks(pos, boston.feature_names[sorted_idx])58 plt.xlabel('Relative Importance')59 plt.title('Variable Importance')60 plt.show()

可以发现，如果要用Gradient Boosting 算法的话，在sklearn包里调用还是非常方便的，几行代码即可完成，大部分的工作应该是在特征提取上。

感觉目前做数据挖掘的工作，特征设计是最重要的，据说现在kaggle竞赛基本是GBDT的天下，优劣其实还是特征上，感觉做项目也是，不断的在研究数据中培养对数据的敏感度。