机器学习常用函数解析

机器学习常用函数解析

逻辑回归

from sklearn.preprocessing import StandardScaler

1. StandardScaler(copy=True, with_mean=True, with_std=True)
	使用:
		scaler = StandardScaler(copy=True, with_mean=True, with_std=True)
		
	参数:
		copy: copy=True不会inplace数据
		with_mean: with_mean=True会让数据的均值为0
		with_std: with_std=True会让数据的方差为1
		
	返回结果:
		一个StandardScaler对象

	联系:
		要使用StandardScaler对象, 一般需要与$2配合		
	PS:
		scaler.copy = False
		scaler.with_mean = False
		scaler.with_std = False
 		可以通过赋值的方式修改copy, with_mean, with_std属性值
		
		scaler的其他属性:
			mean_: 均值
			std_: 方差
	 
	

2.	scaler.fit(X, y=None)
	使用:
		data = [[1, 2], [3, 4], [5, 6]]
		scaler = scaler.fit(data)
	
	参数:
		X: 一个array-like的数据, 是矩阵(矩阵至少是二维的, 所以data = [1, 2, 3]不可以)的形式即可
		y: 现在已经不再使用了, 转移到了Pipeline类中了
	返回结果:
		一个StandardScaler对象
	
	联系:
		fit函数在StandardScaler对象创建出来就要调用, 因为fig函数中封装的算法是后续继续调用scaler对象的API的基础
		一般在fit之后就会使用$3函数
	PS:

3. scaler.transform(X, copy=None)	:
	使用:
		data = scaler.transform(data)
	
	参数:
		X: 一个array-like的数据, 是矩阵
		copy: bool值, 一般使用默认即可
	
	返回结果:
		nd.array
	
	联系:
		这里使用scaler.transform与scaler.fit_transform函数一样
		均值和方差缩放都是按照列来的, 见$4
		
		scaler.fit_transform函数的效果与$5一样
		
		fit_transform(X)
			参数:
				X: array-like
			返回:
				np.array
			PS:
				使用的也挺方便的, 但是还是推荐使用fit(X), transform(X)	
	PS:
		
		$1-$3这个步骤常用于特征中有一个方差不稳定, 就采用sklearn的preprocessing模块去均值和方差缩放
		
4. data.mean(axis=0), scaler.std(axis=0)
	使用:
		In [97]: print(data.mean(axis=0))
		Out[98]: array([0., 0.])
		
		In [99]: print(data.std(axis=0))
		Out [100]: array([1., 1.])
	
	参数:
		axis=None: 0表示列, 1表示行, None表示全部
	
	返回结果:
		nd.array
	
	PS:
		这里的data是np.array, 所以这里的mean和std参见numpy.mean和numpy.std


5. scale(X, axis=0, with_mean=True, with_std=True, copy=True)
	使用:
 		data = scale(data)
 		
 	参数:
 		X: array-like矩阵
 		axis=0: 0表示列优先, 1表示行优先
 		with_mean=True: True表示去均值化
 		with_std=True: True表示对方差进行缩放
 		copy=True: True表示inplace, 不会修改原始数据
 		
 	返回结果:
 		nd.array
 		
 	联系:
 		与scaler.fit_transform功能一样, 但是与scaler.fit(data), scaler.transform(data)相比, scaler这个对象可以存储更多的数据, 如.mean_, .scale_等, 这里的mean_和scale_属性都是
 		scaler.fit(X)中的X而言的, 调用了scaler.transform(X)也不会改变, 所以相比较于直接使用scale(X)函数, scaler.transform函数可以保存原始的值

from sklearn.linear_model import LogisticRegression

1. LogisticRegression(self, 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)
	使用:
		lr = LogisticRegression(C='0.01', penalty='l1') # 最长用的, 延伸一下, 一般默认很多库的函数的默认参数都是设计好的, 很多很多情况下, 不需要修改
	
	参数:
		penalty='l2‘: 正则化惩罚的算法类型, 默认为l2, l2对应的solver='liblinear'这个默认参数, 在penalty='l2'时, solver有很多参数, 但是为l1时之后'liblinear'
		C: 正则化惩罚的参数, 小于1, 去零点多
	
	返回:
		LogisticRegression对象
	
	联系:
		得到lr对象之后, 会立马调用$2方法计算出目标函数, 在sklearn库中, 所有求目标函数的方法名为$2

2、 lr.fit(self, X, y, sample_weight=None)
	使用:
		lr.fit(X_train, y_train)
	
	参数:
		X: 训练集中的特征矩阵, array-like
		y: 训练集中的标签向量, array-like, 一维的, 一般小写的为一维的
	
	返回:
		None
	
	联系:
		调用了fit函数之后, 就在lr中封装了一个目标函数, 一般调用$3方法进行测试

3. lr.predict(self, X)
	使用:
		y_pred = lr.predict(X_test)
	
	参数:
		X: array-like
	
	返回:
		nd.array
		里面的值时候两种
	联系:
		该方法计算默认的阈值为0.5, 我们无法修改, 但是使用类似的$4方法可以修改

4. lr.predict_proba(self, X)
	使用:
		y_pred_probability = lr.predict_proba(X_test) 
	
	参数:
		X: array-like
	
	返回:
		nd.array
		存放的是fit方法计算出来的目标函数根据自变量X_test得出来的直接结果值, 因为逻辑回归的推导, 结果在0-1之间, 成为概率
	
	联系:
		自定义阈值, y_pred_probability_bool = y_pred_probability[:, 1] > your_threhold
		延伸一下:
			sklearn.metrics库中的confusion_matrix函数的构造函数__init__(y_true, y_pred, labels=None, sample_weight=None)
			中y_true理所当然为测试标签集, y_pred可以predict方法得出的array-like的nd.array, 也可以是bool类型的nd.array, 遇到True表示肯定, False表示False
			confusion_matrix()返回np.array
 

from imblearn.over_sampling import SMOTE

1. SMOTE(self, ratio='auto', random_state=None, k=None, k_neighbors=5, m=None, m_neighbors=10, out_step=0.5, kind='regular', svm_estimator=None, n_jobs=1)
	使用:
		over_sample = SMOTE(random_state=0)	
	参数:
		random_state=None:
	
	返回:
		SMOTE对象
	
	联系:
		该函数用于过采样, 实际上相比于下采样, 使用过采样的情况多, 因为过采样数据量大
		得到over_sample对象之后, 会调用$2方法进行过采样
	
2. over_sample.fit_sample(self, X, y)
	使用:
		over_sampled_features, over_sampled_label = over_sample.fit_sample(X_train, y_train)
	参数:			
		X: array-like
		y: array-like, 一维的	
	
	返回:
		tuple
		凡是返回的形式一个x1, x2, x3的都可以判定一个函数或者方法的返回值为tuple
	联系:
		检查y列表中的不同元素的个数, 使用SMOTE算法将少的元素的个数达到和多的一个
		在这之后, 就是一般的操作了, 比如现在我们通过fit_sample函数得到了过采样的样本, 接着使用K-CV(KFold cross validation)进行交叉验证, 再使用LogisticRegression的fit, predict_pro
		ba再配合recall_score, confusion_matrix分析 

from sklearn.model_selection import KFold

1. __init__(self, n_splits=3, shuffle=False, random_state=None)
	使用:
		kf = KFlod(n_splits=5, shuffle=False, random_state=0)
		
	参数:
		n_splits: 将之后调用$2方法, 将该方法中的矩阵切成几份
		shuffle: 不清楚 
		random_state: 不清楚
	返回:
		KFlod对象
	
	联系:
		kf在调用了$2方法之后一般在for循环中进行迭代, 取出index
		KFold对象与$3对象类似, 但是$3采用分层的方法对X进行划分下标
	PS:
		在sklearn中, 一个构造函数中默认参数, 在后去是可以直接修改的, 默认参数就是sklearn的属性, 直接为属性赋值即可
	
2. kf.split(X, y=None, groups=None):
	使用:
		for train_index, test_index in kf.split(X):
			print('%s %s'%(train_index, test_index))
		
	参数:
		X: array-like, 在help文档中显示的格式(n_samples, n_features), 这是什么意思呢? n表示number of, 这个格式是X的shape属性返回的元组, 告诉我们要传入的array-like的shape
		y=None: array-like, 为None表示无监督学习, 按照管理, 在sklearn中有许多的默认参数都是设计好的, 一般不需要我们修改, 反而比较关注位置参数
		groups=None: 没用过
	
	返回:
		generator生成器, 主要用于迭代, 在for循环中, 当然也可是调用生成器的send(None)函数返回
	

from sklearn.model_selection import KFold

3. __init__(self, n_splits=3, shuffle=False, random_state=None)
	使用:
		skf = KFlod(n_splits=5, shuffle=False, random_state=0)
	参数:
		n_splits: 将之后调用$2方法, 将该方法中的矩阵切成几份
		shuffle: 不清楚 
		random_state: 不清楚
	返回:
		StratifiedKFold对象
	
	联系:
		skf在调用了$4方法之后一般在for循环中进行迭代, 取出index, 但是这里的$3还有一个y要传入
	
4. skf.split(X, y, groups=None)
	使用:
		for train_index, test_index in skf.split(X, y):
			print('%s %s'%(train_index, test_index))
	
	参数:
		X: array-like
		y: array-like
		groups=None
	
	返回:
		generator生成器
	
	联系:
		注意到这里的y是未知参数, StratifiedKFold对象在调用split函数时会根据y的值进行划分, 使得每一个划分都比较均匀, 额, 还是看官网上吧

from sklearn.model_selection import train_test_split

5. train_test_split(*arrays, **options)
	使用:
		X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
	
	参数:
		*arrays: 基本上就是X和y了
		**options:
			test_size: 测试集所占百分比
			random_state: shuffle数据
			shuffle:
	返回:
		list
	
	联系:
		就如${使用}写到的, 一般采用拆包的形式接受返回值
		train_test_split是机器学习在建模之前必须的操作, 在格式化了我们的数据, 去掉了多余的特征, 采用了下采样或者过采样之后, 就会对数据进行划分成训练集和评估集

from sklearn.tree import DecisionTreeClassifier

1.  __init__(self, criterion='gini', splitter='best', 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)
	使用:
		clf = DecisionTreeClassifier(max_depth=3, max_features=4, random_state=0)
		
	参数:
		大部分的默认参数是用于预剪枝
		criterion='gini': 指明构建决策树的算法, 常用的有gini(基尼)和entropy(熵值)
		max_depth=None: 用于预剪枝, 当树的深度达到max_depth就停止构建
		min_samples_split=2: 用于预剪枝, 如果某节点的样本数少于min_samples_split，则不会继续再尝试选择最优特征来进行划分
		min_samples_leaf: 这个值限制了叶子节点最少的样本数，如果某叶子节点数目小于样本数，则会和兄弟节点一起被剪枝
		class_weight:指定样本各类别的的权重，主要是为了防止训练集某些类别的样本过多
                 导致训练的决策树过于偏向这些类别; 这里可以自己指定各个样本的权重
                 如果使用“balanced”, 则算法会自己计算权重, 样本量少的类别所对应的样本权重会高
       max_leaf_nodes: 通过限制最大叶子节点数，可以防止过拟合，默认是"None”，即不限制最大的叶子节点数
    
    联系:
    	在构建决策树时如果不加限制, 构建出来的模型容易过拟合, 所以一般需要指明max_depth和max_features, 当然我们很多时候对max_depth和max_features的选择是通过sklearn的${from sklearn.
    	model_selection import GridSreachCV: GridSearchCV --> $2}方法进行网格搜索得出的, 一旦使用了GridSearchCV, 主动权就交给了GridSearchCV, 也就是说原来的clf就可以不用管了, 
    	GridSearchCV对象在调用了${from sklearn.model_selection import GridSreachCV: GridSearchCV --> $2之后内部就封住了一个已经生成的clf, clf已经是优化过的了

from sklearn.model_selection import GridSearchCV

1. __init__(self, estimator, param_grid, scoring=None, fit_params=None, n_jobs=1, iid=True, refit=True, cv=None, verbose=0, pre_dispatch=‘2*n_jobs’, error_score=’raise’, return_train_score=’warn’)
	使用:
		parameters = {'max_depth': [1, 2, 3, 4, 5], 'max_features': [1, 2, 3, 4]} # 这里的键都是clf(DecisionTreeClassifier)的属性, 通过GridSearchCV选择最优的值
		grid_search = GridSearchCV(clf, param_grid=parameters, cv=3) # 可以看出, 该函数自带CV(Cross Validation, 就是只提到的KFold或者StratifiedKFold的功能)
	
	参数:
		estimator: 指的就是分类器(决策树[DecisionTreeClassifier, DecisionTreeRegression], 随机森林[RandomForest])
		param_grid: 值为字典或者列表，即需要最优化的参数的取值, param_test1={'max_depth': range(10,71,10)}
		scoring: 准确度评价标准，默认None,这时需要使用score函数；或者如scoring='roc_auc'，根据所选模型不同，评价准则不同; 如果是None，则使用estimator的误差估计函数
		cv :交叉验证参数，默认None，使用三折交叉验证。指定fold数量，默认为3，也可以是yield训练/测试数据的生成器。
		refit: 默认为True, 程序将会以交叉验证训练集得到的最佳参数, 重新对所有可用的训练集与开发集进行, 作为最终用于性能评估的最佳模型参数, 即在搜索参数结束后, 用最佳参数结果再次fit一遍全部数
		集
		iid: 默认True,为True时, 默认为各个样本fold概率分布一致, 误差估计为所有样本之和, 而非各个fold的平均
		verbose: 日志冗长度, int: 冗长度; 0: 不输出训练过程; 1: 偶尔输出; >1: 对每个子模型都输出
		n_jobs: 并行数; int: 个数; -1: 跟CPU核数一致; 1: 默认值
		pre_dispatch：指定总共分发的并行任务数; 当n_jobs大于1时, 数据将在每个运行点进行复制, 这可能导致OOM, 而设置pre_dispatch参数, 则可以预先划分总共的job数量，使数据最多被复制pre_dispatch次
		
		常用的就stimator, param_grid, cv
	
	返回:
		GridSearchCV对象
	
	联系:
		常用属性:
			以下在调用了$2方法才有意义
			grid_scores_: 给出不同参数情况下的评价结果, 一个list, 里面是_CVScoreTuple对象
			best_params_: 描述了已取得最佳结果的参数的组合
			best_score_: 成员提供优化过程期间观察到的最好的评分, 就是最大的精度
			best_estimator: 返回最优的决策树

2. grid_search.fit(X, y=None, groups=None, **fit_params)
		使用:
	 		grid_search.fit(X, y) # 执行该函数需要一些实现, 因为需要调优(不断的迭代和标胶), 因为传入了X, y, 可想而知, 调用完该函数, 目标函数已经出来了, 可以直接进入评估阶段了
	 
		参数:
		 	X: array-like, train
		 	y: array-like train labels
		 	
	 	返回:
	 		None
	 	
	 	联系:
	 		接下来查看属性:
	 			grid_scores_: 给出不同参数情况下的评价结果, 一个list, 里面是_CVScoreTuple对象
				best_params_: 描述了已取得最佳结果的参数的组合
				best_score_: 成员提供优化过程期间观察到的最好的评分, 就是最大的精度
				best_estimator_: 返回最优的决策树
			最重要的是best_estimator_:
				wanted_estimator = grid_search.best_estimator_
				score = wanted_estimator.score(X_test, y_test) # 返回精度, 就是评估的过程, 如果满意, 使用wanted_estimator.predict()方法应用到实际问题中

from sklearn.ensemble import RandomForestClassifier

1. __init__(tstrap=True, class_weight=None, criterion='gini',
               max_depth=2, max_features='auto', max_leaf_nodes=None,
               min_impurity_decrease=0.0, min_impurity_split=None,
               min_samples_leaf=1, min_samples_split=2,
               min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=1,
               oob_score=False, random_state=0, verbose=0, warm_start=False)
    使用:
    	clf = RandomForestClassifier(n_estimators=3, max_depth=3, max_features=4) # 使用方法与决策树的构造方法一样, 只不过最好指定n_estimators的个数(森林中树的个数)
    
    参数:
    	大部分的默认参数是用于预剪枝
    	n_estimator: 树的个数
		criterion='gini': 指明构建决策树的算法, 常用的有gini(基尼)和entropy(熵值)
		max_depth=None: 用于预剪枝, 当树的深度达到max_depth就停止构建
		min_samples_split=2: 用于预剪枝, 如果某节点的样本数少于min_samples_split，则不会继续再尝试选择最优特征来进行划分
		min_samples_leaf: 这个值限制了叶子节点最少的样本数，如果某叶子节点数目小于样本数，则会和兄弟节点一起被剪枝
		class_weight:指定样本各类别的的权重，主要是为了防止训练集某些类别的样本过多
                 导致训练的决策树过于偏向这些类别; 这里可以自己指定各个样本的权重
                 如果使用“balanced”, 则算法会自己计算权重, 样本量少的类别所对应的样本权重会高
       max_leaf_nodes: 通过限制最大叶子节点数，可以防止过拟合，默认是"None”，即不限制最大的叶子节点数
	
	联系:
		使用方法与决策树一样, 只不过parameter中要指定'n_estimators': [1, 2, 3]