精华内容
下载资源
问答
  • 机器学习计算机配置
    千次阅读
    2020-03-19 17:54:47


    本节介绍如何配置 Azure 机器学习的开发环境。 官方文档对此做了非常详细的介绍。本节对官方文档做了一定简化,重点介绍如何在本地计算机配置 Azure 机器学习的开发环境。

    一、4种开发环境

    Azure 机器学习可以在很多平台上使用。 对开发环境的唯一硬性要求是需要 Python 3。 同时建议使用独立的环境,如 Anaconda 或 Virtualenv。
    下表显示了本节中涉及到的每个开发环境及其优点和缺点。

    环境优点缺点
    基于云的 Azure 机器学习计算实例(预览)入门的最简单方法。 整个 SDK 已安装到你的工作区 VM 中,笔记本教程已预克隆并可随时运行。缺乏对开发环境和依赖项的控制。 Linux VM 产生的额外成本(VM 可以在不使用时停止,以避免收费)。 请参阅定价详细信息
    本地环境完全控制开发环境和依赖项。 在您选择的任何生成工具、环境或 IDE 中运行。需要更长的时间才能开始。 必须安装必需的 SDK 包,并且还必须安装环境(如果尚未安装)。
    Azure Databricks适用于在可缩放的 Apache Spark 平台上运行大规模密集型机器学习工作流。用于试验机器学习或小规模试验和工作流的多余。 Azure Databricks 产生的额外成本。 请参阅定价详细信息
    Data Science Virtual Machine (DSVM)与基于云的计算实例(即预装的 Python 和 SDK)类似,但还预安装了其他热门数据科学和机器学习工具。 易于缩放,并与其他自定义工具和工作流组合。与基于云的计算实例相比,较慢的入门体验。

    二、必备条件

    Azure 机器学习工作区(工作区是Azure机器学习的顶级资源中心,所有的Azure机器学习试验都在工作区下面开展)。

    • 如果你还没有创建Azure机器学习工作区,请参考此节创建
    • 若要为本地计算机安装 SDK 环境、Jupyter Notebook 服务器或Visual Studio Code,还需要:
      • Anaconda或miniconda)包管理器。
      • 在 Linux 或 macOS 上,需要 bash shell。
      • 在 Windows 上,需要命令提示符或 Anaconda 提示符(由 Anaconda 和 Miniconda 安装)。

    三、配置环境

    由于我一般都是在本地计算机上做Azure机器学习开发,所以首先给大家介绍在本地计算机上配置Azure机器学习开发环境。

    本地计算机

    使用本地计算机(也可能是远程虚拟机)时,请创建 Anaconda 环境并安装 SDK。 下面是一个示例:

    • 下载并安装Anaconda (Python 3.7 版)(如果尚未安装)。
    • 打开 Anaconda 提示符,并使用以下命令创建环境:运行以下命令以创建环境。
    conda create -n myenv python=3.6.5
    • 然后激活环境。
    conda activate myenv

    此示例使用 python 3.6.5 创建一个环境,但可以选择任何特定的 subversions。 对于某些主要版本(建议使用 3.5 +),SDK 兼容性可能不会得到保证,如果遇到错误,建议在 Anaconda 环境中尝试不同版本。 下载组件和包时,创建环境需要花费几分钟。

    • 在新环境中运行以下命令,以启用环境特定的 IPython 内核。 当在 Anaconda 环境中使用 Jupyter 笔记本时,这将确保预期内核和包导入行为:
    conda install notebook ipykernel

    然后运行以下命令以创建内核:

    ipython kernel install --user --name myenv --display-name "Python (myenv)"
    • 使用以下命令安装包:
      此命令通过笔记本和 automl 额外内容安装基本 Azure 机器学习 SDK。 automl 是一个比较大的包,如果不打算进行自动机器化学习试验,则可以将其从方括号中删除。 默认情况下,安装automl 包的时候还会安装 Azure 机器学习数据准备包 作为其依赖项。
    pip install azureml-sdk[notebooks,automl]

    上述安装了运行Azure机器学习的默认安装包,当然它还有很多附加组件和高级功能,如果需要,参考此处安装

    • 为机器学习试验安装其他程序包。比如TensorFlow、PyTorch等等。
    conda install <new package>
    #或者
    pip install <new package>

    安装完成了,就可以通过Jupyter Notebook或者Visual Studio Code来使用Azure机器学习SDK。
    一般按上述步骤在本地计算机安装Azure机器学习SDK后,就可以开始各种机器学习试验了。如果涉及到大型项目开发,需要使用环境来跟踪和重现项目的软件依赖关系,那么可以使用Azure机器学习的Environment类在训练和部署中重复使用某个环境,具体操作请参考此链接

    基于云的计算实例

    这个是一个比较有意思的应用。相当于你在Azure机器学习工作区中创建了一台虚拟机,虚拟机的规格可以自己选择。这台虚拟机已经提前准备好了 Jupyter 笔记本服务器、JupyterLab 以及完整的Azure ML 环境,自己无需再安装或配置任何内容。
    创建这个计算实例的方法也很简单,你只需要在Azure机器学习studio的计算栏目中,在“计算实例”下方点击新建,定义计算实例名称和虚拟机规格后就可以创建成功。
    使用起来也很方便,如果计算实例已经启动,点击“应用程序URI”下方的Jupyter,就会在默认浏览器中打开Jupyter notebook,notebook的根目录是这台虚拟机的/home。之后就可以在notebook中开展机器学习试验。
    这个计算实例实际上是一台绑定到Azure机器学习工作区的虚拟机,工作区给了我们一个便捷使用的接口从而不用通过ssh来连接它。计算实例每次启动和停止都会花费一些时间。另外,此计算实例也是按照云上虚拟机定价收费的,因此每次使用完后最好将其停止,以节省费用。
    图1 Azure机器学习studio种的计算实例
    图1 Azure机器学习studio种的计算实例

    Data Science Virtual Machine

    DSVM是Azure上一种特殊的虚拟机,与一般虚拟机不同的是,该虚拟机在创建时已经预配好了以下环境:

    • TensorFlow、PyTorch、Scikit-learn、XGBoost 和 Azure 机器学习 SDK 等包
    • Spark Standalone 和 Drill 等常用数据科学工具
    • Azure CLI、AzCopy 和存储资源管理器等 Azure 工具
    • Visual Studio Code 和 PyCharm 等集成开发环境 (IDE)
    • Jupyter Notebook 服务器

    Azure 机器学习 SDK 适用于 Ubuntu 或 Windows 版本的 DSVM。 但是,如果还计划将 DSVM 用作计算目标,则仅支持 Ubuntu。
    在portal中创建DSVM请查看创建 Ubuntu Data Science Virtual Machine创建 Windows Data Science Virtual Machine

    DSVM 上已安装 Azure 机器学习 SDK。 若要使用包含此 SDK 的 Conda 环境,请使用以下某个命令:

    • 对于 Ubuntu DSVM:
    conda activate py36
    • 对于 Windows DSVM:
    conda activate AzureML

    若要验证是否可以访问 SDK 并检查版本,请使用以下 Python 代码:

    import azureml.core
    print(azureml.core.VERSION)

    Azure Databricks

    Azure Databricks 是 Azure 云中基于 Apache Spark 的环境。 它通过基于 CPU 或 GPU 的计算群集提供基于笔记本的协作环境。如果有兴趣了解和使用,请参考此处

    四、创建工作区配置文件

    在本地安装好Azure机器学习SDK后,你可以通过以下代码连接到机器学习工作区:

    from azureml.core import Workspace
    
    workspace_name = 'your workspace name'
    subscription_id = 'your subscription id'
    resource_group = 'your resource group name'
    
    ws = Workspace.get(name=workspace_name,subscription_id=subscription_id,resource_group=resource_group)
    print(ws.name, ws.resource_group, ws.location, sep='\n')

    其中workspace_name、subscription_id和resource_group可以根据下图查到:
    图2 工作区的相关配置信息
    图2 工作区的相关配置信息
    ———————————————————————————————————————————————————————————————
    注意:为了确保能够连接成功,在连接工作区之前建议先使用az login登陆Azure,具体步骤如下:

    1. 下载和安装 Azure CLI
    2. 如果使用Azure China,那么在Windows cmd或者Linux终端中输入:
    az cloud set --name AzureChinaCloud

    将Azure设置为AzureChina。
    如果要切换成AzureGlobal,则输入:

    az cloud set --name AzureCloud
    1. 在Windows cmd或者Linux终端中输入
    az login

    将打开默认浏览器进入Azure登陆页面。登陆后一般就能正常连接到工作区。
    ———————————————————————————————————————————————————————————————
    workspace_name、subscription_id和resource_group是连接工作区的令牌,不要将其泄露出去。为了进一步保障安全,建议将这三个值保存到json配置文件中,通过ws = Workspace.from_config(‘config.json’)来连接工作区,避免重要信息在代码中泄露。

    ws = Workspace.from_config(path='config.json')
    print(ws.name, ws.resource_group, ws.location, sep='\n')

    有3中方式可以创建配置文件:

    直接写一个json配置文件

    自己写入一个配置文件。 该文件含包含工作区的配置信息。 然后将其复制到某个文件夹下面。
    图3 工作区json配置文件
    图3 工作区json配置文件

    下载文件

    Azure 门户中,从工作区的 “概述” 部分选择 “下载配置文件”。然后将其放到需要使用的文件夹中。
    图4 portal上下载工作区配置文件
    图4 portal上下载工作区配置文件

    以编程方式创建文件

    在以下代码片段中,你可以通过提供订阅 ID、资源组和工作区名称来连接到工作区。 然后,它将工作区配置保存到文件中:

    from azureml.core import Workspace
    
    subscription_id = '<subscription-id>'
    resource_group  = '<resource-group>'
    workspace_name  = '<workspace-name>'
    
    try:
        ws = Workspace(subscription_id = subscription_id, resource_group = resource_group, workspace_name = workspace_name)
        ws.write_config(path='my_path',file_name='config.json')
        print('Library configuration succeeded')
    except:
        print('Workspace not found')

    此代码会将配置文件写入my_path/.azureml/config.json文件。

    五、总结

    • 介绍了Azure机器学习开发的4种环境,以及每种环境的配置方法,重点介绍了在本地计算机的配置方法。
    • 介绍了3种创建工作区配置文件的方法。
    更多相关内容
  • 计算机视觉+机器学习 (一)识别手写数字(1)  本人在七月在线网站上报了一个计算机视觉+机器学习的课程班。第一课教我们看了opencv相关知识,并留了一项作业,用MNIST数据集做一个识别手写数字的项目。  初次...
  • 本篇文章详解机器学习应用流程,应用在结构化数据和非结构化数据(图像)上,借助案例重温机器学习基础知识,并学习应用机器学习解决问题的基本流程。

    作者:韩信子@ShowMeAI
    教程地址https://www.showmeai.tech/tutorials/41
    本文地址https://www.showmeai.tech/article-detail/201
    声明:版权所有,转载请联系平台与作者并注明出处
    收藏ShowMeAI查看更多精彩内容


    引言

    本篇文章希望带大家完整走一遍机器学习应用流程,我们会讲解到基于Python的机器学习算法,应用在结构化数据和非结构化数据(图像)上,希望通过文章内容帮助大家在案例中重温机器学习基础知识,并学习应用机器学习解决问题的基本流程。

    文章中会用到下述两个库来实现机器学习算法:

    在本篇文章中,我们将讲解到以下内容:

    • 问题抽象与理解
    • 数据准备与处理(预处理、特征提取、特征工程等)
    • 各种机器学习算法
    • 实验结果分析与对比
    • 模型选择与调优

    我们会覆盖到的机器学习算法包括:KNN、朴素贝叶斯、逻辑回归、SVM、决策树、随机森林、感知机、前馈神经网络、卷积神经网络。

    1.环境准备

    工欲善其事必先利其器,我们先安装一下必需的Python库(当然我们也推荐大家用集成环境anaconda,具体的安装与设置可以参考ShowMeAI文章 图解Python | 安装与环境设置 完成):

    可以采用pip安装,命令如下:
    $ pip install numpy
    $ pip install pillow
    $ pip install --upgrade scikit-learn
    $ pip install tensorflow # or tensorflow-gpu
    $ pip install keras
    $ pip install opencv-contrib-python
    $ pip install --upgrade imutils
    

    2.数据集

    因为本篇文章我们介绍结构化数据和非结构化数据的不同建模,我们这里用到两个数据集。

    2.1 iris(鸢尾花)数据集

    第一个数据集是iris(鸢尾花)数据集,它是一个入门级数据集。整个数据集都是数值型的数据,是一个结构化的表格数据,每一行代表一个样本,然后每一列就是不同的属性。

    这个数据集主要是收集了三种不同的鸢尾花的数据,分别为:

    • Iris Setosa
    • Iris Versicolor
    • Iris Virginica

    对应图中最后一列Class label,然后还有四种属性,分别是:

    • Sepal length:萼片长度
    • Sepal width:萼片宽度
    • Petal length:花瓣长度
    • Petal width:花瓣宽度

    对于该数据集,我们的目标就是根据给定的四个属性,训练一个机器学习模型来正确分类每个样本的类别,这是一个典型的分类任务。

    2.2 图像数据集

    第二个数据集是一个图像数据集。它包括海岸线(Coast)、森林(Forest)和高速公路(Highway)三种场景,总共是 948 张图片,我们需要构建模型完成类别的分类,每个类别的具体图片数量如下:

    • 海岸线(Coast):360
    • 森林(Forest):328
    • 高速公路(Highway):260

    3.机器学习应用步骤

    我们在不同场景下应用机器学习算法,都有大致的步骤,比如下面是一个典型的机器学习应用流程:

    当然,并不是其中的每一步都是必须的,我们也可能会调整其中某些步骤中的细节。

    3.1 问题抽象与理解

    针对我们的问题,问一下自己:

    • 数据集是哪种类型?数值型,类别型还是图像?
    • 模型的最终目标是什么?
    • 如何定义和衡量“准确率”呢?
    • 以目前自身的机器学习知识来看,哪些算法在处理这类问题上效果很好?

    前序问题比较简单,最后的问题,随着大家应用机器学习解决问题的经验积累,可以更准确快速地回答。

    3.2 数据准备与处理

    数据准备与处理,包括数据预处理以及特征工程了。一般这一步,包括了加载数据、检查数据、探索性数据分析(EDA)、数据预处理,进而决定需要做的特征提取或者特征工程。

    特征提取是应用某种算法通过某种方式来量化数据的过程。比如,对于图像数据,我们可以采用计算直方图的方法来统计图像中像素强度的分布,通过这种方式,我们就得到描述图像颜色的特征。

    特征工程是将原始输入数据转换成一个更好描述潜在问题的特征表示的过程。大家可以查看ShowMeAI机器学习专题文章 系统了解特征工程的常见方法。

    3.3 多模型应用

    下一步可以选择各种候选机器学习算法,并应用在数据集上。我们安装的工具包内,包含很多机器学习算法,比如下述模型都可以用作分类:

    • 线性模型(逻辑回归、线性SVM)
    • 非线性模型(RBF、SVM、梯度下降分类器)
    • 树和基于集成的模型(决策树、随机森林)
    • 神经网络(多层感知机、卷积神经网络)

    对于模型选择,当然很多需要依据实验效果来定,但我们也有一些先序的经验,比如:

    • 对于稠密型多特征的数据集,随机森林算法的效果很不错;
    • 逻辑回归算法可以很好处理高维度的稀疏数据;
    • 对于图像数据,CNNs的效果非常好。

    下图为 scikit-learn工具库 官方给的一个模型选择思路参考:

    4.构建机器学习流程并实验分析

    我们构建如下的代码文件目录,包含四个代码文件和一个3scenes图像文件夹(内含三场景数据集),iris数据集无需另外存储,直接采用scikit-learn库载入即可。

    ├── 3scenes
    │   ├── coast [360 entries]
    │   ├── forest [328 entries]
    │   └── highway [260 entries]
    ├── iris_classifier.py
    ├── image_classifier.py
    ├── nn_iris.py
    └── basic_cnn.py
    

    4.1 结构化数据建模

    首先实现iris_classifier,我们这里直接使用sklearn的机器学习算法来对iris数据集进行分类。

    # 导入需要的库
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.naive_bayes import GaussianNB
    from sklearn.linear_model import LogisticRegression
    from sklearn.svm import SVC
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.neural_network import MLPClassifier
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import classification_report
    from sklearn.datasets import load_iris
    import argparse
    
    # 设置参数
    ap = argparse.ArgumentParser()
    ap.add_argument("-m", "--model", type=str, default="knn", help="type of python machine learning model to use")
    args = vars(ap.parse_args())
    
    # 定义一个保存模型的字典,根据 key 来选择加载哪个模型
    models = {
        "knn": KNeighborsClassifier(n_neighbors=1),
        "naive_bayes": GaussianNB(),
        "logit": LogisticRegression(solver="lbfgs", multi_class="auto"),
        "svm": SVC(kernel="rbf", gamma="auto"),
        "decision_tree": DecisionTreeClassifier(),
        "random_forest": RandomForestClassifier(n_estimators=100),
        "mlp": MLPClassifier()
    }
    

    其中,models从前往后依次包括这些算法:KNN、朴素贝叶斯、逻辑回归、SVM、决策树、随机森林、感知机等。

    我们直接调用sklearn中相应的函数来实现对应的算法即可,这里直接用一个models的字典来保存不同模型的初始化,然后根据参数--model来调用对应的模型,比如命令输入python iris_classifier.py --model knn就是调用knn算法模型。

    接着就是载入数据部分:

    print("加载数据中...")
    dataset = load_iris()
    trainX, testX, trainY, testY = train_test_split(dataset.data, dataset.target, random_state=3, test_size=0.2)
    

    这里直接调用sklearn.datasets中的load_iris()载入数据,然后采用train_test_split来划分训练集和数据集,这里是80%数据作为训练集,20%作为测试集。

    最后就是训练模型和预测部分:

    # 训练模型
    print("应用 '{}' 模型建模...".format(args["model"]))
    model = models[args["model"]]
    model.fit(trainX, trainY)
    
    # 预测并输出一份分类结果报告
    print("评估模型效果...")
    predictions = model.predict(testX)
    print(classification_report(testY, predictions, target_names=dataset.target_names))
    

    4.2 图像数据建模

    类似的过程对三场景图像数据集构建代码image_classifier.py

    # 导入工具库
    from sklearn.preprocessing import LabelEncoder
    from PIL import Image
    from imutils import paths
    import numpy as np
    import os
    

    其中LabelEncoder是为了将标签从字符串编码为整型,然后其余几项都是处理图像相关。

    对于图像数据,如果直接采用原始像素信息输入模型中,大部分的机器学习算法效果都很不理想,所以这里采用特征提取方法,主要是统计图像颜色通道的均值和标准差信息,总共是RGB3个通道,每个通道各计算均值和标准差,然后结合在一起,得到一个六维的特征,函数如下所示:

    def extract_color_stats(image):
        '''
        将图片分成 RGB 三通道,然后分别计算每个通道的均值和标准差,然后返回
        :param image:
        :return:
        '''
        (R, G, B) = image.split()
        features = [np.mean(R), np.mean(G), np.mean(B), np.std(R), np.std(G), np.std(B)]
    
        return features
    

    然后同样会定义一个models字典,代码一样,这里就不贴出来了,然后图像载入部分的代码如下:

    # 加载数据并提取特征
    print("抽取图像特征中...")
    imagePaths = paths.list_images(args['dataset'])
    data = []
    labels = []
    
    # 循环遍历所有的图片数据
    for imagePath in imagePaths:
        # 加载图片,然后计算图片的颜色通道统计信息
        image = Image.open(imagePath)
        features = extract_color_stats(image)
        data.append(features)
    
        # 保存图片的标签信息
        label = imagePath.split(os.path.sep)[-2]
        labels.append(label)
    
    # 对标签进行编码,从字符串变为整数类型
    le = LabelEncoder()
    labels = le.fit_transform(labels)
    
    # 进行训练集和测试集的划分,80%数据作为训练集,其余20%作为测试集
    trainX, testX, trainY, testY = train_test_split(data, labels, test_size=0.2)
    

    上述代码就完成加载图片的路径信息,然后依次遍历,读取图片,提取特征,提取标签信息,保存特征和标签信息,接着编码标签,然后就是划分训练集和测试集。

    接着是相同的训练模型和预测的代码,和前面的分类器一样。完整版代码如下:

    # 导入工具库
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.naive_bayes import GaussianNB
    from sklearn.linear_model import LogisticRegression
    from sklearn.svm import SVC
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.neural_network import MLPClassifier
    from sklearn.preprocessing import LabelEncoder
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import classification_report
    from PIL import Image
    from imutils import paths
    import numpy as np
    import argparse
    import os
    
    # 抽取图像特征
    def extract_color_stats(image):
        '''
        将图片分成 RGB 三通道,然后分别计算每个通道的均值和标准差,然后返回
        :param image:
        :return:
        '''
        (R, G, B) = image.split()
        features = [np.mean(R), np.mean(G), np.mean(B), np.std(R), np.std(G), np.std(B)]
    
        return features
    
    
    # 设置参数
    ap = argparse.ArgumentParser()
    ap.add_argument("-d", "--dataset", type=str, default="3scenes",
                    help="path to directory containing the '3scenes' dataset")
    ap.add_argument("-m", "--model", type=str, default="knn",
                    help="type of python machine learning model to use")
    args = vars(ap.parse_args())
    
    # 定义一个保存模型的字典,根据 key 来选择加载哪个模型
    models = {
        "knn": KNeighborsClassifier(n_neighbors=1),
        "naive_bayes": GaussianNB(),
        "logit": LogisticRegression(solver="lbfgs", multi_class="auto"),
        "svm": SVC(kernel="rbf", gamma="auto"),
        "decision_tree": DecisionTreeClassifier(),
        "random_forest": RandomForestClassifier(n_estimators=100),
        "mlp": MLPClassifier()
    }
    
    # 加载数据并提取特征
    print("抽取图像特征中...")
    imagePaths = paths.list_images(args['dataset'])
    data = []
    labels = []
    
    # 循环遍历所有的图片数据
    for imagePath in imagePaths:
        # 加载图片,然后计算图片的颜色通道统计信息
        image = Image.open(imagePath)
        features = extract_color_stats(image)
        data.append(features)
    
        # 保存图片的标签信息
        label = imagePath.split(os.path.sep)[-2]
        labels.append(label)
    
    # 对标签进行编码,从字符串变为整数类型
    le = LabelEncoder()
    labels = le.fit_transform(labels)
    
    # 进行训练集和测试集的划分,80%数据作为训练集,其余20%作为测试集
    trainX, testX, trainY, testY = train_test_split(data, labels, random_state=3, test_size=0.2)
    # print('trainX numbers={}, testX numbers={}'.format(len(trainX), len(testX)))
    
    # 训练模型
    print("[应用 '{}' 模型建模".format(args["model"]))
    model = models[args["model"]]
    model.fit(trainX, trainY)
    
    # 预测并输出分类结果报告
    print("模型评估")
    predictions = model.predict(testX)
    print(classification_report(testY, predictions, target_names=le.classes_))
    

    完成这两份代码后,我们就可以开始运行下代码,对比不同算法在两个数据集上的性能。

    4.3 不同模型建模对比

    (1) KNN

    K-Nearest Neighbors分类器最简单的分类算法之一。该算法依赖于特征向量之间的距离。简单地说,KNN算法通过在k个最接近的样本中最多的类别来对未知数据点进行分类。关于KNN的详细讲解可以阅读ShowMeAI的文章 图解机器学习 | KNN算法及其应用

    这里我们先运行下image_classifier.py,调用默认的模型knn,看下KNNiris数据集上的实验结果,如下所示:

    $ !python iris_classifier.py --model knn
    加载数据中...
    应用 'knn' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
          setosa       1.00      1.00      1.00        10
      versicolor       0.90      0.90      0.90        10
       virginica       0.90      0.90      0.90        10
    
        accuracy                           0.93        30
       macro avg       0.93      0.93      0.93        30
    weighted avg       0.93      0.93      0.93        30
    

    其中主要是给出了对每个类别的精确率、召回率、F1以及该类别测试集数量,即分别对应precision、recall、f1-score、support。根据最后一行第一列,可以看到KNN取得93%的准确率。

    接着是在三场景图片数据集上的实验结果:

    $ !python image_classifier.py --model knn
    抽取图像特征中...
    应用 'knn' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
           coast       0.84      0.68      0.75       105
          forest       0.78      0.77      0.77        78
         highway       0.56      0.78      0.65        54
    
       micro avg       0.73      0.73      0.73       237
       macro avg       0.72      0.74      0.72       237
    weighted avg       0.75      0.73      0.73       237
    

    这里KNN取得75%的准确率。

    ps:实际上,运行这个算法,不同次数会有不同的结果,其主要原因是因为在划分训练集和测试集的时候,代码没有设置参数random_state,这导致每次运行划分的训练集和测试集的图片都是不同的,所以运行结果也会不相同!

    (2) 朴素贝叶斯

    接着是朴素贝叶斯算法,关于朴素贝叶斯算法的详细讲解可以阅读ShowMeAI的文章 图解机器学习 | 朴素贝叶斯算法详解

    分别测试两个数据集,结果如下:

    $ !python iris_classifier.py --model naive_bayes
    加载数据中...
    应用 'naive_bayes' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
          setosa       1.00      1.00      1.00        15
      versicolor       1.00      0.92      0.96        12
       virginica       0.92      1.00      0.96        11
    
       micro avg       0.97      0.97      0.97        38
       macro avg       0.97      0.97      0.97        38
    weighted avg       0.98      0.97      0.97        38
    
    $ !python image_classifier.py --model naive_bayes
    抽取图像特征中...
    应用 'naive_bayes' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
           coast       0.69      0.40      0.50        88
          forest       0.68      0.82      0.74        84
         highway       0.61      0.78      0.68        65
    
       micro avg       0.65      0.65      0.65       237
       macro avg       0.66      0.67      0.64       237
    weighted avg       0.66      0.65      0.64       237
    

    同样,朴素贝叶斯在iris上有98%的准确率,但是在图像数据集上仅有66%的准确率。

    那么,我们是否可以说明KNN算法比朴素贝叶斯好呢?当然是不可以的,上述结果只能说明在三场景图像数据集上,KNN算法优于朴素贝叶斯算法。
    实际上,每种算法都有各自的优缺点和适用场景,不能一概而论地说某种算法任何时候都优于另一种算法,这需要具体问题具体分析。

    (3) 逻辑回归

    接着是逻辑回归算法,关于逻辑回归算法的详细讲解可以阅读ShowMeAI的文章 图解机器学习 | 逻辑回归算法详解

    分别测试两个数据集,结果如下:

    $ !python iris_classifier.py --model logit
    加载数据中...
    应用 'logit' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
          setosa       1.00      1.00      1.00        15
      versicolor       1.00      0.92      0.96        12
       virginica       0.92      1.00      0.96        11
    
       micro avg       0.97      0.97      0.97        38
       macro avg       0.97      0.97      0.97        38
    weighted avg       0.98      0.97      0.97        38
    
    $ !python image_classifier.py --model logit
    抽取图像特征中...
    应用 'logit' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
           coast       0.67      0.67      0.67        92
          forest       0.79      0.82      0.80        82
         highway       0.61      0.57      0.59        63
    
       micro avg       0.70      0.70      0.70       237
       macro avg       0.69      0.69      0.69       237
    weighted avg       0.69      0.70      0.69       237
    

    同样,逻辑回归在 iris 上有 98% 的准确率,但是在图像数据集上仅有 69% 的准确率

    (4) 支持向量机 SVM

    接着是SVM算法,关于SVM算法的详细讲解可以阅读ShowMeAI的文章 图解机器学习 | 支持向量机模型详解

    分别测试两个数据集,结果如下:

    $ !python iris_classifier.py --model svm
    加载数据中...
    应用 'svm' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
          setosa       1.00      1.00      1.00        15
      versicolor       1.00      0.92      0.96        12
       virginica       0.92      1.00      0.96        11
    
       micro avg       0.97      0.97      0.97        38
       macro avg       0.97      0.97      0.97        38
    weighted avg       0.98      0.97      0.97        38
    
    $ !python image_classifier.py --model svm
    抽取图像特征中...
    应用 'svm' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
           coast       0.84      0.76      0.80        92
          forest       0.86      0.93      0.89        84
         highway       0.78      0.80      0.79        61
    
       micro avg       0.83      0.83      0.83       237
       macro avg       0.83      0.83      0.83       237
    

    同样,SVM在iris上有98%的准确率,但是在图像数据集上仅有83%的准确率。

    (5) 决策树

    接着是决策树算法,关于决策树算法的详细讲解可以阅读ShowMeAI的文章 图解机器学习 | 决策树模型详解

    分别测试两个数据集,结果如下:

    $ !python iris_classifier.py --model decision_tree
    加载数据中...
    应用 'decision_tree' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
          setosa       1.00      1.00      1.00        15
      versicolor       0.92      0.92      0.92        12
       virginica       0.91      0.91      0.91        11
    
       micro avg       0.95      0.95      0.95        38
       macro avg       0.94      0.94      0.94        38
    weighted avg       0.95      0.95      0.95        38
    
    $ !python image_classifier.py --model decision_tree
    抽取图像特征中...
    应用 'decision_tree' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
           coast       0.71      0.74      0.72        85
          forest       0.76      0.80      0.78        83
         highway       0.77      0.68      0.72        69
    
       micro avg       0.74      0.74      0.74       237
       macro avg       0.75      0.74      0.74       237
    weighted avg       0.74      0.74      0.74       237
    

    同样,决策树在iris上有98%的准确率,但是在图像数据集上仅有74%的准确率。

    (6) 随机森林

    接着是随机森林算法,关于随机森林算法的详细讲解可以阅读ShowMeAI的文章 图解机器学习 | 随机森林分类模型详解

    分别测试两个数据集,结果如下:

    $ !python iris_classifier.py --model random_forest
    加载数据中...
    应用 'random_forest' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
          setosa       1.00      1.00      1.00        15
      versicolor       1.00      0.83      0.91        12
       virginica       0.85      1.00      0.92        11
    
       micro avg       0.95      0.95      0.95        38
       macro avg       0.95      0.94      0.94        38
    weighted avg       0.96      0.95      0.95        38
    
    $ !python image_classifier.py --model random_forest
    加载数据中...
    应用 'random_forest' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
           coast       0.80      0.83      0.81        84
          forest       0.92      0.84      0.88        90
         highway       0.77      0.81      0.79        63
    
       micro avg       0.83      0.83      0.83       237
       macro avg       0.83      0.83      0.83       237
    weighted avg       0.84      0.83      0.83       237
    

    同样,随机森林在iris上有96%的准确率,但是在图像数据集上仅有84%的准确率。

    注意了,一般如果决策树算法的效果还不错的话,随机森林算法应该也会取得不错甚至更好的结果,这是因为随机森林实际上就是多棵决策树通过集成学习方法组合在一起进行分类预测。

    (7) 多层感知机

    最后是多层感知机算法,分别测试两个数据集,结果如下:

    $ !python iris_classifier.py --model mlp
    加载数据中...
    应用 'mlp' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
          setosa       1.00      1.00      1.00        15
      versicolor       1.00      0.92      0.96        12
       virginica       0.92      1.00      0.96        11
    
       micro avg       0.97      0.97      0.97        38
       macro avg       0.97      0.97      0.97        38
    weighted avg       0.98      0.97      0.97        38
    
    $ !python image_classifier.py --model mlp
    抽取图像特征中...
    应用 'mlp' 模型建模...
    评估模型效果...
                  precision    recall  f1-score   support
    
           coast       0.72      0.91      0.80        86
          forest       0.92      0.89      0.90        79
         highway       0.79      0.58      0.67        72
    
       micro avg       0.80      0.80      0.80       237
       macro avg       0.81      0.79      0.79       237
    weighted avg       0.81      0.80      0.80       237
    

    同样,多层感知机在 iris 上有 98% 的准确率,但是在图像数据集上仅有 81% 的准确率.

    (8) 神经网络

    最后是实现深度学习的算法,也就是nn_iris.pybasic_cnn.py这两份代码。

    首先是nn_iris.py的实现,同样首先是导入库和数据的处理:

    # 导入工具库
    from keras.models import Sequential
    from keras.layers.core import Dense
    from keras.optimizers import SGD
    from sklearn.preprocessing import LabelBinarizer
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import classification_report
    from sklearn.datasets import load_iris
    
    # 载入 Iris 数据集,然后进行训练集和测试集的划分,80%数据作为训练集,其余20%作为测试集
    print("加载数据中...")
    dataset = load_iris()
    (trainX, testX, trainY, testY) = train_test_split(dataset.data,
                                                      dataset.target, test_size=0.2)
    
    # 将标签进行独热向量编码
    lb = LabelBinarizer()
    trainY = lb.fit_transform(trainY)
    testY = lb.transform(testY)
    

    我们采用Keras来实现神经网络,然后这里需要将标签进行one-hot编码,即独热向量编码。

    接着就是搭建网络模型的结构和训练、预测代码:

    # 利用 Keras 定义网络模型
    model = Sequential()
    model.add(Dense(3, input_shape=(4,), activation="sigmoid"))
    model.add(Dense(3, activation="sigmoid"))
    model.add(Dense(3, activation="softmax"))
    
    # 采用梯度下降训练模型
    print('训练网络中...')
    opt = SGD(lr=0.1, momentum=0.9, decay=0.1 / 250)
    model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=["accuracy"])
    H = model.fit(trainX, trainY, validation_data=(testX, testY), epochs=250, batch_size=16)
    
    # 预测
    print('评估模型效果')
    predictions = model.predict(testX, batch_size=16)
    print(classification_report(testY.argmax(axis=1), predictions.argmax(axis=1), target_names=dataset.target_names))
    

    上述代码构建了3层全连接层的神经网络,前两层采用Sigmoid激活函数,然后最后一层是输出层,所以采用softmax将输出变成概率值。优化算法选择的随机梯度下降SGD,损失函数是categorical_crossentropy,迭代次数是250次,每一批次的数据量batch_size是16。

    完整版代码如下:

    # 加载工具库
    from keras.models import Sequential
    from keras.layers.core import Dense
    from keras.optimizers import SGD
    from sklearn.preprocessing import LabelBinarizer
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import classification_report
    from sklearn.datasets import load_iris
    
    # 载入 Iris 数据集,然后进行训练集和测试集的划分,80%数据作为训练集,其余20%作为测试集
    print("加载数据中...")
    dataset = load_iris()
    (trainX, testX, trainY, testY) = train_test_split(dataset.data,
                                                      dataset.target, test_size=0.2)
    
    # 将标签进行独热向量编码
    lb = LabelBinarizer()
    trainY = lb.fit_transform(trainY)
    testY = lb.transform(testY)
    
    # 利用 Keras 定义网络模型
    model = Sequential()
    model.add(Dense(3, input_shape=(4,), activation="sigmoid"))
    model.add(Dense(3, activation="sigmoid"))
    model.add(Dense(3, activation="softmax"))
    
    # 采用梯度下降训练模型
    print('训练网络中...')
    opt = SGD(lr=0.1, momentum=0.9, decay=0.1 / 250)
    model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=["accuracy"])
    H = model.fit(trainX, trainY, validation_data=(testX, testY), epochs=250, batch_size=16)
    
    # 预测
    print('评估模型效果...')
    predictions = model.predict(testX, batch_size=16)
    print(classification_report(testY.argmax(axis=1), predictions.argmax(axis=1), target_names=dataset.target_names))
    

    直接运行命令python nn_iris.py,输出的结果如下:

    $ python nn_iris.py 
    Using TensorFlow backend.
    加载数据中...
    训练网络中...
    Train on 112 samples, validate on 38 samples
    Epoch 1/250
    2022-02-08 10:28:19.104933: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 AVX512F FMA
    112/112 [==============================] - 0s 2ms/step - loss: 1.1454 - acc: 0.3214 - val_loss: 1.1867 - val_acc: 0.2368
    Epoch 2/250
    112/112 [==============================] - 0s 48us/step - loss: 1.0828 - acc: 0.3929 - val_loss: 1.2132 - val_acc: 0.5000
    Epoch 3/250
    112/112 [==============================] - 0s 47us/step - loss: 1.0491 - acc: 0.5268 - val_loss: 1.0593 - val_acc: 0.4737
    ...
    Epoch 248/250
    112/112 [==============================] - 0s 46us/step - loss: 0.1319 - acc: 0.9554 - val_loss: 0.0407 - val_acc: 1.0000
    Epoch 249/250
    112/112 [==============================] - 0s 46us/step - loss: 0.1024 - acc: 0.9643 - val_loss: 0.1595 - val_acc: 0.8947
    Epoch 250/250
    112/112 [==============================] - 0s 47us/step - loss: 0.0795 - acc: 0.9821 - val_loss: 0.0335 - val_acc: 1.0000
    评估模型效果...
                 precision    recall  f1-score   support
    
         setosa       1.00      1.00      1.00         9
     versicolor       1.00      1.00      1.00        10
      virginica       1.00      1.00      1.00        19
    
    avg / total       1.00      1.00      1.00        38
    

    这里得到的是100%的准确率。

    (9) CNN

    最后我们要应用卷积神经网络,我们实现一下basic_cnn.py代码。

    同样首先是导入必须的库函数:

    # 导入工具库
    from keras.models import Sequential
    from keras.layers.convolutional import Conv2D
    from keras.layers.convolutional import MaxPooling2D
    from keras.layers.core import Activation
    from keras.layers.core import Flatten
    from keras.layers.core import Dense
    from keras.optimizers import Adam
    from sklearn.preprocessing import LabelBinarizer
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import classification_report
    from PIL import Image
    from imutils import paths
    import numpy as np
    import argparse
    import os
    
    # 配置参数
    ap = argparse.ArgumentParser()
    ap.add_argument("-d", "--dataset", type=str, default="3scenes",
                    help="path to directory containing the '3scenes' dataset")
    args = vars(ap.parse_args())
    
    

    同样是要导入Keras来建立CNN的网络模型,另外因为是处理图像数据,所以PILimutils也是要导入的。

    然后是加载数据和划分训练集和测试集,对于加载数据,这里直接采用原始图像像素数据,只需要对图像数据做统一尺寸的调整,这里是统一调整为32×32,并做归一化到[0,1]的范围。

    # 加载数据并提取特征
    print("抽取图像特征中...")
    imagePaths = paths.list_images(args['dataset'])
    data = []
    labels = []
    
    # 循环遍历所有的图片数据
    for imagePath in imagePaths:
        # 加载图片,然后调整成 32×32 大小,并做归一化到 [0,1]
        image = Image.open(imagePath)
        image = np.array(image.resize((32, 32))) / 255.0
        data.append(image)
    
        # 保存图片的标签信息
        label = imagePath.split(os.path.sep)[-2]
        labels.append(label)
    
    # 对标签编码,从字符串变为整型
    lb = LabelBinarizer()
    labels = lb.fit_transform(labels)
    
    # 划分训练集和测试集
    (trainX, testX, trainY, testY) = train_test_split(np.array(data), np.array(labels), test_size=0.25)
    

    接着定义了一个4层的CNN网络结构,包含3层卷积层和最后一层输出层,优化算法采用的是Adam而不是SGD。代码如下所示:

    # 定义 CNN 网络模型结构
    model = Sequential()
    model.add(Conv2D(8, (3, 3), padding="same", input_shape=(32, 32, 3)))
    model.add(Activation("relu"))
    model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
    model.add(Conv2D(16, (3, 3), padding="same"))
    model.add(Activation("relu"))
    model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
    model.add(Conv2D(32, (3, 3), padding="same"))
    model.add(Activation("relu"))
    model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
    model.add(Flatten())
    model.add(Dense(3))
    model.add(Activation("softmax"))
    
    # 训练模型
    print("训练网络中...")
    opt = Adam(lr=1e-3, decay=1e-3 / 50)
    model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"])
    H = model.fit(trainX, trainY, validation_data=(testX, testY),
                  epochs=50, batch_size=32)
    
    # 预测
    print("评估模型效果...")
    predictions = model.predict(testX, batch_size=32)
    print(classification_report(testY.argmax(axis=1),
                                predictions.argmax(axis=1), target_names=lb.classes_))
    

    运行命令python basic_cnn.py,输出结果如下:

    $ python basic_cnn.py 
    Using TensorFlow backend.
    加载图像数据...
    训练网络中...
    Train on 711 samples, validate on 237 samples
    Epoch 1/50
    711/711 [==============================] - 0s 629us/step - loss: 1.0647 - acc: 0.4726 - val_loss: 0.9920 - val_acc: 0.5359
    Epoch 2/50
    711/711 [==============================] - 0s 313us/step - loss: 0.9200 - acc: 0.6188 - val_loss: 0.7778 - val_acc: 0.6624
    Epoch 3/50
    711/711 [==============================] - 0s 308us/step - loss: 0.6775 - acc: 0.7229 - val_loss: 0.5310 - val_acc: 0.7553
    ...
    Epoch 48/50
    711/711 [==============================] - 0s 307us/step - loss: 0.0627 - acc: 0.9887 - val_loss: 0.2426 - val_acc: 0.9283
    Epoch 49/50
    711/711 [==============================] - 0s 310us/step - loss: 0.0608 - acc: 0.9873 - val_loss: 0.2236 - val_acc: 0.9325
    Epoch 50/50
    711/711 [==============================] - 0s 307us/step - loss: 0.0587 - acc: 0.9887 - val_loss: 0.2525 - val_acc: 0.9114
    评估模型效果...
                 precision    recall  f1-score   support
    
          coast       0.85      0.96      0.90        85
         forest       0.99      0.94      0.97        88
        highway       0.91      0.80      0.85        64
    
    avg / total       0.92      0.91      0.91       237
    

    CNN的准确率是达到92%,它是优于之前的几种机器学习算法的结果。

    5.小结

    这篇简单的机器学习教程文章中,我们调用现有的库来应用对应的机器学习算法,解决了2个简单的场景问题。通过这份简单的入门教程,希望大家了解到:

    (1) 没有任何一种算法是完美的,可以完全适用所有的场景,即便是目前很热门的深度学习方法,也存在它的局限性,所以应该具体问题具体分析!

    (2) 经典的5步机器学习操作流程:

    • 问题抽象与理解
    • 数据准备与处理(预处理、特征提取、特征工程等)
    • 各种机器学习算法
    • 实验结果分析与对比
    • 模型选择与调优

    参考资料

    ShowMeAI系列教程推荐

    相关文章推荐

    展开全文
  • 机器学习基础

    千次阅读 2022-04-05 19:03:33
    追溯到17世纪,贝叶斯、拉普拉斯关于最小二乘法的推导和马尔可夫链,这些构成了机器学习广泛使用的工具和基础。1950年(艾伦.图灵提议建立一个学习机器)到2000年初(有深度学习的实际应用以及最近的进展,比如2012...

    1、基本概念

    1.1  发展历史

             机器学习实际上已经存在了几十年或者也可以认为存在了几个世纪。追溯到17世纪,贝叶斯拉普拉斯关于最小二乘法的推导和马尔可夫链,这些构成了机器学习广泛使用的工具和基础。1950年(艾伦.图灵提议建立一个学习机器)到2000年初(有深度学习的实际应用以及最近的进展,比如2012年的AlexNet),机器学习有了很大的进展。

            从20世纪50年代研究机器学习以来,不同时期的研究途径和目标并不相同,可以划分为四个阶段。

            第一阶段是20世纪50年代中叶到60年代中叶,这个时期主要研究“有无知识的学习”。这类方法主要是研究系统的执行能力。这个时期,主要通过对机器的环境及其相应性能参数的改变来检测系统所反馈的数据,就好比给系统一个程序,通过改变它们的自由空间作用,系统将会受到程序的影响而改变自身的组织,最后这个系统将会选择一个最优的环境生存。在这个时期最具有代表性的研究就是Samuet的下棋程序。但这种机器学习的方法还远远不能满足人类的需要。

            第二阶段从20世纪60年代中叶到70年代中叶,这个时期主要研究将各个领域的知识植入到系统里,在本阶段的目的是通过机器模拟人类学习的过程。同时还采用了图结构及其逻辑结构方面的知识进行系统描述,在这一研究阶段,主要是用各种符号来表示机器语言,研究人员在进行实验时意识到学习是一个长期的过程,从这种系统环境中无法学到更加深入的知识,因此研究人员将各专家学者的知识加入到系统里,经过实践证明这种方法取得了一定的成效。在这一阶段具有代表性的工作有Hayes-Roth和Winson的对结构学习系统方法。

    第三阶段从20世纪70年代中叶到80年代中叶,称为复兴时期。在此期间,人们从学习单个概念扩展到学习多个概念,探索不同的学习策略和学习方法,且在本阶段已开始把学习系统与各种应用结合起来,并取得很大的成功。同时,专家系统在知识获取方面的需求也极大地刺激了机器学习的研究和发展。在出现第一个专家学习系统之后,示例归纳学习系统成为研究的主流,自动知识获取成为机器学习应用的研究目标。1980年,在美国的卡内基梅隆(CMU)召开了第一届机器学习国际研讨会,标志着机器学习研究已在全世界兴起。此后,机器学习开始得到了大量的应用。1984年,Simon等20多位人工智能专家共同撰文编写的MachineLearning文集第二卷出版,国际性杂志Machine Learning创刊,更加显示出机器学习突飞猛进的发展趋势。这一阶段代表性的工作有Mostow的指导式学习、Lenat的数学概念发现程序、Langley的BACON程序及其改进程序。

    第四阶段20世纪80年代中叶,是机器学习的最新阶段。这个时期的机器学习具有如下特点:

    (1)机器学习已成为新的学科,它综合应用了心理学、生物学、神经生理学、数学、自动化和计算机科学等形成了机器学习理论基础。

    (2)融合了各种学习方法,且形式多样的集成学习系统研究正在兴起。

    (3)机器学习与人工智能各种基础问题的统一性观点正在形成。

    (4)各种学习方法的应用范围不断扩大,部分应用研究成果已转化为产品。

    (5)与机器学习有关的学术活动空前活跃。 

    1.2 发展现状

    机器学习是人工智能及模式识别领域的共同研究热点,其理论和方法已被广泛应用于解决工程应用和科学领域的复杂问题。2010年的图灵奖获得者为哈佛大学的Leslie vlliant教授,其获奖工作之一是建立了概率近似正确(Probably Approximate Correct,PAC)学习理论;2011年的图灵奖获得者为加州大学洛杉矶分校的Judea Pearll教授,其主要贡献为建立了以概率统计为理论基础的人工智能方法。这些研究成果都促进了机器学习的发展和繁荣。

    机器学习是研究怎样使用计算机模拟或实现人类学习活动的科学,是人工智能中最具智能特征,最前沿的研究领域之一。自20世纪80年代以来,机器学习作为实现人工智能的途径,在人工智能界引起了广泛的兴趣,特别是近十几年来,机器学习领域的研究工作发展很快,它已成为人工智能的重要课题之一。机器学习不仅在基于知识的系统中得到应用,而且在自然语言理解、非单调推理、机器视觉模式识别等许多领域也得到了广泛应用。一个系统是否具有学习能力已成为是否具有“智能”的一个标志。机器学习的研究主要分为两类研究方向:第一类是传统机器学习的研究,该类研究主要是研究学习机制,注重探索模拟人的学习机制;第二类是大数据环境下机器学习的研究,该类研究主要是研究如何有效利用信息,注重从巨量数据中获取隐藏的、有效的、可理解的知识。

    机器学习历经70年的曲折发展,以深度学习为代表借鉴人脑的多分层结构、神经元的连接交互信息的逐层分析处理机制,自适应、自学习的强大并行信息处理能力,在很多方面收获了突破性进展,其中最有代表性的是图像识别领域。 

    1.3 传统机器学习的研究现状

    传统机器学习的研究方向主要包括决策树随机森林人工神经网络贝叶斯学习等方面的研究。

    决策树是机器学习常见的一种方法。20世纪末期,机器学习研究者J.Ross Quinlan将Shannon的信息论引入到了决策树算法中,提出了ID3算法。1984年I.Kononenko、E.Roskar和I.Bratko在ID3算法的基础上提出了AS-SISTANTAlgorithm,这种算法允许类别的取值之间有交集。同年,A.Hart提出了Chi-Squa统计算法,该算法采用了一种基于属性与类别关联程度的统计量。1984年L.Breiman、C.Ttone、R.Olshen和J.Freidman提出了决策树剪枝概念,极大地改善了决策树的性能。1993年,Quinlan在ID3算法的基础上提出了一种改进算法,即C4.5算法。C4.5算法克服了ID3算法属性偏向的问题增加了对连续属性的处理通过剪枝,在一定程度上避免了“过度适合”现象。但是该算法将连续属性离散化时,需要遍历该属性的所有值,降低了效率,并且要求训练样本集驻留在内存,不适合处理大规模数据集。2010年Xie提出一种CART算法,该算法是描述给定预测向量X条件分布变量Y的一个灵活方法,已经在许多领域得到了应用。CART算法可以处理无序的数据,采用基尼系数作为测试属性的选择标准。CART算法生成的决策树精确度较高,但是当其生成的决策树复杂度超过一定程度后,随着复杂度的提高,分类精确度会降低,所以该算法建立的决策树不宜太复杂。2007年房祥飞表述了一种叫SLIQ(决策树分类)算法,这种算法的分类精度与其他决策树算法不相上下,但其执行的速度比其他决策树算法快,它对训练样本集的样本数量以及属性的数量没有限制。SLIQ算法能够处理大规模的训练样本集,具有较好的伸缩性;执行速度快而且能生成较小的二叉决策树。SLIQ算法允许多个处理器同时处理属性表,从而实现了并行性。但是SLIQ算法依然不能摆脱主存容量的限制。2000年RajeevRaSto等提出了PUBLIC算法,该算法是对尚未完全生成的决策树进行剪枝,因而提高了效率。近几年模糊决策树也得到了蓬勃发展。研究者考虑到属性间的相关性提出了分层回归算法、约束分层归纳算法和功能树算法,这三种算法都是基于多分类器组合的决策树算法,它们对属性间可能存在的相关性进行了部分实验和研究,但是这些研究并没有从总体上阐述属性间的相关性是如何影响决策树性能。此外,还有很多其他的算法,如Zhang.J于2014年提出的一种基于粗糙集的优化算法、Wang.R在2015年提出的基于极端学习树的算法模型等。

    随机森林(RF)作为机器学习重要算法之一,是一种利用多个树分类器进行分类和预测的方法。近年来,随机森林算法研究的发展十分迅速,已经在生物信息学、生态学、医学、遗传学、遥感地理学等多领域开展的应用性研究。 

    人工神经网络(Artificial Neural Networks,ANN)是一种具有非线性适应性信息处理能力的算法,可克服传统人工智能方法对于直觉,如模式、语音识别、非结构化信息处理方面的缺陷。早在20世纪40年代人工神经网络已经受到关注,并随后得到迅速发展。 

    贝叶斯学习是机器学习较早的研究方向,其方法最早起源于英国数学家托马斯,贝叶斯在1763年所证明的一个关于贝叶斯定理的一个特例。经过多位统计学家的共同努力,贝叶斯统计在20世纪50年代之后逐步建立起来,成为统计学中一个重要的组成部分。 

    1.4 大数据环境下机器学习的研究现状

    大数据的价值体现主要集中在数据的转向以及数据的信息处理能力等等。在产业发展的今天,大数据时代的到来,对数据的转换,数据的处理数据的存储等带来了更好的技术支持,产业升级和新产业诞生形成了一种推动力量,让大数据能够针对可发现事物的程序进行自动规划,实现人类用户以计算机信息之间的协调。另外现有的许多机器学习方法是建立在内存理论基础上的。大数据还无法装载进计算机内存的情况下,是无法进行诸多算法的处理的,因此应提出新的机器学习算法,以适应大数据处理的需要。大数据环境下的机器学习算法,依据一定的性能标准,对学习结果的重要程度可以予以忽视。采用分布式和并行计算的方式进行分治策略的实施,可以规避掉噪音数据和冗余带来的干扰,降低存储耗费,同时提高学习算法的运行效率。 

    随着大数据时代各行业对数据分析需求的持续增加,通过机器学习高效地获取知识,已逐渐成为当今机器学习技术发展的主要推动力。大数据时代的机器学习更强调“学习本身是手段"机器学习成为一种支持和服务技术。如何基于机器学习对复杂多样的数据进行深层次的分析,更高效地利用信息成为当前大数据环境下机器学习研究的主要方向。所以,机器学习越来越朝着智能数据分析的方向发展,并已成为智能数据分析技术的一个重要源泉。另外,在大数据时代,随着数据产生速度的持续加快,数据的体量有了前所未有的增长,而需要分析的新的数据种类也在不断涌现,如文本的理解、文本情感的分析、图像的检索和理解、图形和网络数据的分析等。使得大数据机器学习和数据挖掘等智能计算技术在大数据智能化分析处理应用中具有极其重要的作用。在2014年12月中国计算机学会(CCF)大数据专家委员会上通过数百位大数据相关领域学者和技术专家投票推选出的“2015年大数据十大热点技术与发展趋势”中,结合机器学习等智能计算技术的大数据分析技术被推选为大数据领域第一大研究热点和发展趋势。 

    简而言之,机器学习更重要的是学习相应的映射。

    2 机器学习三个要素

    机器学习是从已有的有限的观测数据中学习出具有一般性的规律,并可以将总结出来的规律推广到未观测样本上,机器学习可以将其分为三个要素:模型、学习准则、优化算法。

    2. 1 模型

     模型通俗概括: 可以从数据中学习到的,可以实现特定功能(映射)的函数。 进一步专业性概括:模型是在指定的假设空间中,确定学习策略,通过优化算法去学习到的由输入 到输出的映射。分为线性模型和非线性模型。

    2..1.1线性模型

    给定由d个属性描述的示例X=(X1;X2;X3……;Xd),其中Xi是X的X在第i个属性上的取值,线性模型(Liner model)试图学得一个通过属性的线性组合来预测的函数,即:
    f(x)=W1X1+W2X2+……+WdXd+b

    2.1.2 非线性模型

    简单的判断一个模型是不是非线性,就是关注非线性本身,判断它的参数是不是非线性的。非线性有很多种形象,这也是为什么非线性模型能够那么好的拟合那些曲折的函数曲线的原因。比如下面这个:

     线性和非线性

    线性与非线性的区别

    1)、线性和非线性的区别是是否可以用直线将样本划分开(这个观点是对的)

    2)、线性模型可以是用曲线拟合样本,但是分类的决策边界一定是直线的,例如logistics模型

    3)、区分是否为线性模型,主要是看一个乘法式子中自变量x前的系数w,如果w只影响一个x,那么此模型为线性模型。或者判断决策边界是否是线性的

    2.2 学习准则

           好的模型应该在输入输出取值覆盖真实的情况,模型函数与真实的映射函数之间一致,计算出的误差在很小的范围内。可以通过期望风险这个参数来判断模型的好坏。p(x,y)表示真实的数据分布,£(f(x),y)为损失函数。

     

    2.2.1 损失函数

     损失函数是一个非负实数函数,用来衡量真实标签与模型预测之间的误差。

    常用的损失函数

    0-1损失

     0-1损失是指,预测值和目标值不相等为1,否则为0:

    虽然0-1损失能客观评价模型的好坏,但缺点是数学性不好,不连续,且导数等于0,这在反向传播中极其不友好。难以优化,因此经常用其他函数代替。

     交叉熵损失函数

    2.2.2 风险最小化准则

     过拟合趋向于无穷大时,经验风险就 趋向于期望风险。然而通常情况下,我们无法获取无限的训练样本,并且训练样本往往是真实数据的一个很小的子集或者包含一定的噪声数据,不能很好地反映全部数据的真实分布。经验风险最小化原则很容易导致模型在训练集上错误率很低,但是在未知数据上错误率很高。这就是所谓的过拟合(Overfitting)

    过拟合问题往往是由于训练数据少和噪声以及模型能力强等原因造成的。为了解决过拟合问题,一般在经验风险最小化的基础上再引入参数的正则化(Regularization),来限制模型能力,使其不要过度地最小化经验风险。这种准则就是结构风险最小化(Structure Risk Minimization,SRM)准则。

    欠拟合:和过拟合相反的一个概念是欠拟合(Underfitting),即模型不能很好地拟合训练数据,在训练集的错误率比较高。欠拟合一般是由于模型能力不足造成的。

    2.3优化算法

    参数和超参数

    参数作为模型从历史训练数据中学到的一部分,是机器学习算法的关键。

    单来说,模型参数就是模型内部的配置变量,可以用数据估计它的值。

    具体来讲,模型参数有以下特征:

    • 进行模型预测时需要模型参数。
    • 模型参数值可以定义模型功能。
    • 模型参数用数据估计或数据学习得到。
    • 模型参数一般不由实践者手动设置。
    • 模型参数通常作为学习模型的一部分保存。

    通常使用优化算法估计模型参数,优化算法是对参数的可能值进行的一种有效搜索。

    模型参数的一些例子包括:

    • 人造神经网络中的权重。
    • 支持向量机中的支持向量。
    • 线性回归或逻辑回归中的系数。

    什么是模型超参数?

    模型超参数是模型外部的配置,其值不能从数据估计得到。

    具体特征有:

    • 模型超参数常应用于估计模型参数的过程中。
    • 模型超参数通常由实践者直接指定。
    • 模型超参数通常可以使用启发式方法来设置。
    • 模型超参数通常根据给定的预测建模问题而调整。

    怎样得到它的最优值:对于给定的问题,我们无法知道模型超参数的最优值。但我们可以使用经验法则来探寻其最优值,或复制用于其他问题的值,也可以通过反复试验的方法。

    模型超参数的一些例子包括:

    • 训练神经网络的学习速率。
    • 支持向量机的C和sigma超参数。
    • k邻域中的k。

    “模型参数”和“模型超参数”

    二者的联系:当针对特定问题调整机器学习算法时,例如在使用网格搜索或随机搜索时,你将调整模型或命令的超参数,以发现一个可以使模型预测最熟练的模型参数。许多模型中重要的参数无法直接从数据中估计得到。例如,在K近邻分类模型中...这种类型的模型参数被称为调整参数,因为没有可用的分析公式来为其计算一个合适的值。

    区分: 模型超参数通常被称为模型参数,这种叫法很容易让人产生误解。解决这个问题的一个很好的经验法则如下:如果你必须手动指定一个“模型参数”,那么它可能就是一个模型超参数。

    2.3.1梯度下降算法

    Part2.1里面已经介绍了梯度下降法的思想,遗留了两个问题。第一就是如何计算“陡峭”程度,我们这里把它叫做梯度,我们用∇J_θ来代替。第二个也就是步长问题,我们用一个α学习率来代表这个步长,α越大代表步长越大。知道了这两个值,我们如何去得到θ参数的更新表达式了?

    J是关于θ的一个函数,假设初始时我们在θ_1这个位置,要从这个点走到J的最小值点,也就是山底。首先我们先确定前进的方向,也就是梯度的反向“-∇J_θ”,然后走一段距离的步长,也就是α,走完这个段步长,就到达了θ_2这个点了。表达式如下图:

     我们按照上述表达式一直不停地更新θ的值,一直到θ收敛不变为止,当我们到达山底,此时函数的梯度就是0了,θ值也就不会再更新了,因为表达式的后半部分一直是0了。整个下降过程中损失函数的值是一定在减少,但是我们想学习出来的参数值θ不一定一直在减小

    2.3.2 提前停止

    提前终止的目的是为了防止过拟合,如果我们只要返回使验证误差最低的参数,就可以获得验证集误差更低的模型。首先我们要保存好现在的模型(网络结构和权值),训练num_batch次(即一个epoch),得到新的模型。将测试集作为新模型的输入,进行测试。如果我们发现测试误差比上次得到的测试误差大,我们并不会马上终止测试,而是再继续进行几个epoch的训练与测试,如果测试误差依旧没有减小,那么我们就认为该试验在上一次达到最低测试误差时停下来。具体算法可参见《deep learning》

    详见(8条消息) AI学习之深度学习系列---提前终止_laojiangseu的博客-CSDN博客_深度学习提前终止icon-default.png?t=M276https://blog.csdn.net/u012587076/article/details/78702526

    2.3.3随机梯度下降

    在每次更新时用1个样本,可以看到多了随机两个字,随机也就是说我们用样本中的一个例子来近似我所有的样本,来调整θ,因而随机梯度下降是会带来一定的问题,因为计算得到的并不是准确的一个梯度,对于最优化问题,凸问题,虽然不是每次迭代得到的损失函数都向着全局最优方向, 但是大的整体的方向是向全局最优解的,最终的结果往往是在全局最优解附近。但是相比于批量梯度,这样的方法更快,更快收敛,虽然不是全局最优,但很多时候是我们可以接受的,所以这个方法用的也比上面的多。下图是其更新公式

     

    2.3.4 小批量梯度下降法

        在每次更新时用b个样本,其实批量的梯度下降就是一种折中的方法,他用了一些小样本来近似全部的,其本质就是我1个指不定不太准,那我用个30个50个样本那比随机的要准不少了吧,而且批量的话还是非常可以反映样本的一个分布情况的。在深度学习中,这种方法用的是最多的,因为这个方法收敛也不会很慢,收敛的局部最优也是更多的可以接受!

     优点:
      (1)由于不是在全部训练数据上的损失函数,而是在每轮迭代中,随机优化某一条训练数据上的损失函数,这样每一轮参数的更新速度大大加快
    缺点:
      (1)准确度下降。由于即使在目标函数为强凸函数的情况下,SGD仍旧无法做到线性收敛。
      (2)可能会收敛到局部最优,由于单个样本并不能代表全体样本的趋势。
      (3)不易于并行实现

    解释一下为什么SGD收敛速度比BGD要快:
      答:这里我们假设有30W个样本,对于BGD而言,每次迭代需要计算30W个样本才能对参数进行一次更新,需要求得最小值可能需要多次迭代(假设这里是10);而对于SGD,每次更新参数只需要一个样本,因此若使用这30W个样本进行参数更新,则参数会被更新(迭代)30W次,而这期间,SGD就能保证能够收敛到一个合适的最小值上了。也就是说,在收敛时,BGD计算了 10×30W 次,而SGD只计算了 1×30W 次。

    参考(8条消息) 批量梯度下降法(BGD)、随机梯度下降法(SGD)和小批量梯度下降法(MBGD)_Andyato0520的博客-CSDN博客_批量梯度下降icon-default.png?t=M276https://blog.csdn.net/yato0514/article/details/82261821

    展开全文
  • 一文读懂机器学习分类全流程

    千次阅读 多人点赞 2022-05-30 15:21:32
    在本文中,作者将带你了解机器学习分类的全流程,从问题分析>数据预处理>分类器选择>模型构建>精度评价>模型发布为Web应用。从0带读者入门机器学习分类。

    608ab26ec97840f2a4fa8dd46da22706.png

    目录

     

    前言

    提出问题

    一、介绍

    1.分类简介

    2.imblearn的安装

    二、数据加载及预处理

    1.加载并查看数据

    ①导入Python第三方库   

    ②调用并查看数据

    2.查看数据分布

    ①各国样本分布直方图

    ②各国样本划分

    3.各国最受欢迎食材可视化

    4.平衡数据集

    ①样本插值采样

    三、分类器选择

    四、逻辑回归模型构建

    1.数据导入及查看

    2.可训练特征与预测标签选择及数据集划分

    3.构建逻辑回归模型及精度评价

    4.模型测试

    五、更多分类模型

    1.第三方库导入

    2.测试不同分类器

    ①线性SVC分类器

    ②K-近邻分类器

    ③SVM分类器

    ④集成分类器

    六、模型发布为Web应用

    1.模型打包

    2.配置Flask应用

    ②app.py

    3.应用运行及测试

    结论


     

    前言

            在本文中,你将学到:

    0 复习数据预处理及可视化

    1 了解分类的基本概念

    2 使用多种分类器来对比模型精度

    3 掌握使用分类器列表的方式来批处理不同模型

    4 将机器学习分类模型部署为Web应用

    提出问题

            本文我们所用的数据集是亚洲美食数据集,其包括了亚洲5个国家的美食食谱与所属的国家。我们构建模型的目的是解决:

    如何根据美食所用食材判断其所属国家

            即以美食食材为可训练特征,所属国家为预测标签构建机器学习分类模型。

     

    一、介绍

    1.分类简介

            分类是经典机器学习的基本重点,也是监督学习的一种形式,与回归技术有很多共同之处。其通常分为两类:二元分类和多元分类。本文中,我将使用亚洲美食数据集贯穿本次学习。

    还记得我在之前文章中提到的:

    0 线性回归可帮助我们预测变量之间的关系,并准确预测新数据点相对于该线的位置。因此,例如,预测南瓜在9月与12月的价格。

    1 Logistic回归帮助我们发现“二元类别”:在这个价格点上,这是橙子还是非橙子?

            分类也是机器学习人员和数据科学家的基本工作之一。从二分类(判断邮件是否是垃圾邮件),到使用计算机视觉的复杂分类和分割,其在很多领域都有着很大的作用。

            以更科学的方式陈述该过程:

           我们所使用的分类方法创建了一个预测模型,这个模型使我们能够将输入变量之间的关系映射到输出变量。

    670725bb7b904a1badb0eb98183251f8.png

            分类使用各种算法来确定数据点的标签或类别。我们以亚洲美食数据集为例,看看通过输入一组特征样本,我们是否可以确定其菜肴所属的国家。

            以下是经典机器学习常用的分类方法。

    0 逻辑回归

    1 决策树分类(ID3、C4.5、CART)

    2 基于规则分类

    3 K-近邻算法(K-NN)

    4 贝叶斯分类

    5 支持向量机(SVM)

    6 随机森林(Random Forest)

    2.imblearn的安装

            在开始本文学习之前,我们第一个任务是清理和调整数据集以获得更好的分析结果。我们需要安装的是imblearn库。这是一个基于Python的Scikit-learn软件包,它可以让我们更好地平衡数据。

            在命令行中输入以下代码,使用阿里的镜像来安装 imblearn

    pip install -i https://mirrors.aliyun.com/pypi/simple/ imblearn

            看到如下图所示代表安装成功。

    9f8e99e936714211aba6d1b4194972e9.png

     

    二、数据加载及预处理

    1.加载并查看数据

    ①导入Python第三方库   

    import pandas as pd
    import matplotlib.pyplot as plt
    import matplotlib as mpl
    import numpy as np
    from imblearn.over_sampling import SMOTE

    ②调用并查看数据

    df  = pd.read_csv('cuisines.csv')
    df.head()

            前5行数据如下图所示:

    4db9405c915d4e618a7335e356fb9579.png

            查看数据结构:

    df.info()

    aad8d10e36654b628a69c1a7ab67602b.png

            通过查看数据与其组织结构,我们可以发现数据有2448行,385列,其中有大量的无效数据。

    2.查看数据分布

            我们可以对数据进行可视化来发现数据集中的数据分布。

    ①各国样本分布直方图

            通过调用barh()函数将数据绘制为柱状图。

    df.cuisine.value_counts().plot.barh() #根据不同国家对数据集进行划分

             结果如下:

    f5a7565988fc451bb171128b5e1800e0.png

             我们可以看到,数据集中以韩国料理样本最多,泰国样本最少。美食的数量有限,但数据的分布是不均匀的。我们可以解决这个问题!在此之前,请进一步探索。

    ②各国样本划分

            了解各国美食有多少可用数据并将其打印输出。输入以下代码,从结果中我们可以看到不同国家美食的可用数据:

    thai_df = df[(df.cuisine == "thai")]#提取泰国美食
    japanese_df = df[(df.cuisine == "japanese")]#提取日本美食
    chinese_df = df[(df.cuisine == "chinese")]#提取中国美食
    indian_df = df[(df.cuisine == "indian")]#提取印度美食
    korean_df = df[(df.cuisine == "korean")]#提取韩国美食
    print(f'thai df: {thai_df.shape}')#输出数据结构
    print(f'japanese df: {japanese_df.shape}')#输出数据结构
    print(f'chinese df: {chinese_df.shape}')#输出数据结构
    print(f'indian df: {indian_df.shape}')#输出数据结构
    print(f'korean df: {korean_df.shape}')#输出数据结构

    37a7a5b8f2d54363a3e1fdc109ba7543.png

    3.各国最受欢迎食材可视化

            现在,我们可以更深入的挖掘数据,并了解每种菜肴的成分。在此之前,我们应该对数据进行预处理,删去重复值。

            在python中创建一个函数来删除无用的列,然后按成分数量进行排序。

    def create_ingredient_df(df):
        ingredient_df = df.T.drop(['cuisine','Unnamed: 0']).sum(axis=1).to_frame('value')#从原始数据中删除无效列并统计axis=1的总和赋值给value列
        ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]#提取所有非0值的样本
        ingredient_df = ingredient_df.sort_values(by='value', ascending=False,
        inplace=False)#按照数值的大小进行排序
        return ingredient_df#返回处理并排序后的结果

            现在,我们调用create_ingredient_df()函数来了解泰国美食中,最受欢迎的十大食材。输入以下代码:

    thai_ingredient_df = create_ingredient_df(thai_df)
    thai_ingredient_df.head(10).plot.barh()

            查看泰国美食中十大最受欢迎的食材:

    016773948d374a64b73075572a82738c.png

            我们可以看到,第一名的食材是garlic(大蒜),第十名则是chicken(鸡肉)。

            对中国数据执行同样的操作:

    chinese_ingredient_df = create_ingredient_df(chinese_df)
    chinese_ingredient_df.head(10).plot.barh()

            结果如下,中国美食食材中,最受欢迎的是soy_sauce(酱油),第十名是cayenne(红辣椒):

    4d606c93c827479787918d483fd9aca9.png

            同理,我们也可以输出其他国家的美食食材,这里就不水文了。大家可自行尝试。

            现在,我们需要使用drop()函数删除不同美食间造成混淆的最常见成分以突出各国食材的特色,每个国家的人都喜欢米饭、大蒜和生姜。(可自行可视化查看),我们输入以下代码将其删去。

    feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)#删去最常见的这几列以平衡不同国家之间的混淆
    labels_df = df.cuisine 

    4.平衡数据集

            现在我们已经清理了数据,因为不同国家的样本数量差异较大,我们需要使用SMOTE(“合成少数过度采样技术”)来平衡它。

    SMOTE介绍

    ①样本插值采样

            调用SMOTE对象的 fit_resample() 函数来插值重采样生成新样本。输入以下代码:

    oversample = SMOTE()
    transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
    print(f'new label count: {transformed_label_df.value_counts()}')
    print(f'old label count: {df.cuisine.value_counts()}')

            查看新样本与旧样本的数据量差异:

    53fd56e6e4514e8db52bce861f874eeb.png

            我们可以看到,新样本不同类别标签下的样本数量都在799,它是以旧样本中最大样本量标签为基础构建的,而旧样本则参差不齐,分布不均匀。

            数据质量很好,干净、平衡!🧸🧸

            数据预处理的最后一步是将预处理后的数据导出以后直接调用。输入以下代码:

    transformed_df.to_csv("cleaned_cuisines.csv")#保存至新文件方便下一次直接调用

     

    三、分类器选择

            现在,数据已经经过预处理,我们可以构建分类模型了!

            但是选择什么模型好呢?

            Scikit-learn中的分类算法在监督学习下,在该类别中,我们将找到许多分类方法。这种多样性一见钟情就相当令人眼花缭乱。以下方法都包含分类技术:

    线性模型

    支持向量机

    随机梯度下降

    最近邻

    高斯过程

    决策树

    集成学习(随机森林)

    多类和多输出算法(多类和多标签分类、多类-多输出分类)

            使用什么分类器?

            通常,同时运行几个分类模型,最终找到精度最高的方法很常用。Scikit-learn提供了对所创建数据集的并列比较,比较了下面模型的结果。

    KNeighbors,SVC,GaussianProcessClassifier,DecisionTreeClassifier,RandomForestClassifier,MLPClassifier,AdaBoostClassifier,GaussianNB和QuadraticDiscrinationAnalysis

            下图显示了这些模型可视化的结果:

    ea2a88fe5d1b4a7a99c7b9ae0ffcee17.png

            这种方法在数据集样本较少时可以使用,但随着样本数量的增多,这对计算的负担将会越来越大。我们先不考虑这种方法。请继续向下看😀。

     

    四、逻辑回归模型构建

            在前文中,我们已经对数据进行了预处理,方便起见,我们在后续文章中直接调用经过预处理的 cleaned_cuisines.csv 文件。

            我们在之前的逻辑回归文章中,有学到逻辑回归的基本原理与构建流程,这里我们可以尝试使用逻辑回归来解决问题。

    1.数据导入及查看

            导入第三方库并加载经过预处理的数据cleaned_cuisines.csv。输入以下代码:

    from sklearn.linear_model import LogisticRegression
    from sklearn.model_selection import train_test_split, cross_val_score
    from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
    from sklearn.svm import SVC
    import numpy as np
    import pandas as pd
    cuisines_df = pd.read_csv("cleaned_cuisines.csv")
    print(cuisines_df.info())
    cuisines_df.head()

             数据如下图所示:

    965d7868479f42289347eee320ecd678.png

    2.可训练特征与预测标签选择及数据集划分

            以美食数据集的所属国家列为预测标签Y,食材为可训练特征构建数据集。并以7:3的比例划分训练集与测试集。输入以下代码:

    cuisines_label_df = cuisines_df['cuisine'] #以cuisine列为预测标签
    cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1) #删去无用的列,取食材列为可训练特征
    X_train, X_test, Y_train, Y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)#以7:3比例划分训练集与测试集

    3.构建逻辑回归模型及精度评价

            使用划分好的数据集进行逻辑回归模型构建,打印出模型的精度评价表;测试模型的预测效果。输入以下代码:

    lr = LogisticRegression(multi_class='ovr',solver='liblinear')
    model = lr.fit(X_train, np.ravel(Y_train))
    
    accuracy = model.score(X_test, Y_test)
    print ("Accuracy is {}".format(accuracy))
    Y_pred = model.predict(X_test)
    print(classification_report(Y_test,Y_pred))

             输出结果为ACC系数为:79.1%

            通过打印出该模型的精度评价表我们可以获得更多的模型信息:

    cde6a3492cd543a5b9a29c82621a889b.png

    4.模型测试

            测试模型并查看模型在测试集上将样本分类为不同类别的概率:

    print(f'ingredients: {X_test.iloc[50][X_test.iloc[50]!=0].keys()}')
    print(f'cuisine: {Y_test.iloc[50]}')
    test= X_test.iloc[50].values.reshape(-1, 1).T
    proba = model.predict_proba(test)
    classes = model.classes_
    resultdf = pd.DataFrame(data=proba, columns=classes)
    topPrediction = resultdf.T.sort_values(by=[0], ascending = [False])
    topPrediction.head()

            输出结果为:

    7472a5308fd0484ea4192b3333cdfbd8.png

            可以看到对于测试集上的某个样本,其预测为日本菜的概率为91%。

     

    五、更多分类模型

             在前文中,我们已经构建了逻辑回归模型,那么可以使用其他模型吗,怎么选择呢?

            在开始选择分类器之前,我要向各位读者推荐一个机器学习神器----分类地图

            Scikit-learn提供了一个机器学习分类器选择的地图,它可以进一步帮助使用者缩小分类器的选择范围,如下图:

    cf885a147f834f6d8ff96dc9f8077db1.png

            一旦我们对数据有了一定的了解,此地图将极大的节省我们的试错成本,因为我们可以沿着其路径“行走”来选择需要的模型(看着图走):

    0 我们有大于50个样本

    1 我们想要预测一个类别

    2 我们标记了数据

    3 我们的样本少于100K

    4 我们可以选择线性SVC

    5 如果这不起作用,因为我们有数字数据

    6 我们可以尝试 KNeighbors Classifier

    7 如果这不起作用,请尝试 SVC 和 集成分类器(诸如随机森林)

            这是一条非常有用的工具,对机器学习初学者很友好。

    1.第三方库导入

            按照这条路径,我们首先需要导入多分类器需要的第三方库:

    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.linear_model import LogisticRegression
    from sklearn.svm import SVC
    from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
    from sklearn.model_selection import train_test_split, cross_val_score
    from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
    import numpy as np

    数据和训练样本我们继续使用之前划分好的数据集。

    2.测试不同分类器

    ①线性SVC分类器

            支持向量聚类 (SVC) 是支持向量机机器学习技术系列的子集。在此方法中,你可以选择一个“核函数”来决定如何对标签进行聚类。“C”参数是指“正则化”,它调节参数的影响。内核有多个选择;在这里,我们将其设置为“线性”核函数。概率默认为“假”;在这里,我们将其设置为“true”以收集概率估计值。我们将随机状态设置为“0”,以随机排列数据以获得概率。

            首先我们需要创建一个分类器列表,用于存储之后新增的机器学习分类器。先放入一个线性SVC分类器。

    C = 10 #正则化参数设置为10
    # Create different classifiers.
    classifiers = {
        'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0)
    }#创建分类器列表

             使用线性SVC训练模型并打印精度报告:

    n_classifiers = len(classifiers)
    
    for index, (name, classifier) in enumerate(classifiers.items()):
        classifier.fit(X_train, np.ravel(y_train))
    
        y_pred = classifier.predict(X_test)
        accuracy = accuracy_score(y_test, y_pred)
        print("Accuracy (train) for %s: %0.1f%% " % (name, accuracy * 100))
        print(classification_report(y_test,y_pred))

    7f1a72d544a442f08e15152e2b714d34.png

            查看线性SVC的精度报告,效果还不错,准确率达到了78.6%。 

    ②K-近邻分类器

            K-Neighbors是机器学习常用的方法,可用于监督学习与无监督学习。在此方法中,需要预先创建部分点数,并在这些点周围收集数据,以预测数据的广义标签。

            我们在之前创建的分类器列表中加入KNN分类器代码。运行以后再次查看精度:

    'KNN classifier': KNeighborsClassifier(C),

    39b419b31fb64cce91b49febeadbf590.png

            🤨精度有所下降。。

    ③SVM分类器

            SVM分类器是用于分类和回归任务的支持向量机机器学习方法系列的子集。SVM“将训练样本点映射到高维空间中”,最大化两个类别之间的距离。后续的预测数据被映射到此空间中,来预测其类别。

            我们在K-近邻算法后加入支持向量分类器:

    'SVC': SVC(),

            再次运行,查看SVM支持向量模型结果。

    b279042fc5e44877901e8755b07cdcb5.png

    ​       🥇fantastic!精度上升到了82.4%。

            继续测试其他模型...

    ④集成分类器

            之前的测试精度相当不错。让我们尝试使用集成学习模型,特别是Random Forest和AdaBoost吗,在模型中列表加入下面代码后运行:

    'RFST': RandomForestClassifier(n_estimators=100), 
    'ADA': AdaBoostClassifier(n_estimators=100)

    ec78e70fc28d40b99e27a61e34cfe1b3.png

    ​        很不戳!🎈🎈RFST随机森林的精度达到了83.4%,AdaBoost似乎不太好,不过这不重要。

            集成学习方法结合了几个基本分类器的预测,以提高模型的质量。在我们的示例中,我们使用了 Random TreesAdaBoost

    0 随机森林是一种平均方法,它构建了一个由“决策树”组成的“森林”,注入了随机性,以避免过度拟合。n_estimators参数设置为树的数量。

    1 AdaBoost 将分类器拟合到数据集,然后将该分类器的副本拟合到同一数据集。它侧重于错误分类项目的权重,并调整下一个分类器要更正的拟合度。

            这些技术中的每一种都有大量超参数可以调整。读者可以自行研究每个参数的默认参数,并尝试调整这些参数观察其对模型质量的影响

     

    六、模型发布为Web应用

            我在模型部署的文章中有讲解使用Flask框架和pickle库打包模型及应用构建的全流程,虽然之前按用的时回归模型。但回归模型与分类模型部署的流程一样:

    训练模型>模型打包>应用配置>模型部署>运行测试

    1.模型打包

            方便起见,我们我们使用刚刚训练好的逻辑回归分类模型,将其使用Pickle库将其打包为 美食预测.pkl文件,以便后续的使用。输入以下代码:

    import pickle
    model_filename = 'cuisines.pkl'
    pickle.dump(model, open(model_filename,'wb'))
    model = pickle.load(open('cuisines.pkl','rb'))
    print(model.predict([range(1,381)]))

            输出的结果为 Indian🤣,(这里参数其实有错,因为输入特征有380个,不可能一个一个输入...我自己就编了点,还是三哥吃的杂。项目实践中我们对大量样本常常使用批处理,只有小样本才这样直接输入)。

    8bbd56890f214fc8812d212812fda0f5.png

            可以看到文件夹下已经生成了打包好的模型。😊

    2.配置Flask应用

            详细配置请看:机器学习系列8 基于Python构建Web应用以使用机器学习模型

            我们这里只配置关键文件index.html和app.py,其他文件配置请看此文。

    ①index.html

    <!DOCTYPE html>
    <html>
      <head>
        <meta charset="UTF-8">
        <title>🍕亚洲美食预测器🍖</title>
        <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
      </head>
    
      <body>
        <div class="grid">
    
          <div class="box">
    
            <p>根据拥有的食材来预测UFO出现的国家!</p>
            <p>包含的食材填1,不包含的填0</p>
            <form action="{{ url_for('predict')}}" method="post">
              <input type="number" name="cayenne" placeholder="cayenne" required="required" min="0" max="60" />
              <input type="number" name="onion" placeholder="onion" required="required" />
              <input type="number" name="pear" placeholder="pear" required="required" />
    		  <input type="number" name="radish" placeholder="radish" required="required" />
    		  <input type="number" name="sake" placeholder="sake" required="required" />
    		  <input type="number" name="scallion" placeholder="scallion" required="required" />
    		  <input type="number" name="sesame_oil" placeholder="sesame_oil" required="required" />
    		  <input type="number" name="vegetable" placeholder="vegetable" required="required" />
    		  <input type="number" name="vegetable_oil" placeholder="vegetable_oil" required="required" />
              <button type="submit" class="btn">预测</button>
            </form>
    
            <p>{{ prediction_text }}</p>
    
          </div>
    
        </div>
    
      </body>
    </html>

    ②app.py

    import numpy as np
    from flask import Flask, request, render_template
    import pickle
    
    app = Flask(__name__)#初始化APP
    
    model = pickle.load(open("cuisines.pkl", "rb"))#加载模型
    
    
    @app.route("/")#装饰器
    def home():
        return render_template("index.html")#先引入index.html,同时根据后面传入的参数,对html进行修改渲染。
    
    
    @app.route("/predict", methods=["POST"])
    def predict():
    
        int_features = [int(x) for x in request.form.values()]#存储用户输入的参数
        int_features = int_features+list(range(1,372)) #凑数
        final_features = [np.array(int_features)]#将用户输入的值转化为一个数组
        prediction = model.predict(final_features)#输入模型进行预测
        output = prediction[0]#将预测值传入output
    
    
        return render_template(
            "index.html", prediction_text="Likely country: {}".format(output)#将预测值返回到Web界面,使我们看到
        )
    
    
    if __name__ == "__main__":
        app.run(debug=True)#调试模式下运行文件,实时反应结果。仅限测试使用,生产模式下不要使用

            软件结构如下图:

    2f37575f9e264ec184320c4d364087b2.png

    3.应用运行及测试

            在命令行cd切换路径至当前目录下,输入以下代码,将出现的链接复制到浏览器打开:

    python app.py

    708fa0f4deda4fdfad5279c9f754e12a.png​​

            按要求输入特征,代码运行成功,输出印度:

    b1b6f6e665924a6a97dcf9ae8d4777c2.png

             至此,本文内容结束!

     

    结论

            在本文中,作者对机器学习分类的概念进行了简单的介绍,详细的讲解了数据预处理,分类器选择、模型训练及精度评价,还有最后的Web应用发布。在今后的文章中,我将创作更多的机器学习文章,以文督学,感谢观看!

     

     

    4b3eff2300744e8e85b8eee2f0f80a13.png#pic_center



       如果觉得我的文章对您有帮助,三连+关注便是对我创作的最大鼓励!

    “本站所有文章均为原创,欢迎转载,请注明文章出处:https://blog.csdn.net/qq_45590504/category_11752103.html?spm=1001.2014.3001.5482百度和各类采集站皆不可信,搜索请谨慎鉴别。技术类文章一般都有时效性,本人习惯不定期对自己的博文进行修正和更新,因此请访问出处以查看本文的最新版本。”

    ​系列文章

    机器学习系列0 机器学习思想_GISer Liu的博客-CSDN博客

    机器学习系列1 机器学习历史_GISer Liu的博客-CSDN博客

    机器学习系列2 机器学习的公平性_GISer Liu的博客-CSDN博客_公平机器学习

    机器学习系列3 机器学习的流程_GISer Liu的博客-CSDN博客

    机器学习系列4 使用Python创建Scikit-Learn回归模型_GISer Liu的博客-CSDN博客

    机器学习系列5 利用Scikit-learn构建回归模型:准备和可视化数据(保姆级教程)_GISer Liu的博客-CSDN博客
    机器学习系列6 使用Scikit-learn构建回归模型:简单线性回归、多项式回归与多元线性回归_GISer Liu的博客-CSDN博客_多元多项式回归机器学习系列7 基于Python的Scikit-learn库构建逻辑回归模型_GISer Liu的博客-CSDN博客

    机器学习系列8 基于Python构建Web应用以使用机器学习模型_GISer Liu的博客-CSDN博客

     

     

    展开全文
  • 【OpenCV学习】(十三)机器学习

    千次阅读 多人点赞 2022-01-25 16:42:17
    【OpenCV学习】(十三)机器学习 背景 OpenCV中也提供了一些机器学习的方法,例如DNN;本篇将简单介绍一下机器学习的一些应用,对比传统和前沿的算法,能从其中看出优劣; 一、人脸识别 主要有以下两种实现方法: 1...
  • 机器学习教程 - 分步指南

    千次阅读 2021-12-10 20:24:07
    机器学习 (ML)是技术领域最受关注的话题之一。如果你已经了解机器学习和相关技术的基础知识以及它的应用领域,本文将对这些知识进行补充。如果你还不熟悉机器学习,本教程中涵盖的基础知识会帮你快速上手。文章较长...
  • 02 隐私保护和机器学习 分布式机器学习,最开始是用于解决单台计算机无法承载完整的模型训练任务,需要多台计算机并行计算的问题。现在,一个新的应用场景出现了,而且是在一个情理之中但意料之外的地方:隐私保护...
  • 机器学习7个主要领域

    万次阅读 多人点赞 2019-06-13 08:24:58
    机器学习是识别隐藏在数据中的可能性并将其转化为完全成熟机会的技术。巧合的是,机会是促进业务运营并在竞争对手中脱颖而出的因素。 了解机器学习算法如何应用于各个领域以获得可带来合法业务优势的结果至关重要。...
  • Azure机器学习——Azure机器学习介绍

    千次阅读 2020-03-18 12:05:54
    Azure 机器学习介绍一、什么是Azure机器学习?二、Azure 机器学习的几个重要概念工作区(Workspace)数据存储(Datastore)计算目标(Compute Targets)本地资源Azure Machine Learning compute cluster远程虚拟机...
  • 北京交通大学-图像处理与机器学习

    千次阅读 热门讨论 2022-03-04 15:11:20
    图像处理与机器学习 B站主页 啥都会一点的研究生 课程B站视频 【北交】图像处理与机器学习 人工智能技术探讨群1 78174903 人工智能技术探讨群2 571218304 人工智能技术探讨群3 584723646 课程目录及...
  • 这篇文章将介绍基于机器学习的恶意代码检测技术,主要参考郑师兄的视频总结,包括机器学习概述与算法举例、基于机器学习方法的恶意代码检测、机器学习算法在工业界的应用。同时,我再结合自己的经验进行扩充,详细...
  • Python 机器学习经典实例

    万次阅读 多人点赞 2018-04-12 10:44:15
    本书首先通过实用的案例介绍机器学习的基础知识,然后介绍一些稍微复杂的机器学习算法,例如支持向量机、极端随机森林、隐马尔可夫模型、条件随机场、深度神经网络,等等。 用最火的 Python 语言、通过各种各样的...
  • 这是作者的系列网络安全自学教程,主要是关于网安工具和实践操作的在线笔记,特分享出来与博友共勉,希望您...这篇文章换个口味,将分享机器学习在安全领域的应用,并复现一个基于机器学习(逻辑回归)的恶意请求识别。
  • 《基于机器学习的数据库技术综述》 李国良、周煊赫等著,发表于《计算机学报》,2020-11-5. 文章结构导图 整体概述 传统数据库技术往往依赖于启发式算法或者人工干预,例如数据库参数调优、故障诊断、索引推荐等。...
  • 前言很多深度学习入门者或多或少对计算机配置需求有一些疑惑。入门的硬性需求是什么,应该买什么样的电脑,什么样的显卡比较适合,自己的笔记本可以使用吗等等问题。这些问题之前我也有很多疑惑,现在总结了下,为...
  • 文章目录一、什么是机器学习二、机器学习的流程(一)数据收集(二)数据预处理(三)特征工程(四)模型构建和训练三、机器学习该如何学(一)AI时代首选Python(二)PyCharm可视化编辑器和Anaconda大礼包1、...
  • 自动机器学习AutoML

    千次阅读 多人点赞 2020-11-01 09:24:09
    研究背景:随着深度神经网络的不断发展,各种...自此,人工智能又有了更进一步的发展,人们开始探索如何利用已有的机器学习知识和神经网络框架来让人工智能自主搭建适合业务场景的网络,人工智能的另一扇大门被打开。
  • 1、安装Anaconda,构造虚拟环境 这里可以参考我的另一篇文章,里面很详细:机器学习基础环境部署 | 机器学习系列_阿良的博客-CSDN博客_机器学习 环境搭建 官方给的是python3.8的虚拟环境,我们也构造一个,打开...
  • 引子市场上用于深度学习训练计算机大致情况如下:(1)服务器/工作站(支持2、4、8块GPU架构):普遍存在噪音大,无法放置于办公环境,必须放到专门的机房,维护成本高,另外数据存储带宽、延迟、容量也不尽如意。...
  •   本篇主要是让大家熟悉机器学习实际项目中的全流程,并伴随案例讲解,通过让大家动手了解实际机器学习项目的大体流程,以及面对一些常见情况的处理方法 编程环境: Anaconda3:juputer notebook Python3 Pycharm...
  • 文章目录 一、OpenCV4头文件介绍 二、读取图像 二、显示图像 三、保存图像 四、实战小结 五、视频的读取与保存 环境配置与搭建: OpenCV4机器学习(一):OpenCV4+VS2017环境搭建与配置 一、OpenCV4头文件介绍 想要...
  • 近年来,深度学习被应用到越来越多的领域,在艺术创作里,显得尤为有趣,艺术风格迁移可以轻松地创建梵高、莫奈以及任何艺术家风格的图像。这场 Chat 主要介绍深度学习在艺术风格迁移领域中的应用,并通过算法详解和...
  • 机器学习】解释机器学习模型

    千次阅读 2018-08-23 10:05:54
    在这篇博客文章中,我试图解释机器学习中可解释性的重要性,并讨论一些您可以自己试验的简单操作和框架。 关于机器学习的xkcd   为什么机器学习中的可解释性很重要? 在传统统计中,我们通过调查整个数据来...
  • 虽然 Python 和 C++编程语言已成为机器学习框架的流行选择,但 JavaScript 也并不落后。环顾四周,可能会发现 JavaScript 框架也已在 AI 中实现。事实上,根据 GitHub 对最佳机器学习技术的评论,JavaScript 排在 ...
  • 机器学习平台建设

    万次阅读 多人点赞 2018-09-13 17:53:43
    本文从机器学习平台的架构开始,再到具体的功能,然后从需求的角度带给读者思考,找到合适的机器学习平台建设之路。最后,推荐了微软开源开放的机器学习平台OpenPAI,是可私有部署的机器学习训练平台。 本文不少...
  • 文章目录机器学习算法有什么作用?泛化很难,但很强大我们更喜欢更简单的模型机器学习并不适用于所有问题 我最近收到一个问题: 机器学习模型如何对它以前从未见过的数据做出准确的预测? 答案是机器学习的泛化...
  • 本文介绍Spark中用于大数据机器学习的板块MLlib/ML,讲解机器学习工作流(Pipeline)及其构建方式,并详解讲解基于DataFrame的Spark ML特征工程,包括二值化、定边界离散化、标准化、特征抽取等。
  • 文章目录一、显卡和GPU1. 显卡是什么?2. GPU是什么?(1)GPU和显卡的关系...显卡(Video card,Graphics card)全称显示接口卡,又称显示适配器,是计算机最基本配置、最重要的配件之一。 就像电脑联网需要网卡,主.
  • 例如,新款MacBook Air相比于上一代,CPU性能提升3.5倍,GPU性能提升 5 倍,机器学习能力提升9倍,固态硬盘的性能也提升了 2 倍。 新款MacBook Pro,CPU性能比上一代提升了 2.8 倍,GPU提升5 倍,机器学习能力提升 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 106,486
精华内容 42,594
热门标签
关键字:

机器学习计算机配置