精华内容
下载资源
问答
  • Pointnet语义分割任务S3DIS数据上的注意点

    万次阅读 多人点赞 2020-04-09 21:44:56
    前言 Pointnet的网络结构和源码解释,已在之前写了次总结,本次主要针对...首先,Pointnet一文中针对三个不同的任务使用到了三个数据,分别为: 点云分类(3D Object Classification)——ModelNet40,下载命令在...

    前言

    Pointnet的网络结构和源码解释,已在之前写了次总结,本次主要针对论文中的数据集以.h5为TensorFlow的输入格式进行解释,记录如何制作H5文件,以提供给TensorFlow,PyTorch框架中进行训练。
    首先,Pointnet一文中针对3个不同的任务使用到了三个数据集,分别为:

    • 点云分类(3D Object Classification)——ModelNet40,下载命令在provider.py中,运行python train.py后便会自动下载(416MB)到**data/**文件夹下,每个点云包含从形状表面均匀采样的2048个点。每个云均值为零,并归一到单位球面。data/modelnet40_ply_hdf5_2048在h5文件中还指定文本ID的文本文件。
    • 点云部分分割(3D Object Part Segmentation)——ShapeNetPart ,下载命令在part_seg/download_data.sh
      浏览器点击下载:
      ShapeNet原始点云数据(约1.08GB)
      ShapeNet-制作好的hdf5文件(约346MB)
      或者直接在终端手动下载数据集:
      cd part_seg
      sh download_data.sh
      
      执行脚本后将下载上面对应的两个数据集,脚本会自动解压到项目目录下。接下来直接运行train.py和test.py进行训练和测试即可。
    • 语义分割(Semantic Segmentation in Scenes)—— Stanford Large-Scale 3D Indoor Spaces Dataset
      对S3DIS数据集进行简单说明:在6个区域的271个房间,使用Matterport相机(结合3个不同间距的结构光传感器),扫描后生成重建3D纹理网格,RGB-D图像等数据,并通过对网格进行采样来制作点云。对点云中的每个点都加上了1个语义标签(例如椅子,桌子,地板,墙等共计13个对象)。
      在这里插入图片描述
      用于训练的数据会按照房间来划分点集,将房间的点云数据划分为1m×1m1m×1m的块,然后再对每个块预测其中每个点的语义标签。每个点由一个9-dim向量表示,分别为:X, Y, Z, R, G, B, X`,Y`,Z` ——标准化后的每个点相对于所在房间的位置坐标( 值为0 - 1)。在训练时,从每个块中随机采样4096个点,使用K折交叉验证(github中是6折,论文中是3折)
    • k-fold交叉验证:6-fold:训练集5个区域,测试集1个区域,3-fold:训练集4个区域,测试集2个区域,防止过拟合的常用手段。

    注意: 这里有一个有意思的问题,对于分割网格进行训练,如果采用这种切分块式样的预处理方式作为输入,会影响到最后的结果,比如一张桌面出现两种不同的错误分割,这一点在RandLA-Net(2019)一文中进行了说明。因此那篇文章说道在做大场景点云分割的时候不能直接使用pointnnet这种方式,因为网络难以有效地学习到一个物体的整体几何结构,也是大场景点云分割的改进点。

    数据集准备

    1.如果没有最后的可视化要求,即只评价模型的分割准确度,不进行更多测试,那可以下载制作好的hdf5格式文件,不会在训练后生成.obj文件:
    在浏览器中点击下载作者准备好的S3DIS-hdf5文件(大约1.6G)
    或者在终端运行:

    	cd sem_seg
    	sh download_data.sh
    

    脚本会自动解压得到一个indoor3d_sem_seg_hdf5_data 文件夹,其中包含ply_data_all_0.h5~ply_data_all_23.h5 共24个.h5结尾的数据文件,每个文件都包含data和 label数据。除最后一个为585行数据以外,这24个文件共有23×1000+585=23585行,每行对应一个切分为1m×1m1m×1m的Block,表示4096个点,每个点对应9个维度。
    all_files.txt 中保存24个数据文件名,room_filelist.txt中数据为23585 行,对应每行的Block所对应的采集area和room。

    2.如果想要进行测试和可视化,需要下载3D室内解析数据集(S3DIS Dataset数据集介绍进行模型的测试和可视化工作。作者实验用的是Stanford3dDataset_v1.2_Aligned_Version数据集,填写信息进行下载下载链接。第一个是谷歌云平台存储的地址,第二个是一个共享文件形式,如果可以用谷歌云的话可能会方便很多。
    在这里插入图片描述
    在.txt文件中的保存的点云数据(XYZ,RGB),解压后文件夹大小为16.8GB
    注意: 在执行 collect_indoor3d_data.py应该会出现类似于下面的错误:

    D:\pointnet\data\Stanford3dDataset_v1.2_Aligned_Version\Area_5/hallway_6/Annotations
    D:\pointnet\data\Stanford3dDataset_v1.2_Aligned_Version\Area_5/hallway_6/Annotations ERROR!!
    

    作者提示Area_5/hallway_6中多了一个额外的字符,不符合编码规范,需要手动删除。经查找具体位置为:Stanford3dDataset_v1.2_Aligned_Version\Area_5\hallway_6\Annotations\ceiling_1.txt中的第180389行数字185后。windows下建议使用EmEditor打开文件,会自动跳转到该行,数字185后面有一个类似空格的字符,实际上不是空格,删掉然后重新打一个空格就可以了。linux下直接使用gedit或vim跳转到该行修改即可。保存后再次使用编辑器尝试打开该文件,不提示出现问题说明已经修改完成。
    对应修改位置如下:
    在这里插入图片描述
    如果要将数据转换为模型所需的hdf5格式,首先需要在Python中安装h5py,如果是Anaconda环境应该已默认安装,通过import h5py测试检查是否安装,没有安装的话可以使用下面命令进行快速安装:

    sudo apt-get install libhdf5-dev # 安装h5py开发库,必要!
    sudo pip install h5py
    

    接下来准备自己的HDF5数据,下载好数据集后,分别运行该sem_seg/下的两个python脚本来生成hdf5数据文件。

    • python collect_indoor3d_data.py用于数据的重组,转换为.npy格式文件,比如Area_1_hallway_1.npy(.npy为Numpy专用的二进制格式)。
    • python gen_indoor3d_h5.py 将.npy文件批量转为HDF5文件。

    训练:

    使用准备好的HDF5数据文件(处理好的或自己转换的数据),即可开始模型训练,模型默认使用Vanilla PointNet进行训练,指定区域1用作测试集,作者给出的是区域6作测试集:

    python train.py --log_dir log1 --test_area 1
    

    得到在log1文件夹下关于训练模型和日志model.ckpt文件。

    测试:

    训练结束后,可以进行测试,需要对于测试集数据进行简单处理:

    • batch_inference.py 对测试集中的房间进行细分。

    作者实验中使用6折交叉训练来训练获得6个模型。比如:对于model1,将区域2-6用作训练集,区域1用作测试集;对于模型2,区域1,3-6被用作训练集,区域2被用作测试集以此类推,请注意,论文使用了不同的3折交叉训练。
    加入我们想使用model1进行测试,并获得一个obj文件用于可视化,那么测试集为区域1,可以运行如下代码,作者README中给出的是model6作为测试,即以区域6位测试集测试工作和可视化:

    python batch_inference.py --model_path log1/model.ckpt --dump_dir log1/dump --output_filelist log1/output_filelist.txt --room_data_filelist meta/area1_data_label.txt --visu
    

    测试执行完毕后。将会在log1/dump下创建一些.OBJ .TXT文件,可以使用CloudCompare,MeshLab等软件来进行区域1—会议室1的预测结果的可视化。
    在这里插入图片描述

    分割效果评价

    最后是评估整体分割的准确性,作者依次评估了6个模型,并用于eval_iou_accuracy.py产生点的分类准确性和IoU,结果最终除以13,得到一个分割的平均交并比mIOU。
    参考论文中作者的结果:
    在这里插入图片描述
    表3为S3DIS数据集上场景分割任务的实验结果 ,表4为该数据集上的3D目标检测任务结果。

    展开全文
  • 用Pandas完成Excel中常见的任务

    万次阅读 2016-01-27 13:14:12
    本文由 伯乐在线 - 艾凌风 翻译,Daetalus...本文的目的,是向您展示如何使用pandas 来执行一些常见的Excel任务。有些例子比较琐碎,但我觉得展示这些简单的东西与那些你可以在其他地方找到的复杂功能同等重要。
    
    
    

    引言

    本文的目的,是向您展示如何使用pandas 来执行一些常见的Excel任务。有些例子比较琐碎,但我觉得展示这些简单的东西与那些你可以在其他地方找到的复杂功能同等重要。作为额外的福利,我将会进行一些模糊字符串匹配,以此来展示一些小花样,以及展示pandas是如何利用完整的Python模块系统去做一些在Python中是简单,但在Excel中却很复杂的事情的。

    有道理吧?让我们开始吧。

    为某行添加求和项

    我要介绍的第一项任务是把某几列相加然后添加一个总和栏。

    首先我们将excel 数据 导入到pandas数据框架中。

    importpandasaspd
    importnumpyasnp
    df=pd.read_excel("excel-comp-data.xlsx")
    df.head()


    我们想要添加一个总和栏来显示Jan、Feb和Mar三个月的销售总额。

    在Excel和pandas中这都是简单直接的。对于Excel,我在J列中添加了公式sum(G2:I2)。在Excel中看上去是这样的:

    下面,我们是这样在pandas中操作的:

    df["total"]=df["Jan"]+df["Feb"]+df["Mar"]
    df.head()

    接下来,让我们对各列计算一些汇总信息以及其他值。如下Excel表所示,我们要做这些工作:

    如你所见,我们在表示月份的列的第17行添加了SUM(G2:G16),来取得每月的总和。

    进行在pandas中进行列级别的分析很简单。下面是一些例子:

    df["Jan"].sum(),df["Jan"].mean(),df["Jan"].min(),df["Jan"].max()
    <span class="crayon-sy" style="font-family: inherit; white-space: pre; border: 0px; margin: 0px; padding: 0px; height: inherit; font-size: inherit !important; font-weight: inherit !important; line-height: inherit !important; color: rgb(51, 51, 51) !important; background-color: rgb(248, 248, 255);">(</span><span class="crayon-cn" style="font-family: inherit; white-space: pre; border: 0px; margin: 0px; padding: 0px; height: inherit; font-size: inherit !important; font-weight: inherit !important; line-height: inherit !important; color: rgb(0, 153, 153) !important; background-color: rgb(248, 248, 255);">1462000</span><span class="crayon-sy" style="font-family: inherit; white-space: pre; border: 0px; margin: 0px; padding: 0px; height: inherit; font-size: inherit !important; font-weight: inherit !important; line-height: inherit !important; color: rgb(51, 51, 51) !important; background-color: rgb(248, 248, 255);">,</span><span class="crayon-h" style="font-family: inherit; white-space: pre; border: 0px; margin: 0px; padding: 0px; height: inherit; font-size: inherit !important; font-weight: inherit !important; line-height: inherit !important; color: rgb(0, 111, 224) !important; background-color: rgb(248, 248, 255);"></span><span class="crayon-cn" style="font-family: inherit; white-space: pre; border: 0px; margin: 0px; padding: 0px; height: inherit; font-size: inherit !important; font-weight: inherit !important; line-height: inherit !important; color: rgb(0, 153, 153) !important; background-color: rgb(248, 248, 255);">97466.666666666672</span><span class="crayon-sy" style="font-family: inherit; white-space: pre; border: 0px; margin: 0px; padding: 0px; height: inherit; font-size: inherit !important; font-weight: inherit !important; line-height: inherit !important; color: rgb(51, 51, 51) !important; background-color: rgb(248, 248, 255);">,</span><span class="crayon-h" style="font-family: inherit; white-space: pre; border: 0px; margin: 0px; padding: 0px; height: inherit; font-size: inherit !important; font-weight: inherit !important; line-height: inherit !important; color: rgb(0, 111, 224) !important; background-color: rgb(248, 248, 255);"></span><span class="crayon-cn" style="font-family: inherit; white-space: pre; border: 0px; margin: 0px; padding: 0px; height: inherit; font-size: inherit !important; font-weight: inherit !important; line-height: inherit !important; color: rgb(0, 153, 153) !important; background-color: rgb(248, 248, 255);">10000</span><span class="crayon-sy" style="font-family: inherit; white-space: pre; border: 0px; margin: 0px; padding: 0px; height: inherit; font-size: inherit !important; font-weight: inherit !important; line-height: inherit !important; color: rgb(51, 51, 51) !important; background-color: rgb(248, 248, 255);">,</span><span class="crayon-h" style="font-family: inherit; white-space: pre; border: 0px; margin: 0px; padding: 0px; height: inherit; font-size: inherit !important; font-weight: inherit !important; line-height: inherit !important; color: rgb(0, 111, 224) !important; background-color: rgb(248, 248, 255);"></span><span class="crayon-cn" style="font-family: inherit; white-space: pre; border: 0px; margin: 0px; padding: 0px; height: inherit; font-size: inherit !important; font-weight: inherit !important; line-height: inherit !important; color: rgb(0, 153, 153) !important; background-color: rgb(248, 248, 255);">162000</span><span class="crayon-sy" style="font-family: inherit; white-space: pre; border: 0px; margin: 0px; padding: 0px; height: inherit; font-size: inherit !important; font-weight: inherit !important; line-height: inherit !important; color: rgb(51, 51, 51) !important; background-color: rgb(248, 248, 255);">)</span>

    现在我们要把每月的总和相加得到它们的和。这里pandas和Excel有点不同。在Excel的单元格里把每个月的总和相加很简单。由于pandas需要维护整个DataFrame的完整性,所以需要一些额外的步骤。

    首先,建立所有列的总和栏

    sum_row=df[["Jan","Feb","Mar","total"]].sum()
    sum_row
    Jan      1462000
    Feb      1507000
    Mar      717000
    total    3686000
    dtype:int64
    
    <span style="font-family: 'Microsoft YaHei', 宋体, 'Myriad Pro', Lato, 'Helvetica Neue', Helvetica, Arial, sans-serif; background-color: rgb(255, 255, 255);">这很符合直觉,不过如果你希望将总和值显示为表格中的单独一行,你还需要做一些微调。</span>

    我们需要把数据进行变换,把这一系列数字转换为DataFrame,这样才能更加容易的把它合并进已经存在的数据中。T 函数可以让我们把按行排列的数据变换为按列排列。

    df_sum=pd.DataFrame(data=sum_row).T
    df_sum

    在计算总和之前我们要做的最后一件事情是添加丢失的列。我们使用reindex来帮助我们完成。技巧是添加全部的列然后让pandas去添加所有缺失的数据。

    df_sum=df_sum.reindex(columns=df.columns)
    df_sum

    现在我们已经有了一个格式良好的DataFrame,我们可以使用append来把它加入到已有的内容中。

    df_final=df.append(df_sum,ignore_index=True)
    df_final.tail()

    额外的数据变换

    另外一个例子,让我们尝试给数据集添加状态的缩写。

    对于Excel,最简单的方式是添加一个新的列,对州名使用vlookup函数并填充缩写栏。

    我进行了这样的操作,下面是其结果的截图:

    你可以注意到,在进行了vlookup后,有一些数值并没有被正确的取得。这是因为我们拼错了一些州的名字。在Excel中处理这一问题是一个巨大的挑战(对于大型数据集而言)

    幸运的是,使用pandas我们可以利用强大的python生态系统。考虑如何解决这类麻烦的数据问题,我考虑进行一些模糊文本匹配来决定正确的值。

    幸运的是其他人已经做了很多这方面的工作。fuzzy wuzzy库包含一些非常有用的函数来解决这类问题。首先要确保你安装了他。

    我们需要的另外一段代码是州名与其缩写的映射表。而不是亲自去输入它们,谷歌一下你就能找到这段代码code

    首先导入合适的fuzzywuzzy函数并且定义我们的州名映射表。

    from fuzzywuzzy import fuzz
    from fuzzywuzzy import process
    state_to_code={"VERMONT":"VT","GEORGIA":"GA","IOWA":"IA","Armed Forces Pacific":"AP","GUAM":"GU",
                    "KANSAS":"KS","FLORIDA":"FL","AMERICAN SAMOA":"AS","NORTH CAROLINA":"NC","HAWAII":"HI",
                    "NEW YORK":"NY","CALIFORNIA":"CA","ALABAMA":"AL","IDAHO":"ID","FEDERATED STATES OF MICRONESIA":"FM",
                    "Armed Forces Americas":"AA","DELAWARE":"DE","ALASKA":"AK","ILLINOIS":"IL",
                    "Armed Forces Africa":"AE","SOUTH DAKOTA":"SD","CONNECTICUT":"CT","MONTANA":"MT","MASSACHUSETTS":"MA",
                    "PUERTO RICO":"PR","Armed Forces Canada":"AE","NEW HAMPSHIRE":"NH","MARYLAND":"MD","NEW MEXICO":"NM",
                    "MISSISSIPPI":"MS","TENNESSEE":"TN","PALAU":"PW","COLORADO":"CO","Armed Forces Middle East":"AE",
                    "NEW JERSEY":"NJ","UTAH":"UT","MICHIGAN":"MI","WEST VIRGINIA":"WV","WASHINGTON":"WA",
                    "MINNESOTA":"MN","OREGON":"OR","VIRGINIA":"VA","VIRGIN ISLANDS":"VI","MARSHALL ISLANDS":"MH",
                    "WYOMING":"WY","OHIO":"OH","SOUTH CAROLINA":"SC","INDIANA":"IN","NEVADA":"NV","LOUISIANA":"LA",
                    "NORTHERN MARIANA ISLANDS":"MP","NEBRASKA":"NE","ARIZONA":"AZ","WISCONSIN":"WI","NORTH DAKOTA":"ND",
                    "Armed Forces Europe":"AE","PENNSYLVANIA":"PA","OKLAHOMA":"OK","KENTUCKY":"KY","RHODE ISLAND":"RI",
                    "DISTRICT OF COLUMBIA":"DC","ARKANSAS":"AR","MISSOURI":"MO","TEXAS":"TX","MAINE":"ME"}
    

    这里有些介绍模糊文本匹配函数如何工作的例子。

    process.extractOne("Minnesotta",choices=state_to_code.keys())
    ('MINNESOTA', 95)
    process.extractOne("AlaBAMMazzz",choices=state_to_code.keys(),score_cutoff=80)
    

    现在我知道它是如何工作的了,我们创建自己的函数来接受州名这一列的数据然后把他转换为一个有效的缩写。这里我们使用score_cutoff的值为80。你可以做一些调整,看看哪个值对你的数据来说比较好。你会注意到,返回值要么是一个有效的缩写,要么是一个np.nan 所以域中会有一些有效的值。

    def convert_state(row):
        abbrev=process.extractOne(row["state"],choices=state_to_code.keys(),score_cutoff=80)
        if abbrev:
            return state_to_code[abbrev[0]]
        return np.nan

    把这列添加到我们想要填充的单元格,然后用NaN填充它

    df_final.insert(6,"abbrev",np.nan)
    df_final.head()

    我们使用apply 来把缩写添加到合适的列中。

    df_final['abbrev']=df_final.apply(convert_state,axis=1)
    df_final.tail()

    我觉的这很酷。我们已经开发出了一个非常简单的流程来智能的清理数据。显然,当你只有15行左右数据的时候这没什么了不起的。但是如果是15000行呢?在Excel中你就必须进行一些人工清理了。

    分类汇总

    在本文的最后一节中,让我们按州来做一些分类汇总(subtotal)。

    在Excel中,我们会用subtotal 工具来完成。

    输出如下:


    在pandas中创建分类汇总,是使用groupby 来完成的。

    df_sub=df_final[["abbrev","Jan","Feb","Mar","total"]].groupby('abbrev').sum()
    df_sub

    然后,我们想要通过对data frame中所有的值使用 applymap 来把数据单位格式化为货币。

    def money(x):
        return"${:,.0f}".format(x)
     
    formatted_df=df_sub.applymap(money)
    formatted_df

    格式化看上去进行的很顺利,现在我们可以像之前那样获取总和了。

    sum_row=df_sub[["Jan","Feb","Mar","total"]].sum()
    sum_row
    
    Jan      1462000
    Feb      1507000
    Mar      717000
    total    3686000
    dtype:int64
    把值变换为列然后进行格式化。

    df_sub_sum=pd.DataFrame(data=sum_row).T
    df_sub_sum=df_sub_sum.applymap(money)
    df_sub_sum

    最后,把总和添加到DataFrame中。

    final_table=formatted_df.append(df_sub_sum)
    final_table

    你可以注意到总和行的索引号是‘0’。我们想要使用rename 来重命名它。

    final_table=final_table.rename(index={0:"Total"})
    final_table

    结论

    到目前为止,大部分人都已经知道使用pandas可以对数据做很多复杂的操作——就如同Excel一样。因为我一直在学习pandas,但我发现我还是会尝试记忆我是如何在Excel中完成这些操作的而不是在pandas中。我意识到把它俩作对比似乎不是很公平——它们是完全不同的工具。但是,我希望能接触到哪些了解Excel并且想要学习一些可以满足分析他们数据需求的其他替代工具的那些人。我希望这些例子可以帮助到其他人,让他们有信心认为他们可以使用pandas来替换他们零碎复杂的Excel,进行数据操作。

    我发现这个练习会帮助我加强记忆。我希望这对你来说同样有帮助。如果你有一些其他的Excel任务想知道如何用pandas来完成它,请通过评论来告诉我,我会尽力帮助你。

    介绍

    读者对于本系列第一篇文章的回应,让我感到很兴奋。感谢大家正面的反馈。我想把本系列继续下去,重点介绍其他的一些你经常使用Excel完成的任务,并且展示给你如何在pandas中使用相同的功能。

    在第一篇文章中,我着重介绍了Excel中常见的数学计算工作,以及在pandas如何完成这些工作。在本文中,我们将着重介绍一些常见的选择和筛选任务,并且介绍如何在pandas中完成同样的事情。

    设置

    如果您想要继续下去,您可以下载本excel文件

    导入pandas和numpy模块。

    导入我们样本公司销售年销售额的Excel文件。

    import pandas as pd
    import numpy as np
    df=pd.read_excel('sample-salesv3.xlsx')
    

    快速浏览一下数据类型,以确保所以事情都能如预期一样运行。

    df.dtypes
    account number             int64
    name                      object
    sku                       object
    quantity                   int64
    unit price               float64
    ext price                float64
    date              datetime64[ns]
    dtype: object
    
    你会注意到,我们的date列,显示的是一个通用对象。我们准备把它转换为日期对象,来简化将来会用到的一些选择操作。

    df['date']=pd.to_datetime(df['date'])
    

      account number name sku quantity unit price ext price date
    0 740150 Barton LLC B1-20000 39 86.69 3380.91 2014-01-01 07:21:51
    1 714466 Trantow-Barrows S2-77896 -1 63.16 -63.16 2014-01-01 10:00:47
    2 218895 Kulas Inc B1-69924 23 90.70 2086.10 2014-01-01 13:24:58
    3 307599 Kassulke, Ondricka and Metz S1-65481 41 21.05 863.05 2014-01-01 15:05:22
    4 412290 Jerde-Hilpert S2-34077 6 83.21 499.26 2014-01-01 23:26:55

    现在,data变成了一个datetime类型的对象,这对于将来的操作是很有用的。

    筛选数据

    我认为在Excel中最方便的功能是筛选。我想几乎每一次有人拿到一个任意大小的Excel文件,当他们想要筛选数据的时候,都会使用这个功能。

    如图,对本数据集使用该功能:

    excel-filter

    同Excel中的筛选功能一样,你可以使用pandas来筛选和选择某个特定数据的子集。

    比方说,如果我们仅仅想查看一个特定的账号,我们可以简单是在Excel中完成,或是使用pandas完成操作。

    下面是Excel的筛选解决方案:

    excel-filter2

    在pandas中执行相关操作比Excel中更加直观。注意,我将会使用head 函数来显示前面几个结果。这仅仅是为了让本文保持简短。

    df[df["account number"]==307599].head()
    你还可以以数值为基准来进行筛选。我就不再举任何Excel的例子了。我相信你能明白。
    df[df["quantity"]>22].head()

      account number name sku quantity unit price ext price date
    0 740150 Barton LLC B1-20000 39 86.69 3380.91 2014-01-01 07:21:51
    2 218895 Kulas Inc B1-69924 23 90.70 2086.10 2014-01-01 13:24:58
    3 307599 Kassulke, Ondricka and Metz S1-65481 41 21.05 863.05 2014-01-01 15:05:22
    14 737550 Fritsch, Russel and Anderson B1-53102 23 71.56 1645.88 2014-01-04 08:57:48
    15 239344 Stokes LLC S1-06532 34 71.51 2431.34 2014-01-04 11:34:58

    如果我们想要更多复杂的筛选,我们可以可以使用map 来以多重标准进行筛选。在这个例子中,从B1中查找以“sku”中起始的项目。

    df[df["sku"].map(lambdax:x.startswith('B1'))].head()

      account number name sku quantity unit price ext price date
    0 740150 Barton LLC B1-20000 39 86.69 3380.91 2014-01-01 07:21:51
    2 218895 Kulas Inc B1-69924 23 90.70 2086.10 2014-01-01 13:24:58
    6 218895 Kulas Inc B1-65551 2 31.10 62.20 2014-01-02 10:57:23
    14 737550 Fritsch, Russel and Anderson B1-53102 23 71.56 1645.88 2014-01-04 08:57:48
    17 239344 Stokes LLC B1-50809 14 16.23 227.22 2014-01-04 22:14:32

    把两个或更多的语句连接起来很简单,用&就可以。

    df[df["sku"].map(lambdax:x.startswith('B1'))&(df["quantity"]>22)].head()
    

      account number name sku quantity unit price ext price date
    0 740150 Barton LLC B1-20000 39 86.69 3380.91 2014-01-01 07:21:51
    2 218895 Kulas Inc B1-69924 23 90.70 2086.10 2014-01-01 13:24:58
    14 737550 Fritsch, Russel and Anderson B1-53102 23 71.56 1645.88 2014-01-04 08:57:48
    26 737550 Fritsch, Russel and Anderson B1-53636 42 42.06 1766.52 2014-01-08 00:02:11
    31 714466 Trantow-Barrows B1-33087 32 19.56 625.92 2014-01-09 10:16:32

    pandas支持的另外一个很有用的函数是isin。它使得我们可以定义一个列表,里面包含我们所希望查找的值

    在这个例子中,我们查找包含两个特定account number值的全部项目。

    df[df["accountnumber"].isin([714466,218895])].head()

      account number name sku quantity unit price ext price date
    1 714466 Trantow-Barrows S2-77896 -1 63.16 -63.16 2014-01-01 10:00:47
    2 218895 Kulas Inc B1-69924 23 90.70 2086.10 2014-01-01 13:24:58
    5 714466 Trantow-Barrows S2-77896 17 87.63 1489.71 2014-01-02 10:07:15
    6 218895 Kulas Inc B1-65551 2 31.10 62.20 2014-01-02 10:57:23
    8 714466 Trantow-Barrows S1-50961 22 84.09 1849.98 2014-01-03 11:29:02

    pandas支持的另外一个函数叫做query,它使得我们可以有效的再数据集中选择数据。使用它需要安装numexpr ,所以请确保你在进行下面步骤前已经进行了安装。

    如果你想要通过名字来得到一个消费者列表,你可以使用query来完成,和前面展示的python语法类似。

    df.query('name == ["Kulas Inc","Barton LLC"]').head()

      account number name sku quantity unit price ext price date
    0 740150 Barton LLC B1-20000 39 86.69 3380.91 2014-01-01 07:21:51
    2 218895 Kulas Inc B1-69924 23 90.70 2086.10 2014-01-01 13:24:58
    6 218895 Kulas Inc B1-65551 2 31.10 62.20 2014-01-02 10:57:23
    33 218895 Kulas Inc S1-06532 3 22.36 67.08 2014-01-09 23:58:27
    36 218895 Kulas Inc S2-34077 16 73.04 1168.64 2014-01-10 12:07:30

    这里只是做个简单的示例,query函数能做到的还不止这些。我在此展示这些函数的用法,以便当你有需要的时候,会意识到可以用它。

    处理日期

    使用pandas,你可以对日期进行更加复杂的筛选。在我们处理日期前,我建议你把日期栏进行一个排序,以便返回的结果如你所愿。

    df=df.sort('date')
    df.head()

      account number name sku quantity unit price ext price date
    0 740150 Barton LLC B1-20000 39 86.69 3380.91 2014-01-01 07:21:51
    1 714466 Trantow-Barrows S2-77896 -1 63.16 -63.16 2014-01-01 10:00:47
    2 218895 Kulas Inc B1-69924 23 90.70 2086.10 2014-01-01 13:24:58
    3 307599 Kassulke, Ondricka and Metz S1-65481 41 21.05 863.05 2014-01-01 15:05:22
    4 412290 Jerde-Hilpert S2-34077 6 83.21 499.26 2014-01-01 23:26:55

    在操作日期前,为您展示python的筛选语法。

    df[df['date']>='20140905'].head()

      account number name sku quantity unit price ext price date
    1042 163416 Purdy-Kunde B1-38851 41 98.69 4046.29 2014-09-05 01:52:32
    1043 714466 Trantow-Barrows S1-30248 1 37.16 37.16 2014-09-05 06:17:19
    1044 729833 Koepp Ltd S1-65481 48 16.04 769.92 2014-09-05 08:54:41
    1045 729833 Koepp Ltd S2-11481 6 26.50 159.00 2014-09-05 16:33:15
    1046 737550 Fritsch, Russel and Anderson B1-33364 4 76.44 305.76 2014-09-06 08:59:08
    pandas的一个特别棒的特性是它能够理解日期,所以它允许我们进行部分筛选。如果我只想要查看最近几个月的日期数据,我可以这样做。
    df[df['date']>='2014-03'].head()

      account number name sku quantity unit price ext price date
    242 163416 Purdy-Kunde S1-30248 19 65.03 1235.57 2014-03-01 16:07:40
    243 527099 Sanford and Sons S2-82423 3 76.21 228.63 2014-03-01 17:18:01
    244 527099 Sanford and Sons B1-50809 8 70.78 566.24 2014-03-01 18:53:09
    245 737550 Fritsch, Russel and Anderson B1-50809 20 50.11 1002.20 2014-03-01 23:47:17
    246 688981 Keeling LLC B1-86481 -1 97.16 -97.16 2014-03-02 01:46:44

    当然,你可以把筛选标准链接起来。

    df[(df['date']>='20140701')&(df['date']<='20140715')].head()

      account number name sku quantity unit price ext price date
    778 737550 Fritsch, Russel and Anderson S1-65481 35 70.51 2467.85 2014-07-01 00:21:58
    779 218895 Kulas Inc S1-30248 9 16.56 149.04 2014-07-01 00:52:38
    780 163416 Purdy-Kunde S2-82423 44 68.27 3003.88 2014-07-01 08:15:52
    781 672390 Kuhn-Gusikowski B1-04202 48 99.39 4770.72 2014-07-01 11:12:13
    782 642753 Pollich LLC S2-23246 1 51.29 51.29 2014-07-02 04:02:39

    由于pandas可以理解日期列,所以可以将日期值设为不同的格式,都会得到正确的结果。

      account number name sku quantity unit price ext price date
    1168 307599 Kassulke, Ondricka and Metz S2-23246 6 88.90 533.40 2014-10-08 06:19:50
    1169 424914 White-Trantow S2-10342 25 58.54 1463.50 2014-10-08 07:31:40
    1170 163416 Purdy-Kunde S1-27722 22 34.41 757.02 2014-10-08 09:01:18
    1171 163416 Purdy-Kunde B1-33087 7 79.29 555.03 2014-10-08 15:39:13
    1172 672390 Kuhn-Gusikowski B1-38851 30 94.64 2839.20 2014-10-09 00:22:33
    df[df['date']>='10-10-2014'].head()

      account number name sku quantity unit price ext price date
    1174 257198 Cronin, Oberbrunner and Spencer S2-34077 13 12.24 159.12 2014-10-10 02:59:06
    1175 740150 Barton LLC S1-65481 28 53.00 1484.00 2014-10-10 15:08:53
    1176 146832 Kiehn-Spinka S1-27722 15 64.39 965.85 2014-10-10 18:24:01
    1177 257198 Cronin, Oberbrunner and Spencer S2-16558 3 35.34 106.02 2014-10-11 01:48:13
    1178 737550 Fritsch, Russel and Anderson B1-53636 10 56.95 569.50 2014-10-11 10:25:53

    当操作时间序列数据时,如果你把数据进行转化,以日期作为索引,我们可以做一些变相的筛选。

    使用set_index 来设置新的索引。

    df2=df.set_index(['date'])
    df2.head()

      account number name sku quantity unit price ext price
    date            
    2014-01-01 07:21:51 740150 Barton LLC B1-20000 39 86.69 3380.91
    2014-01-01 10:00:47 714466 Trantow-Barrows S2-77896 -1 63.16 -63.16
    2014-01-01 13:24:58 218895 Kulas Inc B1-69924 23 90.70 2086.10
    2014-01-01 15:05:22 307599 Kassulke, Ondricka and Metz S1-65481 41 21.05 863.05
    2014-01-01 23:26:55 412290 Jerde-Hilpert S2-34077 6 83.21 499.26

    你可以通过切分数据来获取一段区间。

    df2["20140101":"20140201"].head()

      account number name sku quantity unit price ext price
    date            
    2014-01-01 07:21:51 740150 Barton LLC B1-20000 39 86.69 3380.91
    2014-01-01 10:00:47 714466 Trantow-Barrows S2-77896 -1 63.16 -63.16
    2014-01-01 13:24:58 218895 Kulas Inc B1-69924 23 90.70 2086.10
    2014-01-01 15:05:22 307599 Kassulke, Ondricka and Metz S1-65481 41 21.05 863.05
    2014-01-01 23:26:55 412290 Jerde-Hilpert S2-34077 6 83.21 499.26

    再一次的,我们可以使用不同的日期表示方法来避免模棱两可的日期命名惯例。

    df2["2014-Jan-1":"2014-Feb-1"].head()

      account number name sku quantity unit price ext price
    date            
    2014-01-01 07:21:51 740150 Barton LLC B1-20000 39 86.69 3380.91
    2014-01-01 10:00:47 714466 Trantow-Barrows S2-77896 -1 63.16 -63.16
    2014-01-01 13:24:58 218895 Kulas Inc B1-69924 23 90.70 2086.10
    2014-01-01 15:05:22 307599 Kassulke, Ondricka and Metz S1-65481 41 21.05 863.05
    2014-01-01 23:26:55 412290 Jerde-Hilpert S2-34077 6 83.21 499.26
    df2["2014-Jan-1":"2014-Feb-1"].tail()

      account number name sku quantity unit price ext price
    date            
    2014-01-31 22:51:18 383080 Will LLC B1-05914 43 80.17 3447.31
    2014-02-01 09:04:59 383080 Will LLC B1-20000 7 33.69 235.83
    2014-02-01 11:51:46 412290 Jerde-Hilpert S1-27722 11 21.12 232.32
    2014-02-01 17:24:32 412290 Jerde-Hilpert B1-86481 3 35.99 107.97
    2014-02-01 19:56:48 412290 Jerde-Hilpert B1-20000 23 78.90 1814.70
    df2["2014"].head()
      account number name sku quantity unit price ext price
    date            
    2014-01-01 07:21:51 740150 Barton LLC B1-20000 39 86.69 3380.91
    2014-01-01 10:00:47 714466 Trantow-Barrows S2-77896 -1 63.16 -63.16
    2014-01-01 13:24:58 218895 Kulas Inc B1-69924 23 90.70 2086.10
    2014-01-01 15:05:22 307599 Kassulke, Ondricka and Metz S1-65481 41 21.05 863.05
    2014-01-01 23:26:55 412290 Jerde-Hilpert S2-34077 6 83.21 499.26
    df2["2014-Dec"].head()
      account number name sku quantity unit price ext price
    date            
    2014-12-01 20:15:34 714466 Trantow-Barrows S1-82801 3 77.97 233.91
    2014-12-02 20:00:04 146832 Kiehn-Spinka S2-23246 37 57.81 2138.97
    2014-12-03 04:43:53 218895 Kulas Inc S2-77896 30 77.44 2323.20
    2014-12-03 06:05:43 141962 Herman LLC B1-53102 20 26.12 522.40
    2014-12-03 14:17:34 642753 Pollich LLC B1-53636 19 71.21 1352.99

    正如你所见到的那样,在进行基于日期的排序或者筛选时,可以有很多选择。

    额外的字符串方法

    Pandas同样已经支持了矢量字符串方法。

    如果我们想识别出sku栏中包含某一特定值的全部值。我们可以使用str.contains。在这个例子中,我们已知sku总是以一种相同的方式表示,所以B1仅会出现在sku的前面。你需要理解你的数据来保证你能够得到你想要的结果。

    df[df['sku'].str.contains('B1')].head()

      account number name sku quantity unit price ext price date
    0 740150 Barton LLC B1-20000 39 86.69 3380.91 2014-01-01 07:21:51
    2 218895 Kulas Inc B1-69924 23 90.70 2086.10 2014-01-01 13:24:58
    6 218895 Kulas Inc B1-65551 2 31.10 62.20 2014-01-02 10:57:23
    14 737550 Fritsch, Russel and Anderson B1-53102 23 71.56 1645.88 2014-01-04 08:57:48
    17 239344 Stokes LLC B1-50809 14 16.23 227.22 2014-01-04 22:14:32

    我们可以把查询连接起来并且使用排序来控制数据的顺序。

    df[(df['sku'].str.contains('B1-531')) & (df['quantity']>40)].sort(columns=['quantity','name'],ascending=[0,1])

      account number name sku quantity unit price ext price date
    684 642753 Pollich LLC B1-53102 46 26.07 1199.22 2014-06-08 19:33:33
    792 688981 Keeling LLC B1-53102 45 41.19 1853.55 2014-07-04 21:42:22
    176 383080 Will LLC B1-53102 45 89.22 4014.90 2014-02-11 04:14:09
    1213 604255 Halvorson, Crona and Champlin B1-53102 41 55.05 2257.05 2014-10-18 19:27:01
    1215 307599 Kassulke, Ondricka and Metz B1-53102 41 93.70 3841.70 2014-10-18 23:25:10
    1128 714466 Trantow-Barrows B1-53102 41 55.68 2282.88 2014-09-27 10:42:48
    1001 424914 White-Trantow B1-53102 41 81.25 3331.25 2014-08-26 11:44:30

    彩蛋任务

    在Excel中,我发现我自己经常会尝试从一个冗长的列表中,得到一个包含不重复项的小列表。在Excel中这件事情需要分几步来完成,但是在Pandas中却非常简单。有一种方式是使用Excel中提供的高级筛选工具来完成。

    excel-filter3

    在pandas中,我们对某列使用这个unique函数来获取这个列表。

    df["name"].unique()

    如果我们想要包含账户号,我们可以使用 drop_duplicates

    df.drop_duplicates(subset=["account number","name"]).head()

      account number name sku quantity unit price ext price date
    0 740150 Barton LLC B1-20000 39 86.69 3380.91 2014-01-01 07:21:51
    1 714466 Trantow-Barrows S2-77896 -1 63.16 -63.16 2014-01-01 10:00:47
    2 218895 Kulas Inc B1-69924 23 90.70 2086.10 2014-01-01 13:24:58
    3 307599 Kassulke, Ondricka and Metz S1-65481 41 21.05 863.05 2014-01-01 15:05:22
    4 412290 Jerde-Hilpert S2-34077 6 83.21 499.26 2014-01-01 23:26:55

    很显然我们放入了的数据超过了我们的需要,得到了一些无用的信息,因此,使用ix 来仅仅选择第一第二列。

    df.drop_duplicates(subset=["account number","name"]).ix[:,[0,1]]

      account number name
    0 740150 Barton LLC
    1 714466 Trantow-Barrows
    2 218895 Kulas Inc
    3 307599 Kassulke, Ondricka and Metz
    4 412290 Jerde-Hilpert
    7 729833 Koepp Ltd
    9 737550 Fritsch, Russel and Anderson
    10 146832 Kiehn-Spinka
    11 688981 Keeling LLC
    12 786968 Frami, Hills and Schmidt
    15 239344 Stokes LLC
    16 672390 Kuhn-Gusikowski
    18 141962 Herman LLC
    20 424914 White-Trantow
    21 527099 Sanford and Sons
    30 642753 Pollich LLC
    37 383080 Will LLC
    51 257198 Cronin, Oberbrunner and Spencer
    67 604255 Halvorson, Crona and Champlin
    106 163416 Purdy-Kunde

    我认为这个记住这个单独的命令比记忆Excel的各步操作更容易。

    如果你想要查看我的笔记 请随意下载。

    结论

    在我发表了我的第一篇文章之后,Dave Proffer在Twitter上转发了我的文章并评论到“打破你#excel沉迷的一些好技巧”。我觉得这句话非常准确,它描述了在我们的生活中使用Excel是有多么的频繁。大多数的人只管伸手去用却从来没有意识到它的局限性。我希望这个系列的文章可以帮助大家认识到我们还有其他的替代工具,Python+Pandas是一个极其强大的组合。


    展开全文
  • 在学习了大约2周的机器学习和深度学习的基础知识,并跑了多个模型之后,老师给我布置了一项真正的任务,利用已经收集到的图片信息,构建并训练模型,一期目标使得精度达到84%,二期目标使得精度达到90%。...

    多类别动物图片分类任务(上)

    在学习了大约2周的机器学习和深度学习的基础知识,并跑了十多个模型之后,老师给我布置了一项真正的实际任务:利用已经收集到的图片信息,构建并训练模型,一期目标使得精度达到84%,二期目标使得精度达到90%。
    一开始并没有认识到,真正的实际数据会和demo中最后的结果差距如此之大,使得自己消沉了一段时间,不过经过将近15天的努力,总算是完成了任务,亦有所收获。
    故,在此把我这段时间踩过的坑都一一标注出来,希望可以帮助到那些初次接触卷积神经网络的新人(虽然我也是啦)

    1. 观察数据
      拿到数据后,要做的第一件事绝不是直接建模(血的教训 ),而是观察数据的分布情况,在真正的实际任务中,数据往往不是你在猫狗大战这样的demo中那样,分布的那么均衡的。
      比如我这次的任务数据,总计30064张彩色图片,分为168类,而最少的类图片只有103张,最多的有1684张,差距非常大。
      解决方法:
      过采样是一个很好的处理手段。
    2. 建立一个简单的卷积神经网络
      无论你是否懂得如何利用已经与训练好的模型进行建模,自己写一个简单的卷积神经网络来测试下数据都是可行的。一般,我们采用2+2的形式来实现。
      实现代码:
    # 建立模型
    model = Sequential()
    # 这里使用卷积神经网络,传入100*100像素的彩色图片,传出时为94*94*32
    model.add(Conv2D(32, (7, 7), strides = (1, 1), name = 'conv0', input_shape = (100, 100, 3)))
    # 使用批标准化
    model.add(BatchNormalization(axis = 3, name = 'bn0'))
    # 激活函数为ReLU(线性整流函数)
    model.add(Activation('relu'))
    # 对于空间数据的最大池化
    model.add(MaxPooling2D((2, 2), name='max_pool'))
    model.add(Conv2D(64, (3, 3), strides = (1, 1), name="conv1"))
    model.add(Activation('relu'))
    # 对于空间数据的平均池化
    model.add(AveragePooling2D((3, 3), name='avg_pool'))
    
    model.add(Flatten())
    model.add(Dense(500, activation="relu", name='rl'))
    model.add(Dropout(0.5))
    model.add(Dense(y.shape[1], activation='softmax', name='sm'))
    # 编译模型
    model.compile(loss='categorical_crossentropy', optimizer="adam", metrics=['accuracy'])
    

    当然,在此之前我们要先处理图片数据和标签
    实现代码:

    train_df = pd.read_csv("input/train.csv")
    
    
    # 这个函数用来预处理图片数据,把图片转化为100*100像素
    # 的彩色图片,其中data是数据集,m是数据集中图片的数目,dataset是图片存放的目录
    def prepareImages(data, m, dataset):
        print("Preparing images")
        X_train = np.zeros((m, 100, 100, 3))
        count = 0     # 这个count用来记录图片处理的数目,函数中实现了每处理500张就通报一声,其实没啥用
    
        for fig in data['Image']:
            # fig读到的是Image这一特征下的具体数据,也就是图片名(一个接一个的)
            img = image.load_img("input/" + dataset + "/" + fig, target_size=(100, 100, 3))
            x = image.img_to_array(img)
            # preprocess_input()函数完成数据预处理的工作
            x = preprocess_input(x)
            # 然后把处理过后的图片信息记录到x_train中去
            X_train[count] = x
            if count % 500 == 0:
                print("Processing image: ", count + 1, ", ", fig)
            count += 1
    
        return X_train
    
    
    # 这个函数用来处理标签,返回两个输出,y和label_encoder,
    # 前者是one-hot编码形式,如:[1;2;3]会编码成[1 0 0; 0 1 0; 0 0 1]。
    # 后者是分组的组号,如:[1;2;2;4;2]会编码成[1;2;2;3;2]。
    def prepare_labels(y):
        values = np.array(y)
        # 为标签分组,并用label_encoder记录,为以后测试集分好组之后重新从组号转变成对应的描述做准备
        label_encoder = LabelEncoder()
        integer_encoded = label_encoder.fit_transform(values)
        # print(integer_encoded)
    
        # 将分好组的标签转化为one-hot编码,并用y记录
        onehot_encoder = OneHotEncoder(sparse=False)
        integer_encoded = integer_encoded.reshape(len(integer_encoded), 1)
        onehot_encoded = onehot_encoder.fit_transform(integer_encoded)
        # print(onehot_encoded)
    
        y = onehot_encoded
    
        return y, label_encoder
    
    # 处理训练数据,并归一化
    X = prepareImages(train_df, train_df.shape[0], "train")
    X /= 255
    # 处理标签
    y, label_encoder = prepare_labels(train_df['Id'])
    

    值得注意的是,此时的图片数据分为两个文件夹,train和valication,其信息被写在两个.csv文件中。
    而跑起来之后,我们会发现,最终的验证准确率非常低,仅仅有23.31%

    1. 确定部分参数
      1).在之前观察原始数据的过程中,我发现问题不仅仅是图片的分布不均匀,不同的图片的分辨率也截然不同,最小的图片大约有250 * 400,最大的甚至达到4000 * 4250,这就使得将图片以怎样的大小传入网络显得尤为重要。
      经过多次试验,最终在平衡了训练时间和验证集准确率之后,选定图片统一裁定到356*356。
      2).而原始图片决定以7:3的比例,随机分配给train和valication。
      3).batch_size的选择是一门艺术:
      batch_size 太小,算法难以收敛。
      随着 batch_size 增大,处理相同数据量的速度越快。
      随着 batch_size 增大,达到相同精度所需要的 epoch 数量越来越多。
      由于上述两种因素的矛盾,batch_size 增大到某个时候,达到时间上的最优。
      由于最终收敛精度会陷入不同的局部极值,因此batch_size 增大到某些时候,达到最终收敛精度上的最优。
      经过多次试验,最终选择batch_size为128。
      此处,一般选择2^n的大小,据说是可以从某种程度上提高显卡对数据的处理速度。

    一些确定的参数

    class_num = 168
    num_train_sample = 20967
    num_validation_sample = 9097
    img_width = 356
    img_height = 356
    epochs = 40
    batch_size = 128
    

    至此,第一阶段结束。

    1. 开始使用VGG16进行预训练模型
      预训练网络(pretrained network)是一个保存好的网络,之前已在大型数据集(通常是大规模图像分类任务)上训练好。如果这个原始数据集足够大且足够通用,那么预训练网络学到的特征的空间层次结构可以有效地作为视觉世界的通用模型,因此这些特征可用于各种不同的计算机视觉问题,即使这些新问题涉及的类别和原始任务完全不同。
      本次任务,我首先选用了VGG16来进行预训练。
      实现代码
    # 实例化一个VGG16卷积基
    base_model = VGG16(weights='imagenet',
                       include_top=False,
                       input_shape=(img_width, img_height, 3))
    
    # 冻结卷积基
    base_model.trainable = False
    # 自定义顶层网络
    top_model = Sequential()
    top_model.add(layers.Flatten(input_shape=base_model.output_shape[1:]))
    top_model.add(layers.Dense(4096, activation='relu'))
    top_model.add(layers.Dropout(0.5))
    top_model.add(layers.Dense(1024, activation='relu'))
    top_model.add(layers.Dropout(0.5))
    top_model.add(layers.Dense(class_num, activation='softmax'))
    
    # 实例化这个模型
    model = Model(inputs=base_model.input,
                  outputs=top_model(base_model.output))
    # 编译模型
    model.compile(loss='categorical_crossentropy',
                  optimizer=optimizers.RMSprop(lr=2e-5),
                  metrics=['acc'])
    

    训练模型后,验证集的准确率只有54.52%

    1. 一些简单的调整
      很明显,如此低的准确率完全无法满足任务的要求,我们需要对模型进行一定的调整,首先,要对数据进行预处理,此处为归一化。
      代码实现
    # 可以对训练集进行数据增强处理
    train_datagen = ImageDataGenerator(rescale=1./255)
    
    
    # 测试集不许动,归一化完了之后不许动
    validation_datagen = ImageDataGenerator(rescale=1./255)
    

    训练模型后,验证集的准确率上涨到60.17%。
    进一步,我们可以调整学习率lr,经过多次调试,最终我们将初试学习率调整为lr = 1e-5。
    训练模型后,验证集的准确率上涨到63.66%。
    可以的话,我们可以在回调函数中加入对学习率的调整。
    代码实现

    # 回调函数用来监控val_loss,一旦超过5次迭代没有下降,降低学习率
    callback_list = [
        keras.callbacks.ReduceLROnPlateau(
            monitor='val_loss',
            factor=0.1,
            patience=5,
            verbose=1,
        )
    ]
    

    训练模型后,验证集的准确率上涨到66.34%。
    至此,我们将自己能做的一些简单的调整执行完毕,很显然,不仅最终的结果依旧不能满足任务的要求,而且由于VGG16网络的特点,需要训练大量的参数,不仅让整个网路臃肿,而且训练效率很低。
    故而,我选择换一种预训练网络,这里,就让我们请出本次任务的最大功臣:ResNet50。

    有关ResNet50的内容太多,我们下一期慢慢讲

    关于深度学习中的batch_size
    https://www.cnblogs.com/gengyi/p/9853664.html

    展开全文
  • 许多二分类任务并不是每个类别都有相同数量的数据,存在着数据分布平衡的情况。 一个常用的例子是成人收入数据,...针对这一数据,可以使用很多平衡分类的相关算法完成分类任务。 在本教程中,您将了解如...

    许多二分类任务并不是每个类别都有相同数量的数据,存在着数据分布不平衡的情况。

    一个常用的例子是成人收入数据集,它涉及到社交关系、教育水平等个人数据,以此来预测成人的收入水平,判断其是否拥有5万美元/年的个人收入。数据集中个人收入低于5万美元的数据比高于5万美元的数据要明显多一些,存在着一定程度的分布不平衡。
    针对这一数据集,可以使用很多不平衡分类的相关算法完成分类任务。

    在本教程中,您将了解如何为数据分布不平衡的成人收入数据集开发分类模型并对其进行评估。

    学习本教程后,您将知道:

    • 如何加载和分析数据集,并对如何进行数据预处理和模型选择有一定启发。
    • 如何使用一个稳健的测试工具系统地评估机器学习模型的效能。
    • 如何拟合最终模型并使用它预测特定情况所对应的类标签。

    针对成人收入不平衡分类的具体内容如下:

    教程大纲

    本教程主要分为了以下五个部分:

    1. 成人收入数据集介绍
    2. 数据集分析
    3. 基础模型和性能评价
    4. 模型评价
    5. 对新输入数据进行预测

    成人收入数据集介绍

    在这个教程中,我们将使用一个数据分布不平衡的机器学习常用数据集,称为“成人收入”或简称“成人”数据集。
    该数据集归Ronny Kohavi和Barry Becker所有,取自1994年美国人口普查局的数据,包含有教育水平等个人详细数据,用于预测个人年收入是否超过或低于50000美元。
    数据集提供14个输入变量,这些变量数据的类型有标签数据、序列数据、连续数据。变量的完整列表如下:

    • 年龄。
    • 阶级。
    • 最终重量。
    • 教育程度。
    • 教育年限。
    • 婚姻状况。
    • 职业。
    • 社交。
    • 种族。
    • 性别。
    • 资本收益。
    • 资本损失。
    • 每周工作小时数。
    • 国籍。

    总共有48842行数据,3620行含有缺失数据,45222行具有完整的数据,其中缺失值用?标记。
    有'>50K'和'<=50K'两类标签数据,也就是说它是一个二分类任务。同时这些标签数据分布不平衡,'<=50K'类标签比重更大。
    考虑到标签数据分布不平衡的情况并不严重,并且两个标签同等重要,本教程采用常见的分类准确度或分类误差来反映此数据集上的相关模型性能。

    分析数据集

    成人数据集是一个广泛使用的标准机器学习数据集,用于探索和演示许多一般性的或专门为不平衡分类设计的机器学习算法。

    首先,下载数据集并将其保存在当前工作目录中,命名为“adult-all.csv”.

    接下来让我们考察一下该数据集。文件的前几行如下:

    39,State-gov,77516,Bachelors,13,Never-married,Adm-clerical,Not-in-family,White,Male,2174,0,40,United-States,<=50K
    50,Self-emp-not-inc,83311,Bachelors,13,Married-civ-spouse,Exec-managerial,Husband,White,Male,0,0,13,United-States,<=50K
    38,Private,215646,HS-grad,9,Divorced,Handlers-cleaners,Not-in-family,White,Male,0,0,40,United-States,<=50K
    53,Private,234721,11th,7,Married-civ-spouse,Handlers-cleaners,Husband,Black,Male,0,0,40,United-States,<=50K
    28,Private,338409,Bachelors,13,Married-civ-spouse,Prof-specialty,Wife,Black,Female,0,0,40,Cuba,<=50K
    ...

    我们可以看到,输入变量包含有连续数据、标签数据以及序号数据,对于标签数据需要进行二进制或者独热编码。同时也需要注意到,目标变量是用字符串表示的,而对于二分类问题,需要用0/1进行标签编码,因此对于占比多的多数标签编码为0,而占比较少的少数标签则编码为1。缺失的数据用?表示,通常可以估算这些值,也可以直接从数据集中删除这些行。

    具体的载入数据集方法可使用read_csv()这一Pandas包的内置函数,只需要指定文件名、是否读入标题行以及缺失值的对应符号(本数据为?,缺失值会被处理为NaN数据):

    # define the dataset location
    filename = 'adult-all.csv'
    # load the csv file as a data frame
    dataframe = read_csv(filename, header=None, na_values='?')

    成功加载数据集后,我们需要移除缺失数据所在的行,并统计数据大小:

    # drop rows with missing
    dataframe = dataframe.dropna()
    # summarize the shape of the dataset
    print(dataframe.shape)

    通过Counter函数我们可以统计数据集分布情况:

    # summarize the class distribution
    target = dataframe.values[:,-1]
    counter = Counter(target)
    for k,v in counter.items():
        per = v / len(target) * 100
        print('Class=%s, Count=%d, Percentage=%.3f%%' % (k, v, per))

    上述函数集合到一起,就实现了数据加载和相关统计工作。完整代码如下:

    # load and summarize the dataset
    from pandas import read_csv
    from collections import Counter
    # define the dataset location
    filename = 'adult-all.csv'
    # load the csv file as a data frame
    dataframe = read_csv(filename, header=None, na_values='?')
    # drop rows with missing
    dataframe = dataframe.dropna()
    # summarize the shape of the dataset
    print(dataframe.shape)
    # summarize the class distribution
    target = dataframe.values[:,-1]
    counter = Counter(target)
    for k,v in counter.items():
        per = v / len(target) * 100
        print('Class=%s, Count=%d, Percentage=%.3f%%' % (k, v, per))

    运行结果如下:

    (45222, 15)
    Class= <=50K, Count=34014, Percentage=75.216%
    Class= >50K, Count=11208, Percentage=24.784%

    在上述代码中,首先我们加载了数据集,并确认了行和列的数量,即45222行,15列(14个输入变量和一个目标变量)。然后分析了数据分布情况,发现数据分布是不平衡的,大约75%的数据都是(<=50K),而只有大约25%的数据是(>50K)。

    通过创建直方图,我们可以更直观地看到数据分布情况。具体做法如下:
    首先,调用select_dtypes函数选取数值型数据。

    ...
    # select columns with numerical data types
    num_ix = df.select_dtypes(include=['int64', 'float64']).columns
    # select a subset of the dataframe with the chosen columns
    subset = df[num_ix]

    然后通过matplotlib绘图包进行显示。

    # create histograms of numeric input variables
    from pandas import read_csv
    from matplotlib import pyplot
    # define the dataset location
    filename = 'adult-all.csv'
    # load the csv file as a data frame
    df = read_csv(filename, header=None, na_values='?')
    # drop rows with missing
    df = df.dropna()
    # select columns with numerical data types
    num_ix = df.select_dtypes(include=['int64', 'float64']).columns
    # select a subset of the dataframe with the chosen columns
    subset = df[num_ix]
    # create a histogram plot of each numeric variable
    subset.hist()
    pyplot.show()

    运行上述代码,将为数据集中的六个输入变量分别创建一个直方图。

     

    我们可以看到它们有着不同的分布情况,有些是高斯分布,有些是指数分布或离散分布。同样可以看出,他们的变化范围差异较大。而为了得到较好的算法效果,我们通常需要将数据分布缩放到相同的范围,因此需要进行相应的幂变换。

    基础模型和性能评价

    k-fold交叉验证方法能够较好估计模型的性能。在这里我们将使用k=10的重复分层k-fold交叉验证方法来评估相关模型,这意味着每个折叠将包含约45222/10=4522个数据。而分层表示每一个折叠将包含相同的混合比例(即每个折叠中指标数据都具有75%-25%的分布特征)。重复表示评估过程将被多次执行,以避免偶然结果和更好地捕获所选模型的方差,本教程中,我们将重复三次。这意味着将对单个模型进行10×3=30次拟合和评估,并记录每次运行结果的平均值和标准差。

    上述方法可以通过scikit-learn包里面的RepeatedStratifiedKFold函数实现。
    具体代码如下:

    # evaluate a model
    def evaluate_model(X, y, model):
        # define evaluation procedure
        cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
        # evaluate model
        scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
        return scores

    通过evaluate_model()函数我们实现了获取加载的数据集和定义的模型,使用重复分层k-fold交叉验证对其进行评估,然后返回一个准确度列表。

    而如何生成X、Y数据呢?我们可以定义一个函数来加载数据集并对目标列进行编码,然后返回所需数据。具体代码如下:

    # load the dataset
    def load_dataset(full_path):
        # load the dataset as a numpy array
        dataframe = read_csv(full_path, header=None, na_values='?')
        # drop rows with missing
        dataframe = dataframe.dropna()
        # split into inputs and outputs
        last_ix = len(dataframe.columns) - 1
        X, y = dataframe.drop(last_ix, axis=1), dataframe[last_ix]
        # select categorical and numerical features
        cat_ix = X.select_dtypes(include=['object', 'bool']).columns
        num_ix = X.select_dtypes(include=['int64', 'float64']).columns
        # label encode the target variable to have the classes 0 and 1
        y = LabelEncoder().fit_transform(y)
        return X.values, y, cat_ix, num_ix

    通过以上步骤,我们就可以使用这个测试工具评估数据集的相关模型了。

    为了更好地评估若干模型之间的差距,我们可以通过scikit库里面的DummyClassifier类建立一个基准模型。相关代码如下:

    # define the reference model
    model = DummyClassifier(strategy='most_frequent')
    # evaluate the model
    scores = evaluate_model(X, y, model)
    # summarize performance
    print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))

    上述函数集合到一起,就实现了一个基准算法对于数据集的预测分类和评价。完整代码如下:

    # test harness and baseline model evaluation for the adult dataset
    from collections import Counter
    from numpy import mean
    from numpy import std
    from numpy import hstack
    from pandas import read_csv
    from sklearn.preprocessing import LabelEncoder
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import RepeatedStratifiedKFold
    from sklearn.dummy import DummyClassifier
    
    # load the dataset
    def load_dataset(full_path):
        # load the dataset as a numpy array
        dataframe = read_csv(full_path, header=None, na_values='?')
        # drop rows with missing
        dataframe = dataframe.dropna()
        # split into inputs and outputs
        last_ix = len(dataframe.columns) - 1
        X, y = dataframe.drop(last_ix, axis=1), dataframe[last_ix]
        # select categorical and numerical features
        cat_ix = X.select_dtypes(include=['object', 'bool']).columns
        num_ix = X.select_dtypes(include=['int64', 'float64']).columns
        # label encode the target variable to have the classes 0 and 1
        y = LabelEncoder().fit_transform(y)
        return X.values, y, cat_ix, num_ix
    
    # evaluate a model
    def evaluate_model(X, y, model):
        # define evaluation procedure
        cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
        # evaluate model
        scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
        return scores
    
    # define the location of the dataset
    full_path = 'adult-all.csv'
    # load the dataset
    X, y, cat_ix, num_ix = load_dataset(full_path)
    # summarize the loaded dataset
    print(X.shape, y.shape, Counter(y))
    # define the reference model
    model = DummyClassifier(strategy='most_frequent')
    # evaluate the model
    scores = evaluate_model(X, y, model)
    # summarize performance
    print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))

    运行结果如下:

    (45222, 14) (45222,) Counter({0: 34014, 1: 11208})
    Mean Accuracy: 0.752 (0.000)

    通过上述代码,我们首先加载数据并进行预处理。然后通过DummyClassifier()进行分类,并通过RepeatedStratifiedKFold()进行评价。可以看到,基准算法达到了约75.2%的准确度。这一结果指出了相关模型的准确度下限;任何平均准确度高于75.2%的模型都可被视为有效模型,而低于75.2%则通常被认为是无效的。

    模型评价

    在上一节中,我们看到,基准算法的性能良好,但还有很大的优化空间。
    在本节中,我们将使用上一节中所描述的评价方法评估作用于同一数据集的不同算法。
    目的是演示如何系统地解决问题,以及某些为不平衡分类问题设计的算法。

    不同的机器学习算法

    在这里,我们选取一系列非线性算法来进行具体的评价,如:

    • 决策树(CART,Decision Tree)
    • 支持向量机(SVM,Support Vector Machine)
    • 袋装决策树(BAG,Bagged Decision Trees)
    • 随机森林(RF,Random Forest)
    • 爬坡机(GBM,Gradient Boosting Machine)

    首先定义一个列表,依次定义每个模型并将它们添加到列表中,以便于后面将运算的结果进行列表显示。代码如下:

    # define models to test
    def get_models():
        models, names = list(), list()
        # CART
        models.append(DecisionTreeClassifier())
        names.append('CART')
        # SVM
        models.append(SVC(gamma='scale'))
        names.append('SVM')
        # Bagging
        models.append(BaggingClassifier(n_estimators=100))
        names.append('BAG')
        # RF
        models.append(RandomForestClassifier(n_estimators=100))
        names.append('RF')
        # GBM
        models.append(GradientBoostingClassifier(n_estimators=100))
        names.append('GBM')
        return models, names

    针对每一个算法,我们将主要使用默认的模型超参数。对标签变量进行独热编码,对连续型数据变量通过MinMaxScaler进行规范化处理。具体的,建立一个Pipeline,其中第一步使用ColumnTransformer()函数;第二步使用OneHotEncoder()函数;第三步使用MinMaxScaler函数。相关代码如下:

    ...
    # define steps
    steps = [('c',OneHotEncoder(handle_unknown='ignore'),cat_ix), ('n',MinMaxScaler(),num_ix)]
    # one hot encode categorical, normalize numerical
    ct = ColumnTransformer(steps)
    # wrap the model i a pipeline
    pipeline = Pipeline(steps=[('t',ct),('m',models[i])])
    # evaluate the model and store results
    scores = evaluate_model(X, y, pipeline)
    # summarize performance
    print('>%s %.3f (%.3f)' % (names[i], mean(scores), std(scores)))

    同时,我们可以通过作图进行直观的比较:

    ...
    # plot the results
    pyplot.boxplot(results, labels=names, showmeans=True)
    pyplot.show()

    上述代码集合到一起,我们就实现了对于若干算法性能的对比。完整代码如下:

    # spot check machine learning algorithms on the adult imbalanced dataset
    from numpy import mean
    from numpy import std
    from pandas import read_csv
    from matplotlib import pyplot
    from sklearn.preprocessing import LabelEncoder
    from sklearn.preprocessing import OneHotEncoder
    from sklearn.preprocessing import MinMaxScaler
    from sklearn.pipeline import Pipeline
    from sklearn.compose import ColumnTransformer
    from sklearn.model_selection import cross_val_score
    from sklearn.model_selection import RepeatedStratifiedKFold
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.svm import SVC
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.ensemble import GradientBoostingClassifier
    from sklearn.ensemble import BaggingClassifier
    
    # load the dataset
    def load_dataset(full_path):
        # load the dataset as a numpy array
        dataframe = read_csv(full_path, header=None, na_values='?')
        # drop rows with missing
        dataframe = dataframe.dropna()
        # split into inputs and outputs
        last_ix = len(dataframe.columns) - 1
        X, y = dataframe.drop(last_ix, axis=1), dataframe[last_ix]
        # select categorical and numerical features
        cat_ix = X.select_dtypes(include=['object', 'bool']).columns
        num_ix = X.select_dtypes(include=['int64', 'float64']).columns
        # label encode the target variable to have the classes 0 and 1
        y = LabelEncoder().fit_transform(y)
        return X.values, y, cat_ix, num_ix
    
    # evaluate a model
    def evaluate_model(X, y, model):
        # define evaluation procedure
        cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
        # evaluate model
        scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
        return scores
    
    # define models to test
    def get_models():
        models, names = list(), list()
        # CART
        models.append(DecisionTreeClassifier())
        names.append('CART')
        # SVM
        models.append(SVC(gamma='scale'))
        names.append('SVM')
        # Bagging
        models.append(BaggingClassifier(n_estimators=100))
        names.append('BAG')
        # RF
        models.append(RandomForestClassifier(n_estimators=100))
        names.append('RF')
        # GBM
        models.append(GradientBoostingClassifier(n_estimators=100))
        names.append('GBM')
        return models, names
    
    # define the location of the dataset
    full_path = 'adult-all.csv'
    # load the dataset
    X, y, cat_ix, num_ix = load_dataset(full_path)
    # define models
    models, names = get_models()
    results = list()
    # evaluate each model
    for i in range(len(models)):
        # define steps
        steps = [('c',OneHotEncoder(handle_unknown='ignore'),cat_ix), ('n',MinMaxScaler(),num_ix)]
        # one hot encode categorical, normalize numerical
        ct = ColumnTransformer(steps)
        # wrap the model i a pipeline
        pipeline = Pipeline(steps=[('t',ct),('m',models[i])])
        # evaluate the model and store results
        scores = evaluate_model(X, y, pipeline)
        results.append(scores)
        # summarize performance
        print('>%s %.3f (%.3f)' % (names[i], mean(scores), std(scores)))
    # plot the results
    pyplot.boxplot(results, labels=names, showmeans=True)
    pyplot.show()

    运行结果如下:

    >CART 0.812 (0.005)
    >SVM 0.837 (0.005)
    >BAG 0.852 (0.004)
    >RF 0.849 (0.004)
    >GBM 0.863 (0.004)

     

    我们可以看到所选择的所有算法都达到了75.2%以上的分类准确度。其中GBM算法表现最好,分类准确度约为86.3%。这一结果只是略好于基准算法的结果。而图中虽然存在一些异常值(图上的圆圈),但每个算法的结果都高于75%的基线。每个算法的分布看起来也很紧凑,中位数和平均值基本持平,这表明算法在这个数据集上是相当稳定的。这突出表明,重要的不仅仅是模型性能的综合趋势,更应该考虑的是对于少数类别的分类结果准确度(这在少数民族的相关例子中尤为重要)。

    对新输入数据进行预测

    本节中,我们将使用GradientBoostingClassfier分类模型用于新输入数据的预测。拟合这个模型需要定义ColumnTransformer来对标签数据变量进行编码并缩放连续数据变量,并且在拟合模型之前在训练集上构造一个Pipeline来执行这些变换。具体代码如下:

    ...
    # define model to evaluate
    model = GradientBoostingClassifier(n_estimators=100)
    # one hot encode categorical, normalize numerical
    ct = ColumnTransformer([('c',OneHotEncoder(),cat_ix), ('n',MinMaxScaler(),num_ix)])
    # scale, then oversample, then fit model
    pipeline = Pipeline(steps=[('t',ct), ('m',model)])

    函数定义完成后,我们就可以调用该函数进行参数拟合了:

    ...
    # fit the model
    pipeline.fit(X, y)

    拟合阶段过后,通过predict()函数进行预测,返回输入数据对应的标签是“<=50K”还是“>50K”:

    ...
    # define a row of data
    row = [...]
    # make prediction
    yhat = pipeline.predict([row])

    通过GradientBoostingClassfier分类模型进行预测的完整代码如下:

    # fit a model and make predictions for the on the adult dataset
    from pandas import read_csv
    from sklearn.preprocessing import LabelEncoder
    from sklearn.preprocessing import OneHotEncoder
    from sklearn.preprocessing import MinMaxScaler
    from sklearn.compose import ColumnTransformer
    from sklearn.ensemble import GradientBoostingClassifier
    from imblearn.pipeline import Pipeline
    
    # load the dataset
    def load_dataset(full_path):
        # load the dataset as a numpy array
        dataframe = read_csv(full_path, header=None, na_values='?')
        # drop rows with missing
        dataframe = dataframe.dropna()
        # split into inputs and outputs
        last_ix = len(dataframe.columns) - 1
        X, y = dataframe.drop(last_ix, axis=1), dataframe[last_ix]
        # select categorical and numerical features
        cat_ix = X.select_dtypes(include=['object', 'bool']).columns
        num_ix = X.select_dtypes(include=['int64', 'float64']).columns
        # label encode the target variable to have the classes 0 and 1
        y = LabelEncoder().fit_transform(y)
        return X.values, y, cat_ix, num_ix
    
    # define the location of the dataset
    full_path = 'adult-all.csv'
    # load the dataset
    X, y, cat_ix, num_ix = load_dataset(full_path)
    # define model to evaluate
    model = GradientBoostingClassifier(n_estimators=100)
    # one hot encode categorical, normalize numerical
    ct = ColumnTransformer([('c',OneHotEncoder(),cat_ix), ('n',MinMaxScaler(),num_ix)])
    # scale, then oversample, then fit model
    pipeline = Pipeline(steps=[('t',ct), ('m',model)])
    # fit the model
    pipeline.fit(X, y)
    # evaluate on some <=50K cases (known class 0)
    print('<=50K cases:')
    data = [[24, 'Private', 161198, 'Bachelors', 13, 'Never-married', 'Prof-specialty', 'Not-in-family', 'White', 'Male', 0, 0, 25, 'United-States'],
        [23, 'Private', 214542, 'Some-college', 10, 'Never-married', 'Farming-fishing', 'Own-child', 'White', 'Male', 0, 0, 40, 'United-States'],
        [38, 'Private', 309122, '10th', 6, 'Divorced', 'Machine-op-inspct', 'Not-in-family', 'White', 'Female', 0, 0, 40, 'United-States']]
    for row in data:
        # make prediction
        yhat = pipeline.predict([row])
        # get the label
        label = yhat[0]
        # summarize
        print('>Predicted=%d (expected 0)' % (label))
    # evaluate on some >50K cases (known class 1)
    print('>50K cases:')
    data = [[55, 'Local-gov', 107308, 'Masters', 14, 'Married-civ-spouse', 'Prof-specialty', 'Husband', 'White', 'Male', 0, 0, 40, 'United-States'],
        [53, 'Self-emp-not-inc', 145419, '1st-4th', 2, 'Married-civ-spouse', 'Exec-managerial', 'Husband', 'White', 'Male', 7688, 0, 67, 'Italy'],
        [44, 'Local-gov', 193425, 'Masters', 14, 'Married-civ-spouse', 'Prof-specialty', 'Wife', 'White', 'Female', 4386, 0, 40, 'United-States']]
    for row in data:
        # make prediction
        yhat = pipeline.predict([row])
        # get the label
        label = yhat[0]
        # summarize
        print('>Predicted=%d (expected 1)' % (label))

    运行结果如下:

    <=50K cases:
    >Predicted=0 (expected 0)
    >Predicted=0 (expected 0)
    >Predicted=0 (expected 0)
    >50K cases:
    >Predicted=1 (expected 1)
    >Predicted=1 (expected 1)
    >Predicted=1 (expected 1)

    运行该代码,我们首先实现了模型在训练数据集上的训练,然后针对新的输入数据进行预测。可以看到,预测值和真实值是一致的,说明模型具有很好的预测功能。

     

    展开全文
  • 摘要:本文对机器学习中的UCI数据进行介绍,带你从UCI数据官网出发一步步深入认识数据,并就下载的原始数据详细讲解了不同类型的数据整理如何通过程序进行整理。为了方便使用,博文中附上了包括数据整理及...
  • 波士顿房价预测任务

    万次阅读 2020-08-12 22:52:17
    构建波士顿房价预测任务的神经网络模型 一、数据处理 数据处理包含五个部分:数据导入、数据形状变换、数据划分、数据归一化处理和封装load data函数。数据预处理后,才能被模型调用。 读入数据:通过读入数据,...
  • 一个单位时间任务是恰好需要一个单位时间完成任务。给定一个单位时间任务的有限S.关于S的一个时间表用于描述S中单位时间任务的执行次序。
  • 任务时间表】解题报告

    千次阅读 2011-11-10 16:09:09
    3、任务时间表(task.cpp/pas) ...时间表中1个任务从时间0开始执行直至时间1结束,2个任务从时间1开始执行至时间2结束,…,n个任务从时间n-1开始执行直至时间n结束。 具有截止时间和误时惩罚的单
  • 任务调度问题实验

    千次阅读 2016-06-13 16:05:17
     任务调度问题就是给定一个有穷单位时间任务的集合S,集合S中的每个任务都有一个截止期限di和超时惩罚wi,需要找出集合S的一个调度,使得因任务误期所导致的总惩罚最小,这个调度也称为S的一个最优调度。...
  • 4-22 任务时间表问题 ...时间表中 1 个任务从 时间 0 开始执行直至时间 1 结束, 2 个任务从时间 1 开始执行至时间 2 结束,…, n 个任务从时间 n-1 开始执行直至时间 n 结束。 具有截止时间和误时惩罚的单...
  • C#OOP之三 组件、程序与反射

    千次阅读 2016-04-30 20:44:42
    组件 组件技术是软件领域一项非常大的成就。组件技术像搭积木游戏一样,在搭积木时,我们知道并不是... 在软件领域,这些“积木”模型有微软的COM,Sun的JavaBean、.Net的程序等。 组件可以提高子程序的重用性和灵
  • 任务调度问题(贪心思想)

    千次阅读 2019-11-12 16:00:22
    时间表中1 个任务从时间0 开始执行直至时间1 结束,2 个任务从时间1 开始执行至时间2 结束,…,n个任务从时间n-1 开始执行直至时间n结束。具有截止时间和误时惩罚的单位时间任务时间表问题可描述如下:   ...
  • 自动任务调度系统

    千次阅读 2019-06-30 05:05:50
    这个自动任务调度系统的来由是这样的:前段时间,在一个 Java 技术群中,看到一个网友发了一个消息,说:自己在面试中,遇到编写一个具体的自动任务调度系统。并把面试中的那个任务调度系统的需求发到了群中。当时,...
  • 神经网络的多任务学习概览

    千次阅读 2019-05-24 15:39:45
    1. 前言   在机器学习中,我们通常关心优化某一特定指标,不管这个指标是一个标准值,还是...为了达到这个目标,我们训练单一模型或多个模型集合来完成指定得任务。然后,我们通过精细调参,来改进模型直至性能...
  • Spring整合Quartz框架定时任务

    千次阅读 2016-11-29 15:44:01
    最近项目中经常用到队列和定时任务及线程的整合应用,涉及的场景是当多人访问系统时需要回调客户系统处理结果时,如何减少服务器压力并能处理业务需求,这里用到了队列减少服务器压力加入定时任务发送机制,使用的是...
  • Java面试题全集(中)

    万次阅读 多人点赞 2015-04-09 22:05:20
    答:Servlet与CGI的区别在于Servlet处于服务器进程中,它通过多线程方式运行其service()方法,一个实例可以服务于多个请求,并且其实例一般不会销毁,而CGI对每个请求都产生新的进程,服务完成后就销毁,所以效率上...
  • Danqi Chen的这篇论文很好地概括了从1977年以来的阅读理解领域发展,通读一遍对初学者(我)也是受益匪浅,文章以“数据和模型的相互促进”为脉络,穿插讲解了各种数据和模型方法的发展,并拿自己的一个典型模型...
  • 主要解决数据研发ETL 错综复杂的依赖关系,而能直观监控任务健康状态等问题。EasyScheduler以DAG流式的方式将Task组装起来,可实时监控任务的运行状态,同时支持重试、从指定节点恢复失败、暂停及Kill任务等操作。...
  • 题目:对话系统任务综述与基于POMDP的对话系统 作者:李林琳,赵世奇 注:本文的一部分主要内容基于“Review of spoken dialogue systems”(López-Cózar et al., 2015);二部分翻译自英文原文“POMDP-...
  • 主机能正常启动解决方案合集

    千次阅读 2006-10-22 17:59:00
    二、按下电源开关后,风扇旋转但主机启动。1、电源开关故障 当电源开关按键因为老化能复位时或机箱前面板因为变形导致电源开关按钮按下后能及时复位,使用开关始终处于接通状态,这时就会出现按下电源开关后...
  • Redis面试题

    千次阅读 多人点赞 2019-09-16 10:19:31
    Redis 面试题Redis 面试题1. Redis为什么是单线程的?2. Redis 支持的数据类型有哪些?合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一...
  • 一步:添加程序,解决方案——右键项目——管理NuGet程序包 搜索quartz,并下载,如下图,此处我当前下载的版本是v3.0.6 下载完成后会发现项目引用里面多了几个引用,并且多了一个packages.config文件 此时...
  • 如果是想训练一个手写体识别的模型,用一些前人收集好的手写文字就好了,比如中科院的这些数据。但是如果我们只是想要训练一个专门用于识别印刷汉字的模型,那么我们就需要各种印刷字体的训练,那怎么获取呢?...
  • 是与KDD-99五届知识发现和数据挖掘国际会议同时举行的三届国际知识发现和数据挖掘工具竞赛使用的数据。竞争任务是建立一个网络入侵检测器,这是一种能够区分称为入侵或攻击的“不良”连接和“良好”的正常...
  • 任务学习综述

    千次阅读 2020-03-30 21:22:41
    本篇来自论文《An Overview of Multi-Task Learning in ...为了做到这一点,我们通常训练一个模型或一组模型来执行我们所期望的任务。然后我们对这些模型进行微调,直到它们的性能不再提高。虽然我们通常可以通过这...
  • yolov3训练自己的数据——一次实操完整记录

    万次阅读 多人点赞 2019-07-09 19:36:24
    make: *** 正在等待未完成任务.... 出现上面错误的原因是之前我安装的opencv是python的,即opencv_python。这里模型的训练需要用到c++的opencv。所以这里再装一遍opencv。 我在 官网 上选择的opencv4.1.0安装...
  • 浅谈大数据任务调度平台

    千次阅读 2020-12-28 13:54:35
    谈到大数据,避免了hadoop, hive, spark 这些基础套件,但是在整个大数据开发的时候,我们面对的基本上都是数据开发平台和任务调度系统。数据开发平台一般直接面对业务同学,很大程度上影响业务同学的开发效率和...
  • 100 个网络基础知识普及,看完成半个网络高手

    万次阅读 多人点赞 2019-09-23 11:38:54
    是否可以这样做,而使用线器或路由器? 是的,您可以使用一根电缆将两台计算机连接在一起。在这种情况下可以使用交叉型电缆。在这种设置中,一条电缆的数据传输引脚连接到另一条电缆的数据接收引脚,反之亦然...
  • VQA数据调研报告

    千次阅读 2018-03-21 18:24:21
    VQA数据调研报告2018年3月16日14:22一、VQA数据1....训练(training set)(1)基本情况介绍:name:v2_OpenEnded_mscoco_train2014_questions.jsonsize:40Mversion: 2.0year: 2017 contributor: VQA Team d...
  • MT-BERT在文本检索任务中的实践

    千次阅读 2020-08-20 19:58:00
    408篇2020年 32篇基于微软大规模真实场景数据的阅读理解数据MS MARCO,美团搜索与NLP中心提出了一种针对该文本检索任务的BERT算法方案DR-BERT,该方案是一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 91,250
精华内容 36,500
关键字:

不可能完成的任务第40集