pythonclf函数,python clf

python中clf.fit什么意思

python训练的模型做预测：

创新互联公司是一家专业提供藤县企业网站建设,专注与成都网站制作、网站设计、H5场景定制、小程序制作等业务。10年已为藤县众多企业、政府机构等服务。创新互联专业网站建设公司优惠进行中。

如下：

1、先要按照scikit-learn包，先安装下面三个依赖包：

Python (= 2.6 or = 3.3),

NumPy (= 1.6.1),

SciPy (= 0.9).

然后在cmd命令行中输入：

pip install -U scikit-learn

扩展资料

应用

系统编程：提供API（Application Programming Interface应用程序编程接口），能方便进行系统维护和管理，Linux下标志性语言之一，是很多系统管理员理想的编程工具。

图形处理：有PIL、Tkinter等图形库支持，能方便进行图形处理。

数学处理：NumPy扩展提供大量与许多标准数学库的接口。

文本处理：python提供的re模块能支持正则表达式，还提供SGML，XML分析模块，许多程序员利用python进行XML程序的开发。

数据库编程：程序员可通过遵循Python DB-API（数据库应用程序编程接口）规范的模块与Microsoft SQL Server，Oracle，Sybase，DB2，MySQL、SQLite等数据库通信。python自带有一个Gadfly模块，提供了一个完整的SQL环境。

网络编程：提供丰富的模块支持sockets编程，能方便快速地开发分布式应用程序。很多大规模软件开发计划例如Zope，Mnet 及BitTorrent. Google都在广泛地使用它。

Web编程：应用的开发语言，支持最新的XML技术。

参考资料来源：百度百科-计算机程序设计语言

python 类matlab中的clf命令

建议你用面向对象的方式去画图，一个图作为一个对象，这样每次调用一个对象的保存图片方法就可以只保存当前图片。

你这种用法第三张图会有三个子图是因为三个子图都画在同一个对象上。

为了将面向对象的绘图库包装成只使用函数的调用接口，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(2) # 创建图表2

ax1 = plt.subplot(211) # 在图表2中创建子图1

ax2 = plt.subplot(212) # 在图表2中创建子图2

x = np.linspace(0, 3, 100)

for i in xrange(5):

plt.figure(1) ❶ # 选择图表1

plt.plot(x, np.exp(i*x/3))

plt.sca(ax1) ❷ # 选择图表2的子图1

plt.plot(x, np.sin(i*x))

plt.sca(ax2) # 选择图表2的子图2

plt.plot(x, np.cos(i*x))

plt.show()

python3.5做分类时，混淆矩阵加在哪一步

preface：做着最近的任务，对数据处理，做些简单的提特征，用机器学习算法跑下程序得出结果，看看哪些特征的组合较好，这一系列流程必然要用到很多函数，故将自己常用函数记录上。应该说这些函数基本上都会用到，像是数据预处理，处理完了后特征提取、降维、训练预测、通过混淆矩阵看分类效果，得出报告。

1.输入

从数据集开始，提取特征转化为有标签的数据集，转为向量。拆分成训练集和测试集，这里不多讲，在上一篇博客中谈到用StratifiedKFold()函数即可。在训练集中有data和target开始。

2.处理

[python] view plain copy

def my_preprocessing(train_data):

from sklearn import preprocessing

X_normalized = preprocessing.normalize(train_data ,norm = "l2",axis=0)#使用l2范式，对特征列进行正则

return X_normalized

def my_feature_selection(data, target):

from sklearn.feature_selection import SelectKBest

from sklearn.feature_selection import chi2

data_new = SelectKBest(chi2, k= 50).fit_transform(data,target)

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_

print sum(main_var)*0.9

import matplotlib.pyplot as plt

n = 15

plt.plot(main_var[:n])

plt.show()

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()函数：

主要使用sklearn的preprocessing函数中的normalize()函数，默认参数为l2范式，对特征列进行正则处理。即每一个样例，处理标签，每行的平方和为1.

my_feature_selection()函数：

使用sklearn的feature_selection函数中SelectKBest()函数和chi2()函数，若是用词袋提取了很多维的稀疏特征，有必要使用卡方选取前k个有效的特征。

my_PCA()函数：

主要用来观察前多少个特征是主要特征，并且画图。看看前多少个特征占据主要部分。

clf_train()函数：

可用多种机器学习算法，如SVM, LR, RF, GBDT等等很多，其中像SVM需要调参数的，有专门调试参数的函数如StratifiedKFold()（见前几篇博客）。以达到最优。

my_confusion_matrix()函数：

主要是针对预测出来的结果，和原来的结果对比，算出混淆矩阵，不必自己计算。其对每个类别的混淆矩阵都计算出来了，并且labels参数默认是排序了的。

my_classification_report()函数：

主要通过sklearn.metrics函数中的classification_report()函数，针对每个类别给出详细的准确率、召回率和F-值这三个参数和宏平均值，用来评价算法好坏。另外ROC曲线的话，需要是对二分类才可以。多类别似乎不行。

主要参考sklearn官网

用python实现红酒数据集的ID3,C4.5和CART算法？

ID3算法介绍

ID3算法全称为迭代二叉树3代算法（Iterative Dichotomiser 3）

该算法要先进行特征选择，再生成决策树，其中特征选择是基于“信息增益”最大的原则进行的。

但由于决策树完全基于训练集生成的，有可能对训练集过于“依赖”，即产生过拟合现象。因此在生成决策树后，需要对决策树进行剪枝。剪枝有两种形式，分别为前剪枝（Pre-Pruning）和后剪枝（Post-Pruning），一般采用后剪枝。

信息熵、条件熵和信息增益

信息熵：来自于香农定理，表示信息集合所含信息的平均不确定性。信息熵越大，表示不确定性越大，所含的信息量也就越大。

设x 1 , x 2 , x 3 , . . . x n {x_1, x_2, x_3, ...x_n}x

,...x

为信息集合X的n个取值，则x i x_ix

的概率：

P ( X = i ) = p i , i = 1 , 2 , 3 , . . . , n P(X=i) = p_i, i=1,2,3,...,n

P(X=i)=p

,i=1,2,3,...,n

信息集合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

∑

logp

条件熵：指已知某个随机变量的情况下，信息集合的信息熵。

设信息集合X中有y 1 , y 2 , y 3 , . . . y m {y_1, y_2, y_3, ...y_m}y

,...y

组成的随机变量集合Y，则随机变量（X，Y）的联合概率分布为

P ( x = i , y = j ) = p i j P(x=i,y=j) = p_{ij}

P(x=i,y=j)=p

条件熵：

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

)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

)=−

j=1

∑

p(y

)

i=1

∑

p(x

∣y

)logp(x

∣y

)

和贝叶斯公式：

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)

p(x

)=p(x

∣y

)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)}}

H(X∣Y)=

j=1

∑

i=1

∑

p(x

)log

p(x

)

p(x

)

信息增益：信息熵-条件熵，用于衡量在知道已知随机变量后，信息不确定性减小越大。

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)

entropy -= p * math.log(p, 2)

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)

else:

classLabel = firstGenDict[k]

return classLabel

下面用鸢尾花数据集对该算法进行测试。由于ID3算法只能用于标称型数据，因此用在对连续型的数值数据上时，还需要对数据进行离散化，离散化的方法稍后说明，此处为了简化，先使用每一种特征所有连续性数值的中值作为分界点，小于中值的标记为1，大于中值的标记为0。训练1000次，统计准确率均值。

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])

featNames[i] = featNames[i]+'='+'{:.3f}'.format(splitPoint)

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)

输出结果为：score: 0.7335，即准确率有73%。每次训练和预测的准确率分布如下：

数据离散化

然而，在上例中对特征值离散化的划分点实际上过于“野蛮”，此处介绍一种通过信息增益最大的标准来对数据进行离散化。原理很简单，当信息增益最大时，说明用该点划分能最大程度降低数据集的不确定性。

具体步骤如下：

对每个特征所包含的数值型特征值排序

对相邻两个特征值取均值，这些均值就是待选的划分点

用每一个待选点把该特征的特征值划分成两类，小于该特征点置为1，大于该特征点置为0，计算此时的条件熵，并计算出信息增益

选择信息使信息增益最大的划分点进行特征离散化

实现代码如下：

def filterRawData(dataSet, colIndex, value, tag):

""" 用于把每个特征的连续值按照区分点分成两类，加入tag参数，可用于标记筛选的是哪一部分数据"""

filterDataList = []

for r in dataSet:

if (tag and r[colIndex] = value) or ((not tag) and r[colIndex] value):

newR = r[:colIndex]

newR = np.append(newR, (r[colIndex + 1:]))

filterDataList.append(newR)

return np.array(filterDataList)

def dataDiscretization(dataSet, featName):

""" 对数据每个特征的数值型特征值进行离散化 """

featureNum = dataSet.shape[1] - 1

entropy = calShannonEnt(dataSet)

for featIndex in range(featureNum): #对于每一个特征

uniqueValues = sorted(np.unique(dataSet[:, featIndex]))

meanPoint = []

for i in range(len(uniqueValues) - 1): # 求出相邻两个值的平均值

meanPoint.append(float(uniqueValues[i+1] + uniqueValues[i]) / 2.0)

bestInfoGain = 0.0

bestMeanPoint = -1

for mp in meanPoint: #对于每个划分点

subEntropy = 0.0 #计算该划分点的信息熵

for tag in range(2): #分别划分为两类

subDataSet = filterRawData(dataSet, featIndex, mp, tag)

p = 1.0 * len(subDataSet) / len(dataSet)

subEntropy += p * calShannonEnt(subDataSet)

## 计算信息增益

infoGain = entropy - subEntropy

## 选择最大信息增益

if infoGain = bestInfoGain:

bestInfoGain = infoGain

bestMeanPoint = mp

featName[featIndex] = featName[featIndex] + "=" + "{:.3f}".format(bestMeanPoint)

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 = []

scoreL_sk = []

for i in range(1000): #对该过程进行1000次

featNames = iris.feature_names[:]

trainData, testData = train_test_split(data) #区分测试集和训练集

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]]

decisionTree = creatDecisionTree(trainData, featNames)

classifyLable = [classify(decisionTree, featNames, td) for td in testData]

scoreL.append(1.0 * sum(classifyLable == testData[:, -1]) / len(classifyLable))

clf = DecisionTreeClassifier('entropy')

clf.fit(trainData[:, :-1], trainData[:, -1])

clf.predict(testData[:, :-1])

scoreL_sk.append(clf.score(testData[:, :-1], testData[:, -1]))

print 'score: ', np.mean(scoreL)

print 'score-sk: ', np.mean(scoreL_sk)

fig = plt.figure(figsize=(10, 4))

plt.subplot(1,2,1)

pd.Series(scoreL).hist(grid=False, bins=10)

plt.subplot(1,2,2)

pd.Series(scoreL_sk).hist(grid=False, bins=10)

plt.show()

两者准确率分别为：

score: 0.7037894736842105

score-sk: 0.7044736842105263

准确率分布如下：

两者的结果非常一样。

（但是。。为什么根据信息熵离散化得到的准确率比直接用均值离散化的准确率还要低啊？？哇的哭出声。。）

最后一次决策树图形如下：

决策树剪枝

由于决策树是完全依照训练集生成的，有可能会有过拟合现象，因此一般会对生成的决策树进行剪枝。常用的是通过决策树损失函数剪枝，决策树损失函数表示为:

C a ( T ) = ∑ t = 1 T N t H t ( T ) + α ∣ T ∣ C_a(T) = \sum_{t=1}^TN_tH_t(T) +\alpha|T|

(T)=

t=1

∑

(T)+α∣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=1

(T)是决策树的经验损失函数当随着T的增加，该节点被不停的划分的时候，熵值可以达到最小，然而T的增加会使后项的值增大。决策树损失函数要做的就是在两者之间进行平衡，使得该值最小。

对于决策树损失函数的理解，如何理解决策树的损失函数? - 陶轻松的回答 - 知乎这个回答写得挺好，可以按照答主的思路理解一下

C4.5算法

ID3算法通过信息增益来进行特征选择会有一个比较明显的缺点：即在选择的过程中该算法会优先选择类别较多的属性（这些属性的不确定性小，条件熵小，因此信息增益会大），另外，ID3算法无法解决当每个特征属性中每个分类都只有一个样本的情况（此时每个属性的条件熵都为0）。

C4.5算法ID3算法的改进，它不是依据信息增益进行特征选择，而是依据信息增益率，它添加了特征分裂信息作为惩罚项。定义分裂信息：

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

∣X∣

∣X

∣

则信息增益率为：

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)

关于ID3和C4.5算法

在学习分类回归决策树算法时，看了不少的资料和博客。关于这两个算法，ID3算法是最早的分类算法，这个算法刚出生的时候其实带有很多缺陷：

无法处理连续性特征数据

特征选取会倾向于分类较多的特征

没有解决过拟合的问题

没有解决缺失值的问题

即该算法出生时是没有带有连续特征离散化、剪枝等步骤的。C4.5作为ID3的改进版本弥补列ID3算法不少的缺陷：

通过信息最大增益的标准离散化连续的特征数据

在选择特征是标准从“最大信息增益”改为“最大信息增益率”

通过加入正则项系数对决策树进行剪枝

对缺失值的处理体现在两个方面：特征选择和生成决策树。初始条件下对每个样本的权重置为1。

特征选择：在选取最优特征时，计算出每个特征的信息增益后，需要乘以一个**“非缺失值样本权重占总样本权重的比例”**作为系数来对比每个特征信息增益的大小

生成决策树：在生成决策树时，对于缺失的样本我们按照一定比例把它归属到每个特征值中，比例为该特征每一个特征值占非缺失数据的比重

关于C4.5和CART回归树

作为ID3的改进版本，C4.5克服了许多缺陷，但是它自身还是存在不少问题：

C4.5的熵运算中涉及了对数运算，在数据量大的时候效率非常低。

C4.5的剪枝过于简单

C4.5只能用于分类运算不能用于回归

当特征有多个特征值是C4.5生成多叉树会使树的深度加深

————————————————

原文链接：

Python版本的问题 sklearn包的neighbors函数

我在学习时也遇到了同样的问题，我是这样解决的clf.fit(list(xy_normalized), labels)

主要原因是Python2和Python3中对zip函数做了一些修改，Python2中的zip函数返回的是一个list，而Python3的zip函数返回的是一个对象。

我目前也在学习Python+ML，大家可以共同学习，共同探讨。

如何利用Python做简单的验证码识别

先是获取验证码样本。。。我存了大概500个。

用dia测了测每个字之间的间距，直接用PIL开始切。

from PIL import Image

for j in range(0,500):

f=Image.open("../test{}.jpg".format(j))

for i in range(0,4):

f.crop((20+20*i,0,40+20*i,40)).save("test{0}-{1}.jpg".format(j,i+1))

上面一段脚本的意思是把jpg切成四个小块然后保存

之后就是二值化啦。

def TotallyShit(im):

x,y=im.size

mmltilist=list()

for i in range(x):

for j in range(y):

if im.getpixel((i,j))200:

mmltilist.append(1)

else:

mmltilist.append(0)

return mmltilist

咳咳，不要在意函数的名字。上面的一段代码的意思是遍历图片的每个像素点，颜色数值小于200的用1表示，其他的用0表示。

其中的im代表的是Image.open()类型。

切好的图片长这样的。

只能说这样切的图片还是很粗糙，很僵硬。

下面就是分类啦。

把0-9，“+”，”-“的图片挑好并放在不同的文件夹里面，这里就是纯体力活了。

再之后就是模型建立了。

这里我试了自己写的还有sklearn svm和sklearn neural_network。发现最后一个的识别正确率高的多。不知道是不是我样本问题QAQ。

下面是模型建立的代码

from sklearn.neural_network import MLPClassifier

import numpy as np

def clf():

clf=MLPClassifier()

mmltilist=list()

X=list()

for i in range(0,12):

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()

for i in range(0,4):

part=TotallyShit(gim.crop((20+20*i,0,40+20*i,40)))

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("-")

else:

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",

'pwd': b64encode(rsa.encrypt((data['hash'] +"yourpassword").encode(), pub_key)).decode(),

}

r.post("",data=payload)

本文名称：pythonclf函数,python clf
本文地址：http://dzwzjz.com/article/hsppge.html

大橙子网站建设，新征程启航

pythonclf函数,python clf

python中clf.fit什么意思

python 类matlab中的clf命令

python3.5做分类时，混淆矩阵加在哪一步

用python实现红酒数据集的ID3,C4.5和CART算法？

Python版本的问题 sklearn包的neighbors函数

如何利用Python做简单的验证码识别

其他资讯