python训练的模型做预测：
如下：
①.、 先要按照scikit-learn包,先安装下面三个依赖包：
然后在cmd命令行中输入：
pip install -U scikit-learn
扩展资料
应用
系统编程：提供API（Application Programming Interface应用程序编程接口）,能方便进行系统维护和管理,Linux下标志性语言之一,是很多系统管理员理想的编程工具.
图形处理：有PIL、Tkinter等图形库支持,能方便进行图形处理.
数学处理：NumPy扩展提供大量与许多标准数学库的接口.
文本处理：python提供的re模块能支持正则表达式,还提供SGML,XML分析模块,许多程序员利用python进行XML程序的开发.
网络编程：提供丰富的模块支持sockets编程,能方便快速地开发分布式应用程序.很多大规模软件开发计划例如Zope,Mnet 及BitTorrent. Google都在广泛地使用它.
Web编程：应用的开发语言,支持最新的XML技术.
建议你用面向对象的方式去画图,一个图作为一个对象,这样每次调用一个对象的保存图片方法就可以只保存当前图片.
你这种用法第三张图会有三个子图是因为三个子图都画在同一个对象上.
为了将面向对象的绘图库包装成只使用函数的调用接口,pyplot模块的内部保存了当前图表以及当前子图等信息.当前的图表和子图可以使用gcf()和gca()获得,它们分别是"Get?Current?Figure"和"Get?Current?Axis"的开头字母缩写.gcf()获得的是表示图表的Figure对象,而gca()则获得的是表示子图的Axes对象.下面我们在IPython中运行上节的"matplotlib_simple_plot.py"程序,然后调用gcf()和gca()查看当前的Figure和Axes对象.
给你个例子
import?numpy?as?np
import?matplotlib.pyplot?as?plt
plt.figure(1)?#?创建图表1
plt.figure(1)?#?选择图表1
plt.plot(x,?np.sin(i*x))
plt.plot(x,?np.cos(i*x))
plt.show()
preface：做着最近的任务,对数据处理,做些简单的提特征,用机器学习算法跑下程序得出结果,看看哪些特征的组合较好,这一系列流程必然要用到很多函数,故将自己常用函数记录上.应该说这些函数基本上都会用到,像是数据预处理,处理完了后特征提取、降维、训练预测、通过混淆矩阵看分类效果,得出报告.
①输入
从数据集开始,提取特征转化为有标签的数据集,转为向量.拆分成训练集和测试集,这里不多讲,在上一篇博客中谈到用StratifiedKFold()函数即可.在训练集中有data和target开始.
[python]?view plain?copy
def?my_preprocessing(train_data):
from?sklearn?import?preprocessing
return?X_normalized
def?my_feature_selection(data,?target):
from?sklearn.feature_selection?import?SelectKBest
return?data_new
def?my_PCA(data):#data?without?target,?just?train?data,?withou?train?target.
from?sklearn?import?decomposition
pca_sklearn?=?decomposition.PCA()
pca_sklearn.fit(data)
main_var?=?pca_sklearn.explained_variance_
plt.plot(main_var[:n])
def?clf_train(data,target):
from?sklearn?import?svm
#from?sklearn.linear_model?import?LogisticRegression
clf?=?svm.SVC(C=100,kernel="rbf",gamma=0.001)
clf.fit(data,target)
#clf_LR?=?LogisticRegression()
#clf_LR.fit(x_train,?y_train)
#y_pred_LR?=?clf_LR.predict(x_test)
return?clf
def?my_confusion_matrix(y_true,?y_pred):
from?sklearn.metrics?import?confusion_matrix
labels?=?list(set(y_true))
conf_mat?=?confusion_matrix(y_true,?y_pred,?labels?=?labels)
print?"confusion_matrix(left?labels:?y_true,?up?labels:?y_pred):"
print?"labels\t",
for?i?in?range(len(labels)):
print?labels[i],"\t",
for?i?in?range(len(conf_mat)):
print?i,"\t",
for?j?in?range(len(conf_mat[i])):
print?conf_mat[i][j],'\t',
def?my_classification_report(y_true,?y_pred):
from?sklearn.metrics?import?classification_report
print?"classification_report(left:?labels):"
print?classification_report(y_true,?y_pred)
my_preprocess()函数：
my_feature_selection()函数：
my_PCA()函数：
主要用来观察前多少个特征是主要特征,并且画图.看看前多少个特征占据主要部分.
clf_train()函数：
可用多种机器学习算法,如SVM, LR, RF, GBDT等等很多,其中像SVM需要调参数的,有专门调试参数的函数如StratifiedKFold()（见前几篇博客）.以达到最优.
my_confusion_matrix()函数：
主要是针对预测出来的结果,和原来的结果对比,算出混淆矩阵,不必自己计算.其对每个类别的混淆矩阵都计算出来了,并且labels参数默认是排序了的.
my_classification_report()函数：
主要通过sklearn.metrics函数中的classification_report()函数,针对每个类别给出详细的准确率、召回率和F-值这三个参数和宏平均值,用来评价算法好坏.另外ROC曲线的话,需要是对二分类才可以.多类别似乎不行.
主要参考sklearn官网
该算法要先进行特征选择,再生成决策树,其中特征选择是基于"信息增益"最大的原则进行的.
但由于决策树完全基于训练集生成的,有可能对训练集过于"依赖",即产生过拟合现象.所以呢在生成决策树后,需要对决策树进行剪枝.剪枝有两种形式,分别为前剪枝（Pre-Pruning）和后剪枝（Post-Pruning）,一般采用后剪枝.
信息熵、条件熵和信息增益
信息熵：来自于香农定理,表示信息集合所含信息的平均不确定性.信息熵越大,表示不确定性越大,所含的信息量也就越大.
,x
,...x
n
为信息集合X的n个取值,则x i x_ix
i
的概率：
P(X=i)=p
信息集合X的信息熵为：
H ( X ) = ? ∑ i = 1 n p i log ? p i H(X) =- \sum_{i=1}^{n}{p_i}\log{p_i}
H(X)=?
i=1
∑
p
logp
条件熵：指已知某个随机变量的情况下,信息集合的信息熵.
,y
,...y
m
组成的随机变量集合Y,则随机变量（X,Y）的联合概率分布为
P ( x = i , y = j ) = p i j P(x=i,y=j) = p_{ij}
P(x=i,y=j)=p
ij
条件熵：
H ( X ∣ Y ) = ∑ j = 1 m p ( y j ) H ( X ∣ y j ) H(X|Y) = \sum_{j=1}^m{p(y_j)H(X|y_j)}
H(X∣Y)=
j=1
p(y
j
)H(X∣y
)
由
H ( X ∣ y j ) = ? ∑ j = 1 m p ( y j ) ∑ i = 1 n p ( x i ∣ y j ) log ? p ( x i ∣ y j ) H(X|y_j) = - \sum_{j=1}^m{p(y_j)}\sum_{i=1}^n{p(x_i|y_j)}\log{p(x_i|y_j)}
H(X∣y
)=?
p(x
∣y
)logp(x
和贝叶斯公式：
p ( x i y j ) = p ( x i ∣ y j ) p ( y j ) p(x_iy_j) = p(x_i|y_j)p(y_j)
y
)=p(x
)p(y
可以化简条件熵的计算公式为:
H ( X ∣ Y ) = ∑ j = 1 m ∑ i = 1 n p ( x i , y j ) log ? p ( x i ) p ( x i , y j ) H(X|Y) = \sum_{j=1}^m \sum_{i=1}^n{p(x_i, y_j)\log\frac{p(x_i)}{p(x_i, y_j)}}
)log
信息增益：信息熵-条件熵,用于衡量在知道已知随机变量后,信息不确定性减小越大.
d ( X , Y ) = H ( X ) ? H ( X ∣ Y ) d(X,Y) = H(X) - H(X|Y)
d(X,Y)=H(X)?H(X∣Y)
python代码实现
import numpy as np
import math
def calShannonEnt(dataSet):
""" 计算信息熵 """
labelCountDict = {}
for d in dataSet:
label = d[-1]
if label not in labelCountDict.keys():
labelCountDict[label] = 1
else:
labelCountDict[label] += 1
entropy = 0.0
for l, c in labelCountDict.items():
p = 1.0 * c / len(dataSet)
return entropy
def filterSubDataSet(dataSet, colIndex, value):
"""返回colIndex特征列label等于value,并且过滤掉改特征列的数据集"""
subDataSetList = []
for r in dataSet:
if r[colIndex] == value:
newR = r[:colIndex]
newR = np.append(newR, (r[colIndex + 1:]))
subDataSetList.append(newR)
return np.array(subDataSetList)
def chooseFeature(dataSet):
""" 通过计算信息增益选择最合适的特征"""
featureNum = dataSet.shape[1] - 1
entropy = calShannonEnt(dataSet)
bestInfoGain = 0.0
bestFeatureIndex = -1
for i in range(featureNum):
uniqueValues = np.unique(dataSet[:, i])
condition_entropy = 0.0
for v in uniqueValues: #计算条件熵
subDataSet = filterSubDataSet(dataSet, i, v)
p = 1.0 * len(subDataSet) / len(dataSet)
condition_entropy += p * calShannonEnt(subDataSet)
infoGain = entropy - condition_entropy #计算信息增益
if infoGain = bestInfoGain: #选择最大信息增益
bestInfoGain = infoGain
bestFeatureIndex = i
return bestFeatureIndex
def creatDecisionTree(dataSet, featNames):
""" 通过训练集生成决策树 """
featureName = featNames[:] # 拷贝featNames,此处不能直接用赋值操作,否则新变量会指向旧变量的地址
classList = list(dataSet[:, -1])
if len(set(classList)) == 1: # 只有一个类别
return classList[0]
if dataSet.shape[1] == 1: #当所有特征属性都利用完仍然无法判断样本属于哪一类,此时归为该数据集中数量最多的那一类
return max(set(classList), key=classList.count)
bestFeatureIndex = chooseFeature(dataSet) #选择特征
bestFeatureName = featNames[bestFeatureIndex]
del featureName[bestFeatureIndex] #移除已选特征列
decisionTree = {bestFeatureName: {}}
featureValueUnique = sorted(set(dataSet[:, bestFeatureIndex])) #已选特征列所包含的类别, 通过递归生成决策树
for v in featureValueUnique:
copyFeatureName = featureName[:]
subDataSet = filterSubDataSet(dataSet, bestFeatureIndex, v)
decisionTree[bestFeatureName][v] = creatDecisionTree(subDataSet, copyFeatureName)
return decisionTree
def classify(decisionTree, featnames, featList):
""" 使用训练所得的决策树进行分类 """
classLabel = None
root = decisionTree.keys()[0]
firstGenDict = decisionTree[root]
featIndex = featnames.index(root)
for k in firstGenDict.keys():
if featList[featIndex] == k:
if isinstance(firstGenDict[k], dict): #若子节点仍是树,则递归查找
classLabel = classify(firstGenDict[k], featnames, featList)
classLabel = firstGenDict[k]
return classLabel
from sklearn import datasets
from sklearn.model_selection import train_test_split
iris = datasets.load_iris()
data = np.c_[iris.data, iris.target]
scoreL = []
for i in range(1000): #对该过程进行10000次
trainData, testData = train_test_split(data) #区分测试集和训练集
featNames = iris.feature_names[:]
for i in range(trainData.shape[1] - 1): #对训练集每个特征,以中值为分界点进行离散化
splitPoint = np.mean(trainData[:, i])
trainData[:, i] = [1 if x = splitPoint else 0 for x in trainData[:, i]]
testData[:, i] = [1 if x = splitPoint else 0 for x in testData[:, i]]
decisionTree = creatDecisionTree(trainData, featNames)
classifyLable = [classify(decisionTree, featNames, td) for td in testData]
scoreL.append(1.0 * sum(classifyLable == testData[:, -1]) / len(classifyLable))
print 'score: ', np.mean(scoreL)
数据离散化
然而,在上例中对特征值离散化的划分点实际上过于"野蛮",此处介绍一种通过信息增益最大的标准来对数据进行离散化.原理很简单,当信息增益最大时,说明用该点划分能最大程度降低数据集的不确定性.
具体步骤如下：
对每个特征所包含的数值型特征值排序
对相邻两个特征值取均值,这些均值就是待选的划分点
用每一个待选点把该特征的特征值划分成两类,小于该特征点置为1, 大于该特征点置为0,计算此时的条件熵,并计算出信息增益
选择信息使信息增益最大的划分点进行特征离散化
实现代码如下：
def filterRawData(dataSet, colIndex, value, tag):
""" 用于把每个特征的连续值按照区分点分成两类,加入tag参数,可用于标记筛选的是哪一部分数据"""
filterDataList = []
if (tag and r[colIndex] = value) or ((not tag) and r[colIndex] value):
filterDataList.append(newR)
return np.array(filterDataList)
def dataDiscretization(dataSet, featName):
""" 对数据每个特征的数值型特征值进行离散化 """
for featIndex in range(featureNum): #对于每一个特征
uniqueValues = sorted(np.unique(dataSet[:, featIndex]))
meanPoint = []
for i in range(len(uniqueValues) - 1): # 求出相邻两个值的平均值
bestMeanPoint = -1
for mp in meanPoint: #对于每个划分点
subEntropy = 0.0 #计算该划分点的信息熵
subDataSet = filterRawData(dataSet, featIndex, mp, tag)
subEntropy += p * calShannonEnt(subDataSet)
## 计算信息增益
infoGain = entropy - subEntropy
## 选择最大信息增益
if infoGain = bestInfoGain:
bestMeanPoint = mp
dataSet[:, featIndex] = [1 if x = bestMeanPoint else 0 for x in dataSet[:, featIndex]]
return dataSet, featName
重新对数据进行离散化,并重复该步骤1000次,同时用sklearn中的DecisionTreeClassifier对相同数据进行分类,分别统计平均准确率.运行代码如下:
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
scoreL_sk = []
for i in range(1000): #对该过程进行1000次
trainData_tmp = copy.copy(trainData)
testData_tmp = copy.copy(testData)
discritizationData, discritizationFeatName= dataDiscretization(trainData, featNames) #根据信息增益离散化
for i in range(testData.shape[1]-1): #根据测试集的区分点离散化训练集
splitPoint = float(discritizationFeatName[i].split('=')[-1])
testData[:, i] = [1 if x=splitPoint else 0 for x in testData[:, i]]
clf = DecisionTreeClassifier('entropy')
clf.fit(trainData[:, :-1], trainData[:, -1])
clf.predict(testData[:, :-1])
scoreL_sk.append(clf.score(testData[:, :-1], testData[:, -1]))
print 'score-sk: ', np.mean(scoreL_sk)
pd.Series(scoreL).hist(grid=False, bins=10)
pd.Series(scoreL_sk).hist(grid=False, bins=10)
两者准确率分别为：
准确率分布如下：
两者的结果非常一样.
（但是..为什么根据信息熵离散化得到的准确率比直接用均值离散化的准确率还要低啊?哇的哭出声..）
最后一次决策树图形如下：
决策树剪枝
由于决策树是完全依照训练集生成的,有可能会有过拟合现象,所以呢一般会对生成的决策树进行剪枝.常用的是通过决策树损失函数剪枝,决策树损失函数表示为:
C a ( T ) = ∑ t = 1 T N t H t ( T ) + a ∣ T ∣ C_a(T) = \sum_{t=1}^TN_tH_t(T) +\alpha|T|
C
a
(T)=
t=1
T
N
t
H
(T)+a∣T∣
其中,H t ( T ) H_t(T)H
(T)表示叶子节点t的熵值,T表示决策树的深度.前项∑ t = 1 T N t H t ( T ) \sum_{t=1}^TN_tH_t(T)∑
(T)是决策树的经验损失函数当随着T的增加,该节点被不停的划分的时候,熵值可以达到最小,然而T的增加会使后项的值增大.决策树损失函数要做的就是在两者之间进行平衡,使得该值最小.
对于决策树损失函数的理解,如何理解决策树的损失函数? - 陶轻松的回答 - 知乎这个回答写得挺好,可以按照答主的思路理解一下
S p l i t I n f o ( X , Y ) = ? ∑ i n ∣ X i ∣ ∣ X ∣ log ? ∣ X i ∣ ∣ X ∣ SplitInfo(X, Y) =-\sum_i^n\frac{|X_i|}{|X|}\log\frac{|X_i|}{|X|}
SplitInfo(X,Y)=?
∣X∣
∣X
∣
log
则信息增益率为：
G a i n R a t i o ( X , Y ) = d ( X , Y ) S p l i t I n f o ( X , Y ) GainRatio(X,Y)=\frac{d(X,Y)}{SplitInfo(X, Y)}
GainRatio(X,Y)=
SplitInfo(X,Y)
d(X,Y)
无法处理连续性特征数据
特征选取会倾向于分类较多的特征
没有解决过拟合的问题
没有解决缺失值的问题
通过信息最大增益的标准离散化连续的特征数据
在选择特征是标准从"最大信息增益"改为"最大信息增益率"
通过加入正则项系数对决策树进行剪枝
对缺失值的处理体现在两个方面：特征选择和生成决策树.初始条件下对每个样本的权重置为1.
特征选择：在选取最优特征时,计算出每个特征的信息增益后,需要乘以一个**"非缺失值样本权重占总样本权重的比例"**作为系数来对比每个特征信息增益的大小
生成决策树：在生成决策树时,对于缺失的样本我们按照一定比例把它归属到每个特征值中,比例为该特征每一个特征值占非缺失数据的比重
————————————————
原文链接：
我在学习时也遇到了同样的问题,我是这样解决的clf.fit(list(xy_normalized), labels)
我目前也在学习Python+ML,大家可以共同学习,共同探讨.
用dia测了测每个字之间的间距,直接用PIL开始切.
from PIL import Image
f=Image.open("../test{}.jpg".format(j))
上面一段脚本的意思是把jpg切成四个小块然后保存
之后就是二值化啦.
def TotallyShit(im):
x,y=im.size
mmltilist=list()
for i in range(x):
for j in range(y):
mmltilist.append(1)
mmltilist.append(0)
return mmltilist
其中的im代表的是Image.open()类型.
切好的图片长这样的.
只能说这样切的图片还是很粗糙,很僵硬.
下面就是分类啦.
再之后就是模型建立了.
这里我试了自己写的还有sklearn svm和sklearn neural_network.发现最后一个的识别正确率高的多.不知道是不是我样本问题QAQ.
下面是模型建立的代码
from sklearn.neural_network import MLPClassifier
def clf():
clf=MLPClassifier()
X=list()
for j in os.listdir("douplings/douplings-{}".format(i)):
mmltilist.append(TotallyShit(Image.open("douplings/douplings-{0}/{1}".format(i,j)).convert("L")))
X.append(i)
clf.fit(mmltilist,X)
return clf
大概的意思是从图片源中读取图片和label然后放到模型中去跑吧.
之后便是图像匹配啦.
def get_captcha(self):
with open("test.jpg","wb") as f:
f.write(self.session.get(self.live_captcha_url).content)
gim=Image.open("test.jpg").convert("L")
recognize_list=list()
np_part_array=np.array(part).reshape(1,-1)
predict_num=int(self.clf.predict(np_part_array)[0])
if predict_num==11:
recognize_list.append("+")
elif predict_num==10:
recognize_list.append("-")
recognize_list.append(str(predict_num))
return ''.join(recognize_list)
最后eval一下识别出来的字符串就得出结果了..
顺便提一句现在的bilibili登陆改成rsa加密了,麻蛋,以前的脚本全部作废,心好痛.
登陆的代码.
import time
import requests
import rsa
r=requests.session()
data=r.get("act=getkey_="+str(int(time.time()*1000))).json()
pub_key=rsa.PublicKey.load_pkcs1_openssl_pem(data['key'])
payload = {
'keep': 1,
'captcha': '',
'userid': "youruserid",
}
r.post("",data=payload)
以上就是土嘎嘎小编为大家整理的pythonclf函数相关主题介绍,如果您觉得小编更新的文章只要能对粉丝们有用,就是我们最大的鼓励和动力,不要忘记讲本站分享给您身边的朋友哦！！