机器学习常用函数解析

本文涉及的产品
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
云解析 DNS,旗舰版 1个月
全局流量管理 GTM,标准版 1个月
简介: 机器学习常用函数解析逻辑回归from sklearn.preprocessing import StandardScaler1. StandardScaler(copy=True, with_mean=True, with_std=True) 使用: scaler = ...

机器学习常用函数解析

逻辑回归

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]
        
目录
相关文章
|
1月前
|
机器学习/深度学习 数据采集 算法
R语言中的机器学习库:caret与mlr的深度解析
【9月更文挑战第2天】Caret和mlr是R语言中两个非常重要的机器学习库,它们在数据预处理、模型构建、调优和评估等方面提供了丰富的功能。Caret以其易用性和集成性著称,适合初学者和快速原型开发;而mlr则以其全面性和可扩展性见长,适合处理复杂的机器学习项目。在实际应用中,用户可以根据具体需求和项目特点选择合适的库进行开发。无论是学术研究、商业智能还是教育场景,这两个库都能为数据科学家和机器学习爱好者提供强大的支持。
|
11天前
|
存储 前端开发 JavaScript
前端基础(十二)_函数高级、全局变量和局部变量、 预解析(变量提升)、函数返回值
本文介绍了JavaScript中作用域的概念,包括全局变量和局部变量的区别,预解析机制(变量提升),以及函数返回值的使用和类型。通过具体示例讲解了变量的作用域、函数的返回值、以及如何通过return关键字从函数中返回数据。
12 1
前端基础(十二)_函数高级、全局变量和局部变量、 预解析(变量提升)、函数返回值
|
11天前
|
设计模式 存储 算法
PHP中的设计模式:策略模式的深入解析与应用在软件开发的浩瀚海洋中,PHP以其独特的魅力和强大的功能吸引了无数开发者。作为一门历史悠久且广泛应用的编程语言,PHP不仅拥有丰富的内置函数和扩展库,还支持面向对象编程(OOP),为开发者提供了灵活而强大的工具集。在PHP的众多特性中,设计模式的应用尤为引人注目,它们如同精雕细琢的宝石,镶嵌在代码的肌理之中,让程序更加优雅、高效且易于维护。今天,我们就来深入探讨PHP中使用频率颇高的一种设计模式——策略模式。
本文旨在深入探讨PHP中的策略模式,从定义到实现,再到应用场景,全面剖析其在PHP编程中的应用价值。策略模式作为一种行为型设计模式,允许在运行时根据不同情况选择不同的算法或行为,极大地提高了代码的灵活性和可维护性。通过实例分析,本文将展示如何在PHP项目中有效利用策略模式来解决实际问题,并提升代码质量。
|
1月前
|
机器学习/深度学习 数据采集 存储
一文读懂蒙特卡洛算法:从概率模拟到机器学习模型优化的全方位解析
蒙特卡洛方法起源于1945年科学家斯坦尼斯劳·乌拉姆对纸牌游戏中概率问题的思考,与约翰·冯·诺依曼共同奠定了该方法的理论基础。该方法通过模拟大量随机场景来近似复杂问题的解,因命名灵感源自蒙特卡洛赌场。如今,蒙特卡洛方法广泛应用于机器学习领域,尤其在超参数调优、贝叶斯滤波等方面表现出色。通过随机采样超参数空间,蒙特卡洛方法能够高效地找到优质组合,适用于处理高维度、非线性问题。本文通过实例展示了蒙特卡洛方法在估算圆周率π和优化机器学习模型中的应用,并对比了其与网格搜索方法的性能。
170 1
|
2月前
|
机器学习/深度学习 数据挖掘
机器学习模型的选择与评估:技术深度解析
【8月更文挑战第21天】机器学习模型的选择与评估是一个复杂而重要的过程。通过深入理解问题、选择合适的评估指标和交叉验证方法,我们可以更准确地评估模型的性能,并选择出最适合当前问题的模型。然而,机器学习领域的发展日新月异,新的模型和评估方法不断涌现。因此,我们需要保持对新技术的学习和关注,不断优化和改进我们的模型选择与评估策略。
|
2月前
|
机器学习/深度学习 人工智能 监控
|
2月前
|
图形学 机器学习/深度学习 人工智能
颠覆传统游戏开发,解锁未来娱乐新纪元:深度解析如何运用Unity引擎结合机器学习技术,打造具备自我进化能力的智能游戏角色,彻底改变你的游戏体验——从基础设置到高级应用全面指南
【8月更文挑战第31天】本文探讨了如何在Unity中利用机器学习增强游戏智能。作为领先的游戏开发引擎,Unity通过ML-Agents Toolkit等工具支持AI代理的强化学习训练,使游戏角色能自主学习完成任务。文章提供了一个迷宫游戏示例及其C#脚本,展示了环境观察、动作响应及奖励机制的设计,并介绍了如何设置训练流程。此外,还提到了Unity与其他机器学习框架(如TensorFlow和PyTorch)的集成,以实现更复杂的游戏玩法。通过这些技术,游戏的智能化程度得以显著提升,为玩家带来更丰富的体验。
41 0
|
2月前
|
SQL 数据处理 数据库
|
2月前
|
开发者 算法 虚拟化
惊爆!Uno Platform 调试与性能分析终极攻略,从工具运用到代码优化,带你攻克开发难题成就完美应用
【8月更文挑战第31天】在 Uno Platform 中,调试可通过 Visual Studio 设置断点和逐步执行代码实现,同时浏览器开发者工具有助于 Web 版本调试。性能分析则利用 Visual Studio 的性能分析器检查 CPU 和内存使用情况,还可通过记录时间戳进行简单分析。优化性能涉及代码逻辑优化、资源管理和用户界面简化,综合利用平台提供的工具和技术,确保应用高效稳定运行。
40 0
|
2月前
|
SQL 关系型数据库 数据处理

推荐镜像

更多
下一篇
无影云桌面