https://www.cnblogs.com/lianyingteng/p/7811126.html
传统的机器学习任务从开始到建模的一般流程是：获取数据 -& 数据预处理 -& 训练建模 -& 模型评估 -& 预测，分类。本文我们将依据传统机器学习的流程，看看在每一步流程中都有哪些常用的函数以及它们的用法是怎么样的。希望你看完这篇文章可以最为快速的开始你的学习任务。
1. 获取数据
1.1 导入sklearn数据集
　　sklearn中包含了大量的优质的数据集，在你学习机器学习的过程中，你可以通过使用这些数据集实现出不同的模型，从而提高你的动手实践能力，同时这个过程也可以加深你对理论知识的理解和把握。（这一步我也亟需加强，一起加油！^-^）
首先呢，要想使用sklearn中的数据集，必须导入datasets模块：
from sklearn import datasets
&下图中包含了大部分sklearn中数据集，调用方式也在图中给出，这里我们拿iris的数据来举个例子：
iris = datasets.load_iris() # 导入数据集
X = iris.data # 获得其特征向量
y = iris.target # 获得样本label
1.2 创建数据集
　　你除了可以使用sklearn自带的数据集，还可以自己去创建训练样本，具体用法参见《》，这里我们简单介绍一些，sklearn中的samples generator包含的大量创建样本数据的方法：
下面我们拿分类问题的样本生成器举例子：
from sklearn.datasets.samples_generator import make_classification
X, y = make_classification(n_samples=6, n_features=5, n_informative=2,
n_redundant=2, n_classes=2, n_clusters_per_class=2, scale=1.0,
random_state=20)
# n_samples：指定样本数
# n_features：指定特征数
# n_classes：指定几分类
# random_state：随机种子，使得随机状可重
&&& for x_,y_ in zip(X,y):
print(y_,end=': ')
0: [-0.6600737
-0.0558978
0..1003977
1: [ 0.4113583
0....059838
1: [ 1.....]
0: [-1.....]
0: [-3.....]
1: [ 1.....]
2. 数据预处理
　　数据预处理阶段是机器学习中不可缺少的一环，它会使得数据更加有效的被模型或者评估器识别。下面我们来看一下sklearn中有哪些平时我们常用的函数：
from sklearn import preprocessing
2.1 数据归一化
　　为了使得训练数据的标准化规则与测试数据的标准化规则同步，preprocessing中提供了很多Scaler：
data = [[0, 0], [0, 0], [1, 1], [1, 1]]
# 1. 基于mean和std的标准化
scaler = preprocessing.StandardScaler().fit(train_data)
scaler.transform(train_data)
scaler.transform(test_data)
# 2. 将每个特征值归一化到一个固定范围
scaler = preprocessing.MinMaxScaler(feature_range=(0, 1)).fit(train_data)
scaler.transform(train_data)
scaler.transform(test_data)
#feature_range: 定义归一化范围，注用（）括起来
2.2 正则化（normalize）
　　当你想要计算两个样本的相似度时必不可少的一个操作，就是正则化。其思想是：首先求出样本的p-范数，然后该样本的所有元素都要除以该范数，这样最终使得每个样本的范数都为1。
&&& X = [[ 1., -1.,
&&& X_normalized = preprocessing.normalize(X, norm='l2')
&&& X_normalized
array([[ 0.40..., -0.40...,
0.70..., -0.70...]])
&2.3 one-hot编码
　　one-hot编码是一种对离散特征值的编码方式，在LR模型中常用到，用于给线性模型增加非线性能力。
data = [[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]]
encoder = preprocessing.OneHotEncoder().fit(data)
enc.transform(data).toarray()
3. 数据集拆分
　　在得到训练数据集时，通常我们经常会把训练数据集进一步拆分成训练集和验证集，这样有助于我们模型参数的选取。
# 作用：将数据集划分为 训练集和测试集
# 格式：train_test_split(*arrays, **options)
from sklearn.mode_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
arrays：样本数组，包含特征向量和标签
test_size：
　　float-获得多大比重的测试样本 （默认：0.25）
　　int - 获得多少个测试样本
train_size: 同test_size
random_state:
　　int - 随机种子（种子固定，实验可复现）
shuffle - 是否在分割之前对数据进行洗牌（默认True）
分割后的列表，长度=2*len(arrays),
　　(train-test split)
4. 定义模型
　　在这一步我们首先要分析自己数据的类型，搞清出你要用什么模型来做，然后我们就可以在sklearn中定义模型了。sklearn为所有模型提供了非常相似的接口，这样使得我们可以更加快速的熟悉所有模型的用法。在这之前我们先来看看模型的常用属性和功能：
# 拟合模型
model.fit(X_train, y_train)
# 模型预测
model.predict(X_test)
# 获得这个模型的参数
model.get_params()
# 为模型进行打分
model.score(data_X, data_y) # 线性回归：R square； 分类问题： acc
&4.1 线性回归
from sklearn.linear_model import LinearRegression
# 定义线性回归模型
model = LinearRegression(fit_intercept=True, normalize=False,
copy_X=True, n_jobs=1)
fit_intercept：是否计算截距。False-模型没有截距
normalize： 当fit_intercept设置为False时，该参数将被忽略。 如果为真，则回归前的回归系数X将通过减去平均值并除以l2-范数而归一化。
n_jobs：指定线程数
　　　　　　
&4.2 逻辑回归LR
from sklearn.linear_model import LogisticRegression
# 定义逻辑回归模型
model = LogisticRegression(penalty=’l2’, dual=False, tol=0.0001, C=1.0,
fit_intercept=True, intercept_scaling=1, class_weight=None,
random_state=None, solver=’liblinear’, max_iter=100, multi_class=’ovr’,
verbose=0, warm_start=False, n_jobs=1)
penalty：使用指定正则化项（默认：l2）
dual: n_samples & n_features取False（默认）
C：正则化强度的反，值越小正则化强度越大
n_jobs: 指定线程数
random_state：随机数生成器
fit_intercept: 是否需要常量
&4.3 朴素贝叶斯算法NB
from sklearn import naive_bayes
model = naive_bayes.GaussianNB() # 高斯贝叶斯
model = naive_bayes.MultinomialNB(alpha=1.0, fit_prior=True, class_prior=None)
model = naive_bayes.BernoulliNB(alpha=1.0, binarize=0.0, fit_prior=True, class_prior=None)
文本分类问题常用MultinomialNB
alpha：平滑参数
fit_prior：是否要学习类的先验概率；false-使用统一的先验概率
class_prior: 是否指定类的先验概率；若指定则不能根据参数调整
binarize: 二值化的阈值，若为None，则假设输入由二进制向量组成
&4.4 决策树DT
from sklearn import tree
model = tree.DecisionTreeClassifier(criterion=’gini’, max_depth=None,
min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0,
max_features=None, random_state=None, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
class_weight=None, presort=False)
criterion ：特征选择准则gini/entropy
max_depth：树的最大深度，None-尽量下分
min_samples_split：分裂内部节点，所需要的最小样本树
min_samples_leaf：叶子节点所需要的最小样本数
max_features: 寻找最优分割点时的最大特征数
max_leaf_nodes：优先增长到最大叶子节点数
min_impurity_decrease：如果这种分离导致杂质的减少大于或等于这个值，则节点将被拆分。
4.5 支持向量机SVM
from sklearn.svm import SVC
model = SVC(C=1.0, kernel=’rbf’, gamma=’auto’)
C：误差项的惩罚参数C
gamma: 核相关系数。浮点数，If gamma is ‘auto’ then 1/n_features will be used instead.
&4.6 k近邻算法KNN
from sklearn import neighbors
#定义kNN分类模型
model = neighbors.KNeighborsClassifier(n_neighbors=5, n_jobs=1) # 分类
model = neighbors.KNeighborsRegressor(n_neighbors=5, n_jobs=1) # 回归
n_neighbors： 使用邻居的数目
n_jobs：并行任务数
4.7 多层感知机（神经网络）
from sklearn.neural_network import MLPClassifier
# 定义多层感知机分类算法
model = MLPClassifier(activation='relu', solver='adam', alpha=0.0001)
hidden_layer_sizes: 元祖
activation：激活函数
solver ：优化算法{‘lbfgs’, ‘sgd’, ‘adam’}
alpha：L2惩罚(正则化项)参数。
5. 模型评估与选择篇
5.1 交叉验证
from sklearn.model_selection import cross_val_score
cross_val_score(model, X, y=None, scoring=None, cv=None, n_jobs=1)
model：拟合数据的模型
cv ： k-fold
scoring: 打分参数-‘accuracy’、‘f1’、‘precision’、‘recall’ 、‘roc_auc’、'neg_log_loss'等等
5.2 检验曲线
　　使用检验曲线，我们可以更加方便的改变模型参数，获取模型表现。
from sklearn.model_selection import validation_curve
train_score, test_score = validation_curve(model, X, y, param_name, param_range, cv=None, scoring=None, n_jobs=1)
model:用于fit和predict的对象
X, y: 训练集的特征和标签
param_name：将被改变的参数的名字
param_range： 参数的改变范围
cv：k-fold
train_score: 训练集得分（array）
test_score: 验证集得分（array）
6. 保存模型
　　最后，我们可以将我们训练好的model保存到本地，或者放到线上供用户使用，那么如何保存训练好的model呢？主要有下面两种方式：
6.1 保存为pickle文件
import pickle
# 保存模型
with open('model.pickle', 'wb') as f:
pickle.dump(model, f)
# 读取模型
with open('model.pickle', 'rb') as f:
model = pickle.load(f)
model.predict(X_test)
6.2 sklearn自带方法joblib
from sklearn.externals import joblib
# 保存模型
joblib.dump(model, 'model.pickle')
model = joblib.load('model.pickle')
阅读(...) 评论()在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
import numpy as np
import random
from sklearn.feature_extraction.text import TfidfVectorizer
import pandas as pd
from sklearn import svm
from sklearn.cross_validation import train_test_split
from sklearn.linear_model import LogisticRegression
def getTokens(inputString):
# custom tokenizer. ours tokens are characters rather than full words
tokens = []
for i in inputString:
tokens.append(i)
return tokens
filepath = '/data.csv' #path for password file
data = pd.read_csv(filepath, ',', error_bad_lines=False)
data = pd.DataFrame(data)
passwords = np.array(data)
random.shuffle(passwords)
# shuffling randomly for robustness
y = [d[1] for d in passwords]
allpasswords = [d[0] for d in passwords]
# actual passwords
vectorizer = TfidfVectorizer(tokenizer=getTokens)
# vectorizing
X = vectorizer.fit_transform(allpasswords)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42)
#splitting
lgs = LogisticRegression(penalty='l2',multi_class='ovr')
lgs.fit(X_train, y_train)
print(lgs.score(X_test, y_test))
# svr = svm.SVR()
# svr.fit(X_train, y_train)
# print(svr.score(X_test, y_test))
# from sklearn import neighbors
# knn = neighbors.KNeighborsRegressor()
# knn.fit(X_train,y_train)
# print(knn.score(X_test,y_test))
# from sklearn import ensemble
# rf =ensemble.RandomForestRegressor(n_estimators=20)
# rf.fit(X_train,y_train)
# print(rf.score(X_test,y_test))
#more testing
X_predict = ['faizanahmad','faizanahmad123','faizanahmad##','ajd1348#28t**','ffffffffff','kuiqwasdi','uiquiuiiuiuiuiuiuiuiuiuiui','mynameisfaizan','mynameis123faizan#','faizan','123456','abcdef']
X_predict = vectorizer.transform(X_predict)
y_Predict = lgs.predict(X_predict)
#在这里更改模型名
print (y_Predict)
仿照github上一个项目多试几个训练方法，但是除了原本的线性回归别的都会很慢，长时间无响应。代码一直到向量化数据都是一样且正确的。具体代码如上，就是不知道哪里有问题，该如何解决，求指教...
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
1、你要清楚这个是个什么任务。
这是分类学习，而不是回归
2、清楚之后，看你写的代码就明白了为什么会出错
代码全是回归
# svr = svm.SVR()
# svr.fit(X_train, y_train)
# print(svr.score(X_test, y_test))
# from sklearn import neighbors
# knn = neighbors.KNeighborsRegressor()
# knn.fit(X_train,y_train)
# print(knn.score(X_test,y_test))
# from sklearn import ensemble
# rf =ensemble.RandomForestRegressor(n_estimators=20)
# rf.fit(X_train,y_train)
# print(rf.score(X_test,y_test))
如下所示（其中KNN因为是训练集是稀疏的，超出了内存，所以会出错）：
同步到新浪微博
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。没有更多推荐了，
不良信息举报
举报内容：
sklearn的train_test_split
举报原因：
原文地址：
原因补充：
最多只允许输入30个字
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！1首先是sklearn的官网：
在官网网址上可以看到很多的demo，下边这张是一张非常有用的流程图，在这个流程图中，可以根据数据集的特征，选择合适的方法。
2.sklearn使用的小例子
import numpy as np
from sklearn import datasets
from sklearn.cross_validation import train_test_split
from sklearn.neighbors import KNeighborsClassifier
iris=datasets.load_iris()
iris_X=iris.data
iris_y=iris.target
print(iris_X[:2,:])　　　　#输出数据的前2行，print(iris_y)
X_train,X_test,y_train,y_test=train_test_split(iris_X,iris_y,test_size=0.3)
#把数据集分为训练集和测试集两个部分一部分是训练集，一部分是测试集，其中测试集占了30%
print(y_train)
knn=KNeighborsClassifier()
knn.fit(X_train,y_train)
print(knn.predict(X_test))
print(y_test)
3.sklearn数据集
在上边例子中，直接使用了sklearn的数据集，在这个包中还有很多其他的数据集，数据集的网址：不仅可以使用数据集中的数据，还可以生成虚拟的数据，
sklearn中自带的数据集，以房屋数据集为例：
sklearn可以生成的数据集，回归模型中使用的数据集为例：
Parameters:
n_samples : int, optional (default=100)：The number of samples.
n_features : int, optional (default=100)：The number of features.
n_informative : int, optional (default=10)：The number of informative features, i.e., the number of features used to build the linear model used to generate the output.
n_targets : int, optional (default=1)：The number of regression targets, i.e., the dimension of the y output vector associated with a sample. By default, the output is a scalar.
bias : float, optional (default=0.0)：The bias term in the underlying linear model.
effective_rank : int or None, optional (default=None)
　　if not None:The approximate number of singular vectors required to explain most of the input data by linear combinations. Using this kind of singular spectrum in the input allows the generator to 　　reproduce the correlations often observed in practice.
　　if None:The input set is well conditioned, centered and gaussian with unit variance.
tail_strength : float between 0.0 and 1.0, optional (default=0.5)：The relative importance of the fat noisy tail of the singular values profile if effective_rank is not None.
noise : float, optional (default=0.0)：The standard deviation of the gaussian noise applied to the output.
shuffle : boolean, optional (default=True)：Shuffle the samples and the features.
coef : boolean, optional (default=False)：If True, the coefficients of the underlying linear model are returned.
random_state : int, RandomState instance or None, optional (default=None)：If int, random_state is the seed used by the ran If RandomState instance, random_state is the ran If None, the random number generator is the RandomState instance used by np.random.
X : array of shape [n_samples, n_features]：The input samples.
y : array of shape [n_samples] or [n_samples, n_targets]：The output values.
coef : array of shape [n_features] or [n_features, n_targets], optional：The coefficient of the underlying linear model. It is returned only if coef is True.
from sklearn import datasets
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
#使用以后的数据集进行线性回归
loaded_data=datasets.load_boston()
data_X=loaded_data.data
data_y=loaded_data.target
model=LinearRegression()
model.fit(data_X,data_y)
print(model.predict(data_X[:4,:]))
print(data_y[:4])
#使用生成线性回归的数据集，最后的数据集结果用散点图表示
X,y=datasets.make_regression(n_samples=100,n_features=1,n_targets=1,noise=10)
#n_samples表示样本数目，n_features特征的数目
plt.scatter(X,y)
plt.show()
&4。模型的参数
sklearn 的 model 属性和功能都是高度统一的. 你可以运用到这些属性查看 model 的参数和值等等.
from sklearn import datasets
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
#使用以后的数据集进行线性回归
loaded_data=datasets.load_boston()
data_X=loaded_data.data
data_y=loaded_data.target
model=LinearRegression()
model.fit(data_X,data_y)
print(model.predict(data_X[:4,:]))
print(data_y[:4])
print(model.coef_)
#如果y=0.1x+0.3
则此行输出的结果为0.1
print(model.intercept_)
#此行输出的结果为0.3
print(model.get_params())
#模型定义时定义的参数，如果没有定义则返回默认值
print(model.score(data_X,data_y))
#给训练模型打分，注意用在LinearR中使用R^2 conefficient of determination打分
输出的结果：
[ 30..0298606
30.5702317
{'fit_intercept': True, 'normalize': False, 'n_jobs': 1, 'copy_X': True}
&5.标准化：normalization&
normalization 在数据跨度不一的情况下对机器学习有很重要的作用.特别是各种数据属性还会互相影响的情况之下. Scikit-learn 中标准化的语句是 preprocessing.scale() . scale 以后, model 就更能从标准化数据中学到东西.
from sklearn import preprocessing #进行标准化数据时，需要引入个包
import numpy as np
from sklearn.cross_validation import train_test_split
from sklearn.datasets.samples_generator import
make_classification
from sklearn.svm import SVC
import matplotlib.pyplot as plt
X,y=make_classification(n_samples=300,n_features=2,n_redundant=0,n_informative=2,random_state=22,n_clusters_per_class=1,scale=100)
#X=preprocessing.minmax_scale(X,feature_range=(-1,1))
X=preprocessing.scale(X)
#<span style="color: #. 没有 0.
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.3)
clf.fit(X_train,y_train)
print(clf.score(X_test,y_test))
plt.scatter(X[:,0],X[:,1],c=y)
plt.show()
a=np.array([[10,2.7,3.6],
[-100,5,-2],
[120,20,40]],dtype=np.float64)
#每一列代表一个属性
print(a)　　　　　　　#标准化之前a　　　　　
print(preprocessing.scale(a))　#标准化之后的a　
6.交叉验证&cross validation（1）
sklearn 中的 cross validation 交叉验证 对于我们选择正确的 model 和model 的参数是非常有帮助的. 有了他的帮助, 我们能直观的看出不同 model 或者参数对结构准确度的影响.
from sklearn.datasets import load_iris
from sklearn.cross_validation import train_test_split
from sklearn.neighbors import KNeighborsClassifier
iris=load_iris()
iris_X=iris.data
iris_y=iris.target
X_train,X_test,y_train,y_test=train_test_split(iris_X,iris_y,random_state=4)
#把数据集分为训练集和测试集两个部分一部分是训练集，一部分是测试集，其中测试集占了30%
knn=KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train,y_train)
print(knn.score(X_test,y_test))
#<span style="color: #.
from sklearn.cross_validation import cross_val_score
knn=KNeighborsClassifier(n_neighbors=5)
score=cross_val_score(knn,iris_X,iris_y,cv=5,scoring='accuracy')
#c分成几组 scoring是准确度
print(score)
print(score.mean())
import matplotlib.pyplot as plt
k_range=range(1,31)
k_score=[]
for k in k_range:
knn=KNeighborsClassifier(n_neighbors=k)
#score=cross_val_score(knn,iris_X,iris_y,cv=10,scoring='accuracy')#for classification
loss=-cross_val_score(knn,iris_X,iris_y,cv=10,scoring='mean_squared_error') #for regression
#k_score.append(score.mean())
k_score.append(loss.mean())
plt.plot(k_range,k_score)
plt.xlabel("Value of K for KNN")
plt.ylabel("Cross-validates Accuracy")
plt.show()
k越大越容易underfitting而不是overfitting
如果想要对不同的机器学习模型来计算，可能需要把knn的值换一下
7.交叉验证&cross validation（2）
&sklearn.learning_curve 中的 learning curve 可以很直观的看出我们的 model 学习的进度,对比发现有没有 overfitting 的问题.然后我们可以对我们的 model 进行调整,克服 overfitting 的问题.
from sklearn.learning_curve import learning_curve
#可视化学习的整个过程
from sklearn.datasets import load_digits
from sklearn.svm import SVC
import matplotlib.pyplot as plt
import numpy as np
digits=load_digits()
X=digits.data
y=digits.target
train_sizes,train_loss,test_loss=learning_curve(
SVC(gamma=0.1),X,y,cv=10,scoring="mean_squared_error",
train_sizes=[0.1,0.25,0.5,0.75,1]) #记录的点是学习过程中的10%，25%等等的点
train_loss_mean= (-1)*np.mean(train_loss,axis=1)
test_loss_mean= (-1)*np.mean(test_loss,axis=1)
plt.plot(train_sizes,train_loss_mean,"o-",color="r",label="Training")
plt.plot(train_sizes,test_loss_mean,"o-",color="g",label="Cross-validation")
plt.xlabel("Training examples")
plt.ylabel("Loss")
plt.legend(loc="best")
plt.show()
&8.交叉验证&cross validation（3）
&连续三节的 cross validation让我们知道在机器学习中 validation 是有多么的重要, 这一次的 sklearn 中我们用到了 sklearn.learning_curve 当中的另外一种, 叫做 validation_curve, 用这一种 curve 我们就能更加直观看出改变 model 中的参数的时候有没有 overfitting 的问题了.这也是可以让我们更好的选择参数的方法.
from sklearn.learning_curve import validation_curve
#可视化学习的整个过程
from sklearn.datasets import load_digits
from sklearn.svm import SVC
import matplotlib.pyplot as plt
import numpy as np
digits=load_digits()
X=digits.data
y=digits.target
gamma_range=np.logspace(-6,-2.3,5)#从-6到-2.3取5个点
train_loss,test_loss=validation_curve(
SVC(),X,y,param_name="gamma",param_range=gamma_range,cv=10,scoring="mean_squared_error")
train_loss_mean= (-1)*np.mean(train_loss,axis=1)
test_loss_mean= (-1)*np.mean(test_loss,axis=1)
plt.plot(gamma_range,train_loss_mean,"o-",color="r",label="Training")
plt.plot(gamma_range,test_loss_mean,"o-",color="g",label="Cross-validation")
plt.xlabel("gamma")
plt.ylabel("Loss")
plt.legend(loc="best")
plt.show()
9，存储模型：
我们练习好了一个 model 以后总需要保存和再次预测, 所以保存和读取我们的 sklearn model 也是同样重要的一步.本文采用了两种方法来存储
from sklearn import svm
from sklearn import datasets
clf=svm.SVC()
iris=datasets.load_iris()
X,y=iris.data,iris.target
clf.fit(X,y)
#method1:pickle
import pickle
with open('save/clf.pickle','wb')as f:
pickle.dump(clf,f)
with open('save/clf.pickle','rb') as f:
clf=pickle.load(f)
print(clf.predict(X[0:1]))
#method2:joblib
from sklearn.externals import joblib
joblib.dump(clf,'save/clf.pkl')
clf3=joblib.load('save/clf.pkl')
print(clf3.predict(X[0:1]))
&youtube学习 ：
阅读(...) 评论()