机器学习常用函数解析

  1. 云栖社区>
  2. 博客>
  3. 正文

机器学习常用函数解析

megachen 2018-08-29 17:39:00 浏览603
展开阅读全文

机器学习常用函数解析

逻辑回归

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]
        

网友评论

登录后评论
0/500
评论