基于神经网络(PyTorch)的常见水果分类
一本关于神经网络实现高准确率的易读指南
目的:寻找一种对水果 360 幅图像分类准确率最高的神经网络模型。
- 深度前馈
- 卷积神经网络
- 残差神经网络(ResNet9)
数据来源:【https://www.kaggle.com/moltean/fruits
全码笔记本:https://jovian.ml/limyingying2000/fruitsfinal
D 数据准备
首先，让我们了解一下我们的数据集！
Kaggle Fruits 360 数据集由 131 种不同类型的水果和蔬菜的 90483 张图像组成。
首先，我们导入数据和所需的库来运行我们的代码。
import torch
import os
import jovian
import torchvision
import numpy as np
import matplotlib.pyplot as plt
import torch.nn as nn
import torchvision.models as models
import torch.nn.functional as F
from torchvision.datasets import ImageFolder
from torchvision.transforms import ToTensor
from torchvision.utils import make_grid
from torch.utils.data.dataloader import DataLoader
from torch.utils.data import random_split
import torchvision.models as models
%matplotlib inline
每种水果都有其独特的文件夹，由 jpg 图像组成。
使用 matplotlib 库显示彩色图像:
import matplotlib.pyplot as plt
def **show_example**(img, label):
print('Label: ', dataset.classes[label], "("+str(label)+")")
plt.imshow(img.permute(1, 2, 0))
数据集[5000]是一个苹果蛇果
由于我们使用的是 PyTorch ，我们必须使用ToTensor将上面的像素图像转换成张量:
dataset = ImageFolder(data_dir + '/Training', transform=ToTensor())
img, label = dataset[0]
print(img.shape, label)
img
图像转换成张量的一个例子
有 3 个通道(红、绿、蓝)，100*100 图像尺寸。每个值代表相对于通道颜色的颜色强度。
训练和验证数据集
接下来，我们将随机分割数据以获得 3 组数据:
- 训练集:训练模型
- 验证集:评估模型
- 测试集:报告模型的最终准确性
训练数据集的大小:57，692
验证数据集的大小:10，000
测试数据集的大小:22，688
分批培训
因为我们总共有 57，692 个训练图像，所以在使用*DataLoader*训练我们的模型之前，我们应该将我们的图像分成更小的批次。使用较小的数据集可以减少内存空间，从而提高训练速度。
对于我们的数据集，我们将使用 128 的批量大小。
在训练批次中随机分配 128 个图像
现在，我们将开始设计我们的模型。
1.深度前馈
超参数:
架构:“5 层(2000，1000，500，250，131)”
学习率:[0.01，0.001]
历元数:[10，10]
优化函数:随机梯度下降(SGD)
用 5 层架构训练模型:
class **FruitsModelFF**(ImageClassificationBase):
def **__init__**(self):
super().__init__()
self.linear1= nn.Linear(input_size, 2000)
self.linear2= nn.Linear(2000, 1000)
self.linear3= nn.Linear(1000,500)
self.linear4= nn.Linear(500,250)
self.linear5= nn.Linear(250, output_size)
def **forward**(self, xb):
*# Flatten images into vectors*
out = xb.view(xb.size(0), -1)
*# Apply layers & activation functions*
out= self.linear1(out)
out=F.relu(out)
out=self.linear2(out)
out=F.relu(out)
out=self.linear3(out)
out=F.relu(out)
out=self.linear4(out)
out=F.relu(out)
out=self.linear5(out)
return out
训练前，验证准确率为: 0.52734%
A 在以[0.01，0.001]的学习速率训练了总共 20 个周期后，验证准确率在大约 96.84% 处达到平稳状态。这与最初的 0.52734%相比是一个巨大的跳跃。
最后，让我们用测试数据集来测试我们训练好的模型！
img, label = test[8000]
plt.imshow(img.permute(1, 2, 0))
print('Label:', dataset.classes[label], ', Predicted:', predict_image(img, model))
img, label = test[1002]
plt.imshow(img.permute(1, 2, 0))
print('Label:', dataset.classes[label], ', Predicted:', predict_image(img, model))
img, label = test[0]
plt.imshow(img.permute(1, 2, 0))
print('Label:', dataset.classes[label], ', Predicted:', predict_image(img, model))
我们训练的模型正确地预测了上述所有结果。
**Final test accuracy: 86.209%**
为了进一步提高我们的测试精度，我们将使用卷积神经网络，它通常比前馈神经网络性能更好。
原因:
通过应用相关过滤器，ConvNet 能够成功捕捉图像中的空间和时间相关性。由于所涉及的参数数量的减少和权重的可重用性，该架构对图像数据集执行更好的拟合。换句话说，可以训练网络更好地理解图像的复杂程度。
简而言之，CNN 非常适合计算密集型的大尺寸图像:
- 需要更少的参数
- 形成连接的稀疏性
- 能够检测相似的模式，并在图像的不同部分应用学到的特征
2。简单卷积神经网络(CNN)
CNN 功能简介:
内核上的权重首先被随机初始化为:
[0, 1, 2] [2, 2, 0] [0, 1, 2]
我们的示例图像如下所示:
[3, 3, 2, 1, 0] [0, 0, 1, 3, 1] [3, 1, 2, 2, 3] [2, 0, 0, 2, 2] [2, 0, 0, 0, 1]
当我们对样本图像应用内核时，输出将是:
[12., 12., 17.] [10., 17., 19.] [ 9., 6., 14.]
申请:
输出= 2 * 0+2 * 1+3 * 2+0 * 2+2 * 2+2 * 0+0 * 0+0 * 1+1 * 2 = 14
对样本图像上内核的每次移动重复计算输出，以获得新的输出大小。
def **apply_kernel**(image, kernel):
ri, ci = image.shape *# image dimensions*
rk, ck = kernel.shape *# kernel dimensions*
ro, co = ri-rk+1, ci-ck+1 *# output dimensions*
output = torch.zeros([ro, co])
for i in range(ro):
for j in range(co):
output[i,j] = torch.sum(image[i:i+rk,j:j+ck] * kernel)
return output
此外，我们通过应用最大池层来逐渐减小每个卷积层的输出张量的大小。
如上所述，卷积层增加了通道，而最大池层减少了图像大小。
现在，让我们为同一个 Kaggle 水果数据集构建 CNN 模型。
超参数:
纪元数量:10
学习率:0.001
优化函数:亚当
class **FruitsModel**(ImageClassificationBase):
def **__init__**(self):
super().__init__()
self.network = nn.Sequential(
nn.Conv2d(3, 32, kernel_size=3, padding=1), *#3 channels to 32 channels*
nn.ReLU(),
nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
nn.MaxPool2d(2, 2), *# output: 64 channels x 50 x 50 image size - decrease*
nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1), *#can keep the same, increase power of model , go deeper as u add linearity to non-linearity*
nn.ReLU(),
nn.MaxPool2d(2, 2), *# output: 128 x 25 x 25*
nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
nn.MaxPool2d(5, 5), *# output: 256 x 5 x 5*
nn.Flatten(), *#a single vector 256*5*5,*
nn.Linear(256*5*5, 1024),
nn.ReLU(),
nn.Linear(1024, 512),
nn.ReLU(),
nn.Linear(512, 131))
def **forward**(self, xb):
return self.network(xb)
除了在我们的模型中的改变之外，我们使用 Adam 优化器函数，因为它是在分类问题中寻找最小成本函数的更有效的方式。
**Final test accuracy rate: 92.571%**
我们已经实现了非常高的最终测试准确率，大约比前馈神经网络高6。然而，让我们通过额外的残差块和对 CNN 模型的微小调整来进一步拓展边界。
**3。**残差神经网络( ResNet9)
超参数:
最大学习率:0.01
纪元数量:10
优化函数:亚当
def **conv_block**(in_channels, out_channels, pool=False):
layers = [nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)]
if pool: layers.append(nn.MaxPool2d(2))
return nn.Sequential(*layers)
class **ResNet9**(ImageClassificationBase):
def **__init__**(self, in_channels, num_classes):
super().__init__()
self.conv1 = conv_block(in_channels, 64)
self.conv2 = conv_block(64, 128, pool=True)
self.res1 = nn.Sequential(conv_block(128, 128), conv_block(128, 128))
self.conv3 = conv_block(128, 256, pool=True)
self.conv4 = conv_block(256, 512, pool=True)
self.res2 = nn.Sequential(conv_block(512, 512), conv_block(512, 512))
self.classifier = nn.Sequential(nn.MaxPool2d(4),
nn.Flatten(),
nn.Linear(4608, num_classes))
def **forward**(self, xb):
out = self.conv1(xb)
out = self.conv2(out)
out = self.res1(out) + out
out = self.conv3(out)
out = self.conv4(out)
out = self.res2(out) + out
out = self.classifier(out)
return out
除此之外，我们还将引入**“一个周期学习率策略”**，它会逐渐提高学习率，直至达到用户设定的最大学习率，然后逐渐降至极低的学习率。这种学习率的变化发生在每一批训练之后。
很难找到正确的学习速率，因为相对较高的学习速率会导致发散，而相对较低的学习速率会导致模型过拟合。
然而,“一个周期学习率策略”通过为我们的模型找到一个最佳学习率范围克服了这样的问题。
学习率在大约第 1200 批次时达到峰值 0.01
**Final test accuracy: 98.85%**
经过一些修改，我们的最终测试精度又提高了6%。
总结:
在这 3 个不同的模型中，ResNet9 的测试准确率最高，为 98.85%。
未来工作:
- 数据转换(数据扩充和标准化)
- 高级迁移学习
演职员表:
课程资料来自深度学习用 py torch:Zero to GANs&freeCodeCamp
基于 KNN 和 SMOTE 的酒店取消分类
KNN(K-最近邻)是一种用于分类目的的常用方法。
在此特定示例中，KNN 算法用于根据取消风险对酒店预订进行分类(1 =模型预测客户将取消预订，0 =预测客户不会取消预订)。
假设该数据集是不平衡的，即 0(未消除)比 1(消除)多，则使用合成少数过采样技术(SMOTE)来平衡类，以便应用 KNN 算法。
SMOTE 过采样技术
鉴于数据集的不均匀性，有必要对次要类进行过采样(1 =取消)，以确保 KNN 结果不会偏向主要类。
这可以通过 SMOTE 过采样技术来实现。
使用 MinMaxScaler 导入和缩放数据后，可以从 imblearn 库中导入 SMOTE。计数器是为了汇总类分布而导入的。
import imblearn
print(imblearn.__version__)
from imblearn.over_sampling import SMOTE
from collections import Counter
首先，调用训练-测试分割将数据分成训练和验证数据。
x1_train, x1_val, y1_train, y1_val = train_test_split(x_scaled, y1, random_state=0)
原班级分布由 0 : 21672， 1 : 8373 组成。
>>> counter = Counter(y_train)
>>> print(counter)Counter({0: 21672, 1: 8373})
然而，在应用 SMOTE 过采样技术之后，我们现在看到每一类中的观察值的数量是相等的。
>>> oversample = SMOTE()
>>> x_train, y_train = oversample.fit_resample(x_train, y_train)
>>> counter = Counter(y_train)
>>> print(counter)Counter({1: 21672, 0: 21672})
模型性能
该模型配置如下:
# KNN
knn = KNeighborsClassifier(n_neighbors=10)
model=knn.fit(x1_train, y1_train)
pred = model.predict(x1_val)
pred
print("Training set score: {:.2f}".format(knn.score(x1_train, y1_train)))
print("Validation set score: {:.2f}".format(knn.score(x1_val, y1_val)))# KNN Plot
mglearn.plots.plot_knn_classification(n_neighbors=10)
plt.show()
生成训练和测试集分数:
Training set score: 0.88
Validation set score: 0.46
以下是 KNN 模型所示的训练课程与测试预测的对比图:
来源:Jupyter 笔记本
以下是根据混淆矩阵对模型性能进行的细分:
[[2286 4980]
[ 440 2309]]
precision recall f1-score support 0 0.84 0.31 0.46 7266
1 0.32 0.84 0.46 2749 accuracy 0.46 10015
macro avg 0.58 0.58 0.46 10015
weighted avg 0.70 0.46 0.46 10015
虽然总体准确率很低，只有 46%，但根据 f1 评分，召回率相当不错，为 84%。
精确度与召回率
当处理分类数据时，还必须注意精度与召回读数，而不是简单的整体精度。
- Precision = ((True Positive)/(True Positive + False Positive))- Recall = ((True Positive)/(True Positive + False Negative))
这两个读数经常相互矛盾，也就是说，通常不可能在不降低召回率的情况下提高精确度，反之亦然。
对理想指标的评估很大程度上取决于所分析的具体数据。例如，癌症检测筛查出现假阴性(即表明患者没有患癌症，而事实上他们患有癌症)是一大禁忌。在这种情况下，召回是理想的衡量标准。
然而，对于电子邮件，人们可能更喜欢避免误报，例如，将一封重要的电子邮件发送到垃圾邮件文件夹，而实际上它是合法的。
f1 分数在设计一个更通用的分数时考虑了精确度和召回率。
哪个因素对预测酒店取消更重要？
从酒店的角度来看，他们可能希望更准确地识别出最终会取消预订的客户，这使得酒店能够更好地分配房间和资源。确定不打算取消预订的客户不一定会增加酒店分析的价值，因为酒店知道，无论如何，很大一部分客户最终都会坚持预订。
测试数据
让我们看看当模型对 H2(测试集)进行预测时，结果是什么样的。
在这里，我们可以看到 f1 得分的准确性略微提高到了 52%。
[[12569 33659]
[ 4591 28511]]
precision recall f1-score support 0 0.73 0.27 0.40 46228
1 0.46 0.86 0.60 33102 accuracy 0.52 79330
macro avg 0.60 0.57 0.50 79330
weighted avg 0.62 0.52 0.48 79330
但是，取消类(1)的召回率为 86%。如前所述，精确度和召回率经常相互矛盾，仅仅是因为假阳性倾向于增加召回率，而假阴性倾向于增加精确度。
假设酒店希望最大化召回率(即容忍一定数量的误报，同时识别所有将取消预订的客户)，那么该模型符合该标准。
在所有取消预订的客户中，该模型正确识别了 86%的客户。
模型评估
虽然较高的召回率被认为是判断该模型的较好方式，但这不一定以较低的准确性为代价。
如果召回是惩罚假阴性，那么它也有利于假阳性——有太多的假阳性会破坏模型的目的——因为这本质上是假设所有客户都会取消，而事实并非如此。
在这方面，准确性和召回率将理想地最大化。例如，XGBoost 模型展示了 94%的召回率和 55%的 f1 分数准确度——两者都比这个例子中的略高。
结论
在本例中，我们研究了如何使用 KNN 作为分类算法，以及在判断模型性能时精确度和召回率的重要性。
非常感谢您的参与，这个例子的相关 GitHub 库可以在这里找到。
免责声明:本文是在“原样”的基础上编写的，没有担保。本文旨在提供数据科学概念的概述，不应以任何方式解释为专业建议。
参考
使用 Foursquare 数据对加德满都和 Lalitpur 病房进行分类
介绍
加德满都大都市和拉利特普尔大都市是尼泊尔最大的两个城市。虽然是两个不同的城市，但对于这两个城市的居民来说，它们就像一个联合的大城市。每天都有成千上万的人往返于这两个城市之间，这是他们日常生活的一部分。
加德满都市区和拉利特普尔市区分别有 32 个市级选区和 29 个市级选区。对于这个项目，我们想根据病房中的场地对这两个城市的不同病房进行分类。我们的目标是将这两个城市作为一个单一的组合城市来研究，并找出这两个城市的相互反映或作为一个单一单位的选区。
由于人口密集的地区通常更加昂贵和嘈杂，我们也在研究每个病房的人口密度数据。这项研究对于那些想搬到或不得不搬到加德满都或拉利特普尔市的人来说，将是非常有见地的。这种分析将有助于他们根据对场地和人口密度的偏好缩小病房的范围。
数据收集
我们需要收集关于加德满都和拉利特普尔市的病房位置、人口密度和面积的数据。
由于我们正在收集两个城市的数据，我们将分别收集每个城市的数据，然后将它们合并为一个数据集。单个城市的数据被废弃，并从其各自的大都市网站提供的数据中收集。几乎所有关于选区、人口和位置的数据都是用尼泊尔语(梵文)提供的，所以我们必须使用谷歌翻译将数据翻译成英语，然后废弃这些数据。
两个城市的官方网站都提供了每个选区总部的位置。我们将使用地理编码器库使用这些位置数据来定位病房的纬度和经度。
使用纬度、经度数据和 four square API 可以获得每个区的场馆细节。
数据来源是:
- 加德满都病房及其总部的详细信息列表从[1]中删除，各个病房的人口数据从[2]中收集。病房面积数据从本文中导入[3]。
- 类似地，从[4]中删除了 Lalitpur 病房及其总部位置的列表，并从[5]中收集了各个病房的人口和面积数据。
- 使用地理编码库获得基于其总部位置的病房的经度和纬度，并使用谷歌地图[6]手动放置缺失值。
- 从 four square API [7]中收集关于场馆列表、类别、细节和每个病房的数量的数据。
方法学
数据准备
我们只选择了面积大于 0.5 平方米的病房。合并面积小于 0.5 平方公里的行政区。平方公里及其邻近的选区。这减少了病房的数量，而且如果病房很小的话，很多地点重叠的可能性很高，这可能会影响我们以后的研究。关于加德满都和拉利特普尔的病房位置、面积和人口密度的数据被合并，以获得最终的合并数据集，您可以在这个 github 链接上访问该数据集。
下面的地图是使用加德满都和拉利特普尔的病房的位置数据创建的。
加德满都和拉利特普尔的地图及其选区办公室位置
可以使用 four square API 收集为每个病房列出的场所，并且选择半径作为从各个病房的区域获得的半径。为了更好地进行分析和数据研究，我们只筛选出那些列出的场馆数量至少为五个的病房。
代表加德满都和拉利特普尔区场馆数量的条形图
大约有 94 个独特的场馆类别。因此，我们决定使用 four square API 提供的 10 个主要分类场馆，而不是子分类场馆。这 10 个分类场地及其各自的 id 是从下面列出的四个广场 API 中获得的。
主场馆类别及其 ID
从每个区的四个广场 API 中获得这十个类别的每个分类场所的数量。下面的方框图描述了这些类别在拉利特普尔和加德满都的分布情况。
代表加德满都和拉利特普尔病房分类场所的箱线图
我们可以观察到，食品在该类别中占主导地位，而商店和服务、户外活动和创作则排在食品之后。由于事件地点没有重要数据，我们删除了事件类别。
我们使用最小-最大比例(1:最高值，0:最低值)对数据进行标准化。这使数据正常化，并使我们更容易解释不同的场馆。缩放后的数据如下图所示。
使加德满都和拉利特普尔区的场馆类别数据正常化
使聚集
我们使用 k-means 聚类对加德满都和拉利特普尔的病房进行聚类，以每个病房的分级类别数据为基础。
不同组数(k)的初步结果可以解释如下:
1.k=2:场馆数量多和数量少的集群
2.k=3:学院数量多、场馆数量少的集群，第三个集群难以解释
3.k=4:具有高数量的学院、高数量的户外和娱乐场所的集群，其余两个被分类为高和低数量的场所
4.k=5:难以解释集群。
我们选择第四组的数字进行病房分析，因为它提供了比其他组更详细的见解。
聚类及其分类场所的盒图
我们可以从箱线图中观察到，当将数据分为四个簇时，我们得到以下簇。
- 集群 0:多样但低的场馆集群
- 集群 1:户外、创意、艺术和娱乐集群
- 集群 2:学院、大学、商店和服务集群
- 集群 3:多样化和高场馆集群
五大场馆
我们还对每个区的前五个子场馆类别进行了排名，列出了每个区最受欢迎的场馆。
每个选区的前五个场馆
标注人口密度
加德满都和拉利特普尔的人口密度分布
该直方图显示了加德满都和拉利特普尔选区的人口密度分布。
基于这个直方图，我们可以根据人口密度给每个病房贴上以下标签。
-
20，000 =低水平人口密度
- 20000–40000 =较低的中层 1 人口密度
- 40，000–60，000=更高的中层 2 人口密度
- 60，000–80，000 =高水平人口密度
-
80，000 =非常高的人口密度
将我们获得的每个区的所有细节与人口密度标签和聚类标签合并，我们得到以下最终数据集。
加德满都和拉利特普尔的病房及其集群标签、人口密度标签和前五名场馆
最后，我们实现了以下加德满都和拉利特普尔城市的地图。这张地图是用两个城市的不同区标绘的，区标有各自的集群、前三个热门地点和人口密度的信息。
代表加德满都和拉利特普尔区集群、场馆和人口密度的地图
结果
根据现有场馆对加德满都和拉利特普尔的不同行政区进行聚类，并在地图上进行绘制，这向我们展示了大多数多样但低矮的场馆区域位于拉利特普尔和加德满都联合城市的郊区，而联合城市的中心以及两个城市的中心由高大的场馆和特定的场馆区域组成。我们可以观察到两个城市在许多镜像地理位置上相互镜像。人口密度让我们进一步了解所谓的住宅和市场情况。
讨论
four square 数据确实信息丰富，但并不全面，尤其是对于像尼泊尔这样数字平台使用和可访问性刚刚开始繁荣的国家。我们可以观察到，许多病房在四方 API 中列出的场馆数量很少，这肯定与这些病房中的实际场馆数量不一致。此外，四方场馆数据侧重于类别，不包括场馆的规模。与餐馆相比，公园无疑会吸引更多的人。)
结论
我们可以在更大的范围内部署这样的工具，提供更多的功能，如住房率、空气质量率，以更详细地研究我们的城市和其他地区。
不仅对于寻找他们最喜欢的社区的人来说，这种分析也可以极大地有益于城市管理和商业团体等团体。
参考
[1] 加德满都病房办公室位置
[2] 加德满都病房简介
[3] Chhetri，Sachin & Kayastha，P… (2015 年)。尼泊尔加德满都大都市火灾潜在区划绘图的层次分析法(AHP)模型的表现。国际地理信息杂志。4.400–417.10.3390/ijgi4010400。
[4] 拉利特普尔病房办公室
[5] 拉利普尔病房详情
[6] 谷歌地图
[7] 四个正方形
我想提一下 Stanislav Rogozhin 对莫斯科地铁站所做的类似分析，它给了我很大的帮助，让我清楚地知道如何处理和实施这种分析。你可以在下面的链接中找到关于他的分析的研究文章。
基于机器学习的天空物体分类
图片鸣谢&版权: 伊万·佩德雷蒂
第一步:问题和背景
分类是你在数据科学领域可能面临的主要项目之一。因此，我们的导师要求我们为第三个个人项目执行一个分类项目。
自从我开始从事数据科学工作以来，我一直想从事天文数据方面的工作。因此，在做了一些研究后，我决定处理 SDSS 的数据，其中包括关于天空物体及其各种特征的信息。
通过这个项目，我的目标是通过光谱和光度特征对天空物体如恒星、星系和类星体进行分类。SDSS 将这些特性保存在两个不同的表中，所以我不得不借助于一个 SQL 命令来合并它们。合并之后，我将这个表添加到我的项目文件夹中。好了，我得到了我的数据，所以是时候研究这个项目的方法了。
第二步:数据知识
我之前说过，我的数据集是由两个表组成的；一个是光谱特征，一个是光度特征。
- 光谱数据:从物体光谱测得的各种量。例如它的光谱类型或红移。
- 测光数据:从物体图像测量的各种量。例如它的亮度、mag、通量或大小。
这个数据集由 22 列和 500000 行组成，没有缺失值。我在目标列中有三个独特的值:星系，恒星和类星体。
我的目标变量的三个等级之间的平衡是 54%星系，35.4%恒星，和 10.6%类星体。因此，我的数据集没有不平衡，在对数据进行一些基本的数据清理和可视化之后，我可以跳到特征工程部分。
目标值的红移情况-真表示红移，假表示蓝移
步骤 3:特征工程
我标记了 11 个对构建一个良好的分类模型非常重要的特性。因此，我专注于这些专栏来做特性工程。以下是我为本节选择的功能:
- 电磁波谱:天体辐射的光的强度。观测波段范围:紫外线(u)、绿色(g)、红色®、红外线(I)和 z 波段。
- 通量密度:从天体表面流出的能量比率。
- 红移
我从异常值开始。在 I 波段和 z 波段有异常值，所以我用 pandas clip方法处理它们。其次，由于我的通量特征范围太广，我也做了一些单位转换。当我收集数据时，通量特征采用纳马吉单位，因此我将它们转换为扬斯基单位(光谱通量密度单位)，1 纳马吉= 3.631 * 10^-6 扬斯基。此外，我做了一个对数转换，以减少红移特性的离群值的影响。
在这些操作之后，我检查了我的特征来进行提取。在这种情况下，我受益于频谱特性来创建新的特性。嗯，有一个特征叫做颜色指数，它定义了天体的颜色。将这个特性添加到我的数据集中太简单了，因为它是由两个光谱范围之间的差异定义的。
# Colour Indexes-difference between the two spectrum range
df1['color_u_g'] = df1['u'] - df1['g']
df1['color_g_r'] = df1['g'] - df1['r']
df1['color_r_i'] = df1['r'] - df1['i']
df1['color_i_z'] = df1['i'] - df1['z']
因此，在简单的四行代码之后，我设法向我的数据集添加了四个新特性。最后一步，我为将要创建的分类模型编码了目标变量。
步骤 4:分类模型
我从探索基本模型开始这一步:KNN、逻辑回归、朴素贝叶斯、线性 SVC 和决策树。在这些模型初始化之后，我开始定义集合模型:
- Bagging 算法:随机森林、额外树和 Bagging 分类器
- 增强算法:AdaBoost 和 GradientBoosting
- 投票分类器:软和硬
我的方法是，在运行完本节中的所有模型后，选择最佳模型进行优化。因此，我用默认参数运行了所有的模型，以查看结果。
这是我的分类模型的结果。我还在表中添加了测试准确度分数，以确保我的模型中没有过度拟合。可以看出，我定义了所有众所周知的算法来为这个项目的问题选择最合适的模型。
我必须明确指出，现实世界中没有最好的模型。正如乔治 E.P 博克斯曾经说过的:“所有的模型都是错的，但有些是有用的。”你只需要找到对你的问题最有用的模型&数据。
随机森林-特征重要性表:前七个特征
嗯，Bagging 分类器模型是我选择用于进一步工作的模型，因为测试准确度分数。有了 99.38%的准确率，它似乎是我的项目的最佳模型。
第五步:改进模型
我跳到了模型评估之后的优化部分。为此，我决定使用GridSearch。
#specify the parameters to be tested
n_est = [80, 100, 120, 140]
max_features_opt = [0.93, 0.95, 0.97]param_grid = dict(n_estimators = n_est, max_features=max_features_opt)
我们可以在确定将由GridSearchCV测试的参数后拟合模型。请注意，GridSearchCV本身包含了交叉验证，所以我也必须指定KFold的值。当拟合过程完成时，我可以检查最佳估计值。
kf=KFold(n_splits=10, shuffle=True, random_state=76)bag_grid = GridSearchCV(bag, param_grid, cv = kf, scoring='accuracy', n_jobs=-1)
bag_grid.fit(X_train, y_train)
并且，根据我从GridSearch得到的结果，我重新定义了 Bagging 分类器模型。
bag_opt = BaggingClassifier(base_estimator=dtree, n_estimators=120, max_features=0.93, bootstrap=True, random_state=seed, n_jobs = -1)bag_opt_acc = round(cross_val_score(bag_opt, X_train, y_train, cv=kf).mean())bag_opt_std = round(cross_val_score(bag_opt, X_train, y_train, cv=kf).std())
第六步:结果
在我的最后一步，我进行了保持测试，以查看优化的 Bagging 模型的准确性。我从优化后的模型中得到的结果是 99.44%，因此我实现了大约 0.06%的提高。这不是很多，但我的模型有一个很好的准确性评分。
混淆矩阵
最终结论:
- 从特征重要性表中可以看出，红移和颜色索引是我的分类问题中最有价值的特征。
- 我得到的最好的结果来自集合模型。在这个项目中，朴素贝叶斯和 KNN 模型的精度值相对较小。
好了，暂时就这些了。下一篇文章再见！
另外，如果你想了解更多，也可以看看我的 Github 简介！
多重测量分类——用更多证据建立信心
基于朴素贝叶斯假设的贝叶斯方法
如果您熟悉分类问题，那么您可能对训练模型的整个过程并不陌生:分割数据、训练模型、使用 ROC 分析调整模型，最后，将模型发布到现实世界中为您做出预测…
如果有超过 1 个数据点来自同一个对象，而你的分类器给你的结果是混合的，该怎么办？或者，即使你的分类器给你一致的结果，你应该对结果有多少信心，因为你的分类器不是 100%准确的(它从来不是，也永远不会是)？
例如，如果您正在构建一个准确率为 85%的 cat 分类器应用程序。一个用户刚刚上传了同一只猫的 5 张照片。
或者你正在为一个时间序列建立一个信号检测分类器。一些异常事件可能偶尔出现，如果不是连续出现的话。
当我们手中有越来越多的数据时，我们如何利用这些测量数据并建立信心？
在此之前，我们需要先回顾一些基础知识
概率链规则
让我们从两个变量 A 和 b 开始。贝叶斯定理指出
它可以简单地用文氏图表示出来。
然后我们可以再添加一个事件，事件 C:
有了这个模式，我们可以将公式推广到 n 个事件:
朴素贝叶斯
假设我们要构建一个分类器
我们可以用链式法则展开右边的分子
朴素贝叶斯假设条件独立性
有了朴素贝叶斯假设，我们就有了继续前进所需的东西。
利用多个证据做出综合决策
假设我们有 n 个测量值，分类器的输出标记为
我们试图回答的是给定 n 测量值，真实类的概率等于 1。即
假设在 n 个测量值中，我们的分类器预测其中 n0 个是 0，n1 个是 1。这给了我们最后一个表达式:
注意，这里出现的所有术语都可以从 ROC 分析中检索到，因此我们可以将这个公式集成到我们现有的监督学习过程中。
例子
让我们在公式中加入一些数字，看看它在实际中是如何工作的。以下是数字:
并且聚集预测相对于测量数量的曲线如下所示:
真类 y=0
真类 y=1
您可以看到，聚合预测对测量结果建立了信心，并最终收敛到正确的预测。
另一个观察结果是，只有一个度量时的预测不如 ROC 度量。这是因为我们考虑了 P(y=0)/P(y=1)的比值。这取决于你的应用来证明这个定量的估计是否准确。然而，当测量的数量增加时，这个比率的影响变小，因为其余的项呈指数增长。
PyCaret 分类:一个更好的机器学习库
用 PyCaret 解决分类任务——比你想象的要简单。
几天前，我已经介绍了 PyCaret 库的基础知识，以及如何使用它来处理回归任务。如果你是新来的， PyCaret 是一个低代码的机器学习库，可以为你做一切事情——从型号选择到部署。阅读前两篇文章不是先决条件，但是如果您以前没有使用过这个库，可以随意浏览它们。
奥斯曼·拉纳在 Unsplash 上拍摄的照片
分类问题是最常见的机器学习问题类型-信息是否是垃圾邮件，客户是否会离开，测试结果是肯定的还是否定的-仅举几个例子。出于这个原因，我们需要知道如何处理分类任务，以及如何轻松地这样做。
如果你更喜欢视频，或者只是想巩固你的知识，请随意观看我们关于这个主题的视频。源代码包括:
对于开发者来说， PyCaret 被认为比 Scikit-Learn 更好更友好。两者都很棒，不要误会我的意思，但是 PyCaret 将为您节省大量时间，否则这些时间将花费在型号选择和微调上。这是这份工作最无趣的部分。
本文假设您熟悉机器学习中的分类概念。您不必是专家，但前提是您知道如何使模型适合其他库中的数据。
这篇文章的结构如下:
- 数据集概述和清理
- 模型选择和培训
- 模型可视化和解释
- 预测和保存模型
- 结论
事不宜迟，我们开始吧！
数据集概述和清理
在我的大多数基于分类的文章中，我喜欢使用巨大的数据集。原因有很多，最明显的一个原因是它相当简单，但是对于数据清理和准备来说并不简单。
我们可以直接从 GitHub 加载到熊猫中:
data = pd.read_csv('https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv') data.head()
现在，我们可以继续进行数据清理了。我想做的是:
- 删除无关栏目(车票和乘客号
- 将性别列重新映射为 0 和 1
- 检查一个乘客是否有一个独特的头衔(如医生)或更普通的头衔(如先生、小姐。)—可以从名称列中提取
- 检查舱室信息是否已知——如果舱室栏的值不是 NaN
- 从开始的列创建虚拟变量— 3 个选项
- 用简单平均值填充年龄值
这是代码:
data.drop(['Ticket', 'PassengerId'], axis=1, inplace=True) gender_mapper = {'male': 0, 'female': 1}
data['Sex'].replace(gender_mapper, inplace=True) data['Title'] = data['Name'].apply(lambda x: x.split(',')[1].strip().split(' ')[0])
data['Title'] = [0 if x in ['Mr.', 'Miss.', 'Mrs.'] else 1 for x in data['Title']]
data = data.rename(columns={'Title': 'Title_Unusual'})
data.drop('Name', axis=1, inplace=True) data['Cabin_Known'] = [0 if str(x) == 'nan' else 1 for x in data['Cabin']]
data.drop('Cabin', axis=1, inplace=True) emb_dummies = pd.get_dummies(data['Embarked'], drop_first=True, prefix='Embarked')
data = pd.concat([data, emb_dummies], axis=1)
data.drop('Embarked', axis=1, inplace=True) data['Age'] = data['Age'].fillna(int(data['Age'].mean()))
我鼓励你只是复制代码，因为很容易出现拼写错误，而且你不是来练习数据准备的。数据集现在看起来是这样的:
这个看起来好多了。我们还可以做一些事情，但是今天就到此为止，继续建模吧。
模型选择和培训
首先，让我们从 PyCaret 库中导入分类模块，并执行一个基本设置:
from pycaret.classification import * clf = setup(data, target='Survived', session_id=42)
我已经将随机种子设置为 42，因此您可以重现结果。
几秒钟后，您会在屏幕上看到一条成功消息，旁边有一个表格，显示您的数据信息。如果你愿意，可以通读一遍。接下来，我们将比较各种机器学习模型的性能，看看哪种模型总体上做得最好:
compare_models()
是的，就像函数调用一样简单。执行时间从几秒钟到一分钟不等，因为几个算法都经过交叉验证训练。完成后，您应该会看到下表:
看起来光梯度增强方法总体上做得最好，所以我们可以用它来创建我们的模型:
model = create_model('lightgbm')
您可以通过 tune_model() 函数自由地执行额外的超参数调优，但是它并没有提高我的性能。
我们将在下一节进行一些可视化和解释。
模型可视化和解释
首先，让我们看看 plot_model() 函数提供了什么:
plot_model(model)
ROC(受试者操作特征)曲线下的面积告诉我们该模型在区分类别方面有多好——预测存活为存活，预测死亡为死亡。
如果这仍然不能像你希望的那样很好地解释，下面是绘制混淆矩阵的方法:
plot_model(model, 'confusion_matrix')
如果我们考虑到建造它的容易程度，这个模型实际上是相当不错的。接下来，让我们用 SHAP 值来解释我们的模型。
SHAP，或*沙普利附加解释，*是一种解释机器学习模型输出的方式。通过绘制每个样本的每个特征的 SHAP 值，我们可以使用它来查看哪些特征最重要。
太好了！现在让我们对测试集进行最终评估，并将模型保存到一个文件中。
预测和保存模型
一旦我们对模型的表现感到满意，我们就可以在测试集(以前看不到的数据)上对它进行评估:
predictions = predict_model(model)
当我们调用本文开头的 setup() 函数时， PyCaret 以 70:30 的比例执行了训练/测试拆分。当然，这个比例是可以改变的，但是我对默认值很满意。
测试集上的结果有点糟糕，但这是意料之中的。在将模型保存到文件之前，我们需要完成它:
finalize_model(model)
现在可以保存模型了:
save_model(model, 'titanic_lgbm')
模型现在保存在笔记本所在的文件夹中。要在以后加载它，您可以使用 load_model() 函数，并将文件路径作为参数。
结论
我希望您已经跟上了，在数据准备上花了更多的时间，并最终得到了一个更好的模型。PyCaret 确实为我们做了很多事情，所以我们可以把时间花在更重要的事情上。
还有更多的东西需要探索，而且很快就会到来。感谢阅读。
加入我的私人邮件列表，获取更多有用的见解。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
[## 通过我的推荐链接加入 Medium-Dario rade ci
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@radecicdario/membership)
原载于 2020 年 7 月 18 日 https://betterdatascience.com**T21。
Python 中的随机森林分类
随机森林分类模型
随机森林算法是一种机器学习方法，可用于监督学习任务，如分类和回归。该算法通过构建一组在随机特征子集上训练的决策树来工作。在分类的情况下，随机森林模型的输出是决策树中预测类的模式。在本帖中，我们将讨论如何在 python 中为分类任务构建随机森林模型。
我们开始吧！
随机森林分类
对于我们的分类任务，我们将使用蘑菇分类数据集，可以在这里找到。我们将对一个二元目标进行预测，该目标指定蘑菇是有毒的还是可食用的。
首先，让我们导入 pandas 库并将我们的数据读入数据框:
import pandas as pd
df = pd.read_csv("mushrooms.csv")
让我们打印数据框的形状:
print("Shape: ", df.shape)
接下来，让我们打印数据框中的列:
print(df.columns)
现在让我们也来看看前五行的数据。head()'方法:
print(df.head())
属性信息如下
我们将预测蘑菇的类别，其中可能的类别值为“e”表示可食用,“p”表示有毒。接下来我们将把每一列转换成机器可读的分类变量:
df_cat = pd.DataFrame()
for i in list(df.columns):
df_cat['{}_cat'.format(i)] = df[i].astype('category').copy()
df_cat['{}_cat'.format(i)] = df_cat['{}_cat'.format(i)].cat.codes
让我们打印结果数据框的前五行:
print(df_cat.head())
接下来，让我们定义我们的功能和目标:
X = df_cat.drop('class_cat', axis = 1)
y = df_cat['class_cat']
现在让我们从“sklearn”导入随机森林分类器:
from sklearn.ensemble import RandomForestClassifier
接下来，我们从‘sk learn’中的型号选择模块导入‘KFold’。我们将“折叠”以验证我们的模型。此外，我们将使用 f1 分数作为我们的准确度指标，它是准确度和召回率的调和平均值。让我们也用两次分割初始化“KFold”对象。最后，我们将初始化一个列表，我们将使用它来附加我们的 f1 分数:
from sklearn.model_selection import KFold
kf = KFold(n_splits=2, random_state = 42)
results = []
接下来，让我们迭代数据中的索引，并拆分数据用于训练和测试:
for train_index, test_index in kf.split(X):
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
在 for-loop 中，我们将定义随机森林模型对象，适合不同的训练数据折叠，预测相应的测试数据折叠，评估每次测试运行的 f1 分数，并将 f1 分数附加到我们的“结果”列表中。我们的模型将使用 100 个估计器，对应于 100 个决策树:
for train_index, test_index in kf.split(X):
...
model = RandomForestClassifier(n_estimators = 100, random_state = 24)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
results.append(f1_score(y_test, y_pred))
最后，让我们打印模型的平均性能:
print("Accuracy: ", np.mean(results))
如果我们将拆分数量增加到 5，则我们有:
kf = KFold(n_splits=3)
...
print("Accuracy: ", np.mean(results))
我就讲到这里，但是我鼓励你自己动手处理数据和编写代码。
结论
总之，在这篇文章中，我们讨论了如何用 python 训练一个随机森林分类模型。我们展示了如何将分类特征值转换成机器可读的分类值。此外，我们还展示了如何分割用于训练和测试的数据，初始化我们的随机森林模型对象，使其适合我们的训练数据，以及测量我们的模型的性能。我希望你觉得这篇文章有用/有趣。这篇文章中的代码可以在 GitHub 上找到。感谢您的阅读！
分类器校准
分类任务模型校准的原因、时间和方式。
Christophe Hautier 在 Unsplash 上拍摄的照片
当处理分类问题时，仅收集测试集上的预测是远远不够的；我们通常会带着某种程度的自信来赞美他们。为此，我们利用关联概率，即由分类器计算的可能性，它指定了每个样本的类别。但这总是反映现实吗？如果不是，我们怎么知道？
学习率是我每周给那些对 AI 和 MLOps 世界好奇的人发的简讯。你会在每周五收到我关于最新人工智能新闻、研究、回购和书籍的更新和想法。在这里订阅！
介绍
假设我们有两个二元分类器；型号A和型号B。模型A的每一次预测都有 85%的准确率和 0.86 的置信度。另一方面，模型B也有 85%的准确性，但对其每个预测的置信度为 0.99。你觉得哪个型号比较好？
在这个故事中，我会试着让你相信A模式更好。模型A认为自己在 86%的时间里都是精确的，事实上，差不多就是这样。相反，model B对自己的预测过于自信。这个玩具示例展示了概率和模型校准背后的直觉。
模型校准指的是这样一个过程，其中我们采用一个已经训练好的模型，并应用一个后处理操作，这改进了它的概率估计。因此，如果我们以 0.85 的概率检查估计为阳性的样本，我们预计其中 85%实际上是阳性的。
从形式上来说，如果对于任何概率值
p，一个类的预测有信心p在 90%的时间里是正确的100*p，那么这个模型就是完美校准的。
现在，因为如果你试图将一幅图像可视化并绘制出p的每一个值，那么在从0到1的时间间隔内，一幅图像就抵得上千言万语，所以我们期望在计算出的概率和阳性分数之间得到一个完美的线性关系。
校准完美的分类器
在接下来的章节中，我们将了解校准分类器的原因、时间和方法。
为什么模型校准很重要？
只有当您关心模型计算的概率时，模型校准才是重要的。例如，假设您正在构建一个推荐引擎，它根据用户偏好对产品进行排序。如果您的模型估计用户u将以 0.9 的概率购买产品a，以 0.7 的概率购买商品b，那么您可以先提供产品a。不需要校准那个模型。
然而，如果您正在构建一个计算一个人生病的概率的关键任务应用程序，那么实际的概率值是非常重要的。例如，如果你的模型对一个特定的病人不那么有信心，人类医生当然应该知道这一点并采取相应的行动。
模型校准还有其他有用的情况:
- *调试:*我们想知道什么时候我们的模型是高置信度错误的，或者把低概率分配给正确的类
- *集合:*如果我们想要组合许多概率模型，拥有准确的预测是很重要的
如何检查你的模型
到目前为止，我们已经了解了什么是模型校准，以及为什么它在某些情况下很重要。但是我们如何检查我们的分类器是否被校准了呢？
最好的方法是用我们自己的眼睛去看。在这个实验中，我们使用 scikit-learn 提供的“make_classification”辅助方法创建了一个用于分类的随机数据集。
接下来，我们实例化两个分类器进行比较；一个简单的逻辑回归模型和一个由 scikit-learn 提供的支持向量机实现。
最后，我们将分类器拟合到我们的训练数据，并计算我们对测试数据集的预测。特别是对于 SVM，要获得正类的概率，我们需要知道决策函数如何分离测试样本，并将结果归一化为介于“0”和“1”之间。
现在让我们为两个分类器绘制Kernel Density Estimation。
逻辑回归 Vs SVM KDE 图
正如我们所料，我们从逻辑回归得到的结果是从0扩散到1，而 SVM 预测正好是0或1。接下来，让我们检查两个二元分类器的 AUC-ROC 曲线，但是这次使用我们为 SVM 计算的概率。
逻辑回归与 SVM 曲线
我们可以看到，SVM 在这个数据集上几乎是完美的。但是精度和校准完全是两码事。我们可以有一个完全精确的模型，根本没有校准，另一方面，一个不比随机模型好的模型，尽管如此，也是完全校准的。那么，我们如何检查呢？
第一步是获取所有预测并将它们分组到箱中。我们将根据模型做出的概率估计对它们进行分组。接下来，我们计算每个箱的阳性分数，最后计算每个箱的平均置信度，这就是属于该箱的样本的概率估计的平均值。如果我们将平均值与每个箱中阳性部分相对照，我们就得到可靠性图。我们希望该图类似于我们在开始时看到的线性图。
为了绘制每个分类器的校准曲线，我们定义了如下所示的效用函数。
我们现在准备绘制每个模型的校准曲线。让我们从逻辑回归开始。
逻辑回归的校准图
看起来相当不错。我们为 SVM 做同样的事情。
SVM 校准图
很明显，SVM 模型远未校准。当它预测样本不属于正类时，我们可以说它是信心不足，否则就是过于自信。那么，我们该如何解决这个问题呢？
校准模型
校准机器学习模型的两种最流行的方法是isotonic和Platt's方法。
Scikit-learn通过CalibratedClassifierCV类提供校准模型的基本估计器。对于这个例子，我们将使用Platt's方法，这相当于将类的构造函数中的method参数设置为sigmoid。如果你想使用isotonic方法，你可以传递它。
校准的 SVM 分类器
SVM 分类器的结果令人印象深刻地不同。现在我们有一个校准的 SVM 分类器。请注意，如果您在 SVM 分类器上调用predict_proba方法，结果已经通过Platt's方法进行了校准(参见此处的)。你可以自己试试。
此外，请记住，校准后模型的准确性可能会降低。例如，AUC-ROC 曲线现在是 0.963。因此，我们可以看到，在某些情况下，我们可能需要在精度和校准之间进行权衡。您也可以随时检查其他指标(如精确度、召回率、F1 分数等。).
校准后的 AUC-ROC 曲线
结论
在这个故事中，我们研究了什么是模型校准，为什么以及何时使用它，如何检查您的分类器是否校准，以及如果没有校准，如何潜在地修复它。
最后，我想给出一个经验法则，关于是否使用普氏标度的等张回归。等张回归不做 sigmoid 假设，因此，它可能更适合大量情况。另一方面，它更容易过度拟合。因此，如果我们有一个小数据集， Platt 的缩放可能会更好。
我叫 Dimitris Poulopoulos，是希腊比雷埃夫斯大学*BigDataStack的机器学习研究员和博士©。我曾为欧洲委员会、欧盟统计局、国际货币基金组织、欧洲中央银行、经合组织和宜家等主要客户设计和实施人工智能和软件解决方案。如果你有兴趣看更多关于机器学习、深度学习、数据科学的帖子，在 twitter 上关注我 中 、LinkedIn或@ james2pl**。***
使用预先训练的 CNN 模型对任何对象进行分类
现实世界中的 DS
使用预训练的 Inception v3 卷积神经网络模型的大规模图像分类
列宁·艾斯特拉达在 Unsplash 上的照片
今天，我们有了超级有效的技术转移学习，我们可以使用由谷歌人工智能预先训练的模型来对计算机视觉世界中任何已分类视觉对象的图像进行分类。
迁移学习是一种利用预训练神经网络的机器学习方法。这里，名为 Inception-v3 的图像识别模型由两部分组成:
- 特征提取部分采用卷积神经网络。
- 分类具有全连接和 softmax 层的零件。
Inception-v3 是一个预训练的卷积神经网络模型，深度为 48 层。
这是一个已经在来自 ImageNet 数据库的 100 多万张图像上训练过的网络版本。这是谷歌的第三版 Inception CNN 模型，最初是在 ImageNet 识别挑战期间发起的。
这个预先训练好的网络可以将图像分为 1000 个对象类别，例如键盘、鼠标、铅笔和许多动物。因此，该网络已经学习了各种图像的丰富特征表示。网络的图像输入大小为 299 x 299。该模型在第一部分从输入图像中提取一般特征，并在第二部分基于这些特征对它们进行分类。
《盗梦空间 3 版》示意图——谷歌人工智能
Inception v3 是一个广泛使用的图像识别模型，已被证明在 ImageNet 数据集上达到超过 78.1%的准确率，在前 5 名结果中达到大约 93.9%的准确率。该模型是过去几年多名研究人员提出的许多想法的结晶。它基于 Szegedy 等人的原始论文:“重新思考计算机视觉的初始架构”。艾尔。
更多关于初始架构的信息可以在这里找到。
在迁移学习中，当您构建一个新模型来对原始数据集进行分类时，您可以重复使用特征提取部分，并使用数据集重新训练分类部分。由于不需要训练特征提取部分(这是模型中最复杂的部分)，所以可以用更少的计算资源和训练时间来训练模型。
在本文中，我们将仅仅使用 Inception v3 模型来预测一些图像，并获取相同图像的前 5 个预测类。我们开始吧。
我们用的是 Tensorflow v2.x
输入数据
import os
import numpy as np
from PIL import Image
from imageio import imread
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import tf_slim as slim
from tf_slim.nets import inception
import tf_slim as slim
import cv2
import matplotlib.pyplot as plt
数据加载
用默认文件位置和各自的值设置所有初始变量。
ckpt_path = "/kaggle/input/inception_v3.ckpt"
images_path = "/kaggle/input/animals/*"
img_width = 299
img_height = 299
batch_size = 16
batch_shape = [batch_size, img_height, img_width, 3]
num_classes = 1001
predict_output = []
class_names_path = "/kaggle/input/imagenet_class_names.txt"
with open(class_names_path) as f:
class_names = f.readlines()
创建 Inception v3 模型
X = tf.placeholder(tf.float32, shape=batch_shape)
with slim.arg_scope(inception.inception_v3_arg_scope()):
logits, end_points = inception.inception_v3(
X, num_classes=num_classes, is_training=False
)
predictions = end_points["Predictions"]
saver = tf.train.Saver(slim.get_model_variables())
定义用于加载图像和调整大小的函数，以便以 RGB 模式发送到模型进行评估。
def load_images(input_dir):
global batch_shape
images = np.zeros(batch_shape)
filenames = []
idx = 0
batch_size = batch_shape[0]
files = tf.gfile.Glob(input_dir)[:20]
files.sort()
for filepath **in** files:
with tf.gfile.Open(filepath, "rb") as f:
imgRaw = np.array(Image.fromarray(imread(f, as_gray=False, pilmode="RGB")).resize((299, 299))).astype(np.float) / 255.0
images[idx, :, :, :] = imgRaw * 2.0 - 1.0
filenames.append(os.path.basename(filepath))
idx += 1
if idx == batch_size:
yield filenames, images
filenames = []
images = np.zeros(batch_shape)
idx = 0
if idx > 0:
yield filenames, images
加载预训练模型
session_creator = tf.train.ChiefSessionCreator(
scaffold=tf.train.Scaffold(saver=saver),
checkpoint_filename_with_path=ckpt_path,
master='')
使用模型对图像进行分类
with tf.train.MonitoredSession(session_creator=session_creator) as sess:
for filenames, images **in** load_images(images_path):
labels = sess.run(predictions, feed_dict={X: images})
for filename, label, image **in** zip(filenames, labels, images):
predict_output.append([filename, label, image])
预言
我们将使用来自 kaggle 的动物-10 数据集的一些图像来声明模型预测。
for x **in** predict_output:
out_list = list(x[1])
topPredict = sorted(range(len(out_list)), key=lambda i: out_list[i], reverse=True)[:5]
plt.imshow((((x[2]+1)/2)*255).astype(int))
plt.show()
print("Filename:",x[0])
print("Displaying the top 5 Predictions for above image:")
for p **in** topPredict:
print(class_names[p-1].strip())
最后，所有的类都被准确地分类了，我们还可以看到模型预测的前 5 个相似的类都非常好和精确。
探索和分析贷款违约背后的驱动因素，即，使贷款审批流程风险…
towardsdatascience.com](/insightful-loan-default-analysis-in-lending-credit-risk-model-b16bbfc94a2f)
用谷歌自动分类狗和猫
让我们使用狗与猫的 Kaggle 数据集来测试 GCP 汽车
https://MC . ai/build-a-machine-learning-model-on-cloud-using-Google-automl/
这是我与谷歌 Auto ML 的第一个项目，我非常好奇想尝试一下，因为我在 Medium 上看到了很多关于它的有趣帖子。例如，我建议你阅读这篇来自 Sriram Gopal 的非常有趣的帖子，他解释了使用 Google AutoML 进行类似项目的所有步骤
我决定使用来自 Kaggle 的 狗对猫 数据集。目标是分类图像是否包含狗或猫
让我们从使用 CRISP-DM 流程(数据挖掘的跨行业流程)开始:
- 业务理解
- 数据理解
- 准备数据
- 数据建模
- 评估结果
- 展开
业务理解
图像分类是当今非常常见的任务，它包括将图像和一些类别作为输入，并输出输入图像属于一个或多个给定类别的概率
一部分来自我想尝试的项目的主要目标 Google Auto ML
数据理解
Kaggle 提供的数据:
- 测试:包含 12500 张猫狗图片的文件夹，用作测试数据集
- train :包含 25000 张猫狗图片的文件夹，图片名称中带有标签，即 dog.0.jpg cat.0.jpg
- sample submission . CSV:CSV 文件，参赛时作为提交参考
这些图像是 RGB 的，并且具有不同的尺寸
Kaggle 的数据集结构与 Google AutoML 的数据集结构非常不同，Google AutoML 的数据集结构是每个标签一个文件夹，里面有图像
准备数据和数据建模
如前所述，Kaggle 已经完成了图像的标记，模型的选择和调整将由 Google AutoML Vision 完成
要使用谷歌自动视觉:
- 创建一个谷歌云平台账户
- 创建新项目
- 启用 AutoML API
- 创建服务帐户
- 创建一个桶
- 创建. csv 文件来映射数据集的图像
- 将图像上传到桶中
- 创建数据集并上传图像
- 训练模型
- 部署模型
因此，我们只需以预期的格式向 Google AutoML Vision 提供数据。要让 Google AutoML Vision 使用数据:
- 将 Kaggle train 文件夹中的图像分离到狗和猫文件夹中
- 将狗和猫文件夹上传到谷歌云存储的桶中
- 创建一个 csv 文件来映射桶中数据集的图像
数据集已经在训练、验证和测试数据集中被自动拆分。也可以在映射 csv 文件中为每个图像指定训练、验证、测试或未分配，以更改用于训练、验证和测试的图像数量之间的比率
标签统计
模型的训练可能需要几个小时(您可以选择使用多少个节点小时),当它完成时，google 将发送一封电子邮件
评估结果
在评估页面中，我们可以看到模型性能
GCP 评估模型
可以使用滑块改变置信度阈值
我们也可以检查一下混淆矩阵(顺便说一句，我建议你读一读这篇来自blog.exsilio.com的帖子
https://blog . ex silio . com/all/accuracy-Precision-recall-f1-score-interpretation-of-performance-measures/#:~:text = Precision %20% 2D % 20 Precision % 20 is % 20 比率% 20 总计% 20 预测% 20 正面% 20 观察值。&text = F1 %20 score % 20% 2D % 20 F1 % 20 score % 20 is，以及% 20false % 20negatives %进入% 20 帐户。
真阳性(TP) :这些是正确预测的阳性
真阴性(TN) :这些是正确预测的阴性
假阳性和假阴性，这些值出现在你的实际类与预测类相矛盾的时候。
【FP】:实际类为负，预测类为正
假阴性(FN) :实际类为正，预测类为负
精度 = (TP + TN) / (TP + FP + FN + TN)
精度 = TP / (TP + FP)
回忆 = TP / (TP + FN)
F1 得分 = 2*(召回率*精确度)/(召回率+精确度)
在我们的案例中:
TP = 1240
TN = 1249
FP = 1
FN = 10
精度=(1240+1249)/(1240+1+10+1249)= 0.995
精度= 1240 / (1240 + 1) = 0.999
召回= 1240 / (1240 + 10) = 0.992
F1
展开
培训结束后，我们可以在 GCP 部署并使用该模型
一个 dash 应用程序已经被开发为用户界面:可以上传要分类的图像。当没有上传图像时，应用程序显示训练数据集的概览
Dash web 应用程序主页
当提供图像并按下分类按钮时，应用程序显示分类
图像分类
在所示的例子中，我在谷歌图片上搜索了一只狗，并用它作为输入来检查我的分类器的输出
有趣的事实
我试图对我的个人资料图片进行分类，显然我是一只得分为 0.89 的狗
我的个人资料图片分类
**注意:**代码可以在这个 github 仓库中找到
新冠肺炎增长数据的模式分类
不同国家/地区每日确诊病例的模式
全球冠状病毒病例数据的探索性数据分析
2 月 2 日，我启动了一个网络仪表板,用于跟踪最近冠状病毒(新冠肺炎)爆发的传播，它提供了全球确诊、康复和死亡病例的实时视图。
冠状病毒新冠肺炎监测提供冠状病毒全球传播的最新数据。
dash-coronavirus-2020.herokuapp.com](https://dash-coronavirus-2020.herokuapp.com/)
到目前为止，它已经吸引了超过 17，000 名活跃用户，并在社交媒体上被分享了近 3，500 次。我真的很高兴我能贡献出我的技能来帮助处于全球危机中的人们，特别要感谢那些支持这个网络仪表板运行的人。
回到仪表板本身，很明显，它上面显示的信息是为了有效和容易理解而设计的。它们总是及时更新，并且只提供有限数量的历史数据(即区域范围的历史数据)。这使得用户能够获得他们所关心区域的最新状态。
然而，除了显示在仪表板上的实时数据之外，还可以从这些数据中提取更多信息。今天，我将与你们分享从迄今收集的所有数据中提炼出的一些见解。这可能有助于提高公众意识，进一步促进预先准备和减缓传播。
像往常一样，如果你想练习代码，可以从我的 Github 访问笔记本。
我们预计每日确诊病例的增量模式是什么？
在我们讨论个别模式之前，最好用一幅最近流行的漫画(图 1)来解释我们期望实现什么样的模式来遏制病毒并减缓其传播。
图 1 |三相和平曲线止价差改编自https://twitter.com/SiouxsieW
流行病事件发展过程中的病例数可以用流行病曲线来说明(图 1，左图)，它包括三个阶段。目前，大多数国家正处于第一阶段，每天都有越来越多的病例得到确认。
我们希望看到的理想情况是放慢第一阶段的速度，使曲线变平，以便我们的卫生系统有足够的时间做好准备，最重要的是，有足够的资源应对每一个脆弱的病例(图 1，中图)。为了达到这种情况，需要采取严格的措施，包括旅行限制、自我隔离、社会距离和个人卫生。
对于那些处于疫情最早期阶段的国家，还有另一个积极的选择，即通过迅速和积极主动地采取全面措施来阻止疫情蔓延(图 1，右图)。
不同国家/地区每日确诊病例的增量模式是什么？
考虑到这些，让我们看看不同国家/地区的个别疫情曲线。此处使用的数据是从 1 月 21 日至 3 月 14 日收集的。为了能够看出模式，只有那些确诊病例超过 50 例的国家/地区包括在本分析中。
如图 2 所示，截至 3 月 14 日，共有 49 个国家/地区出现 50 例以上确诊病例。当绘制每日增量病例数与日期的关系图时(图 2)，我们可以清楚地看到不同的模式。例如，根据流行曲线的定义，mainland China(图 2，右上角)已经处于第三阶段，而大多数其他地区仍处于第一或第二阶段。
图 2 |每日增量病例数与日期的对比
我们可以对增量模式进行分类吗？
然而，这些曲线的视觉区分是相当困难的。最好将这些曲线分类成簇，其中相似的曲线归为同一组。在这里，我将 P 原则 C o 坐标 A 分析( PCoA )和 k 均值聚类结合起来，在二维空间上绘制国家/地区增量模式的相似性，并对它们进行分组。简而言之，在二维排序中，相邻的圆圈(即国家/地区)应该具有相似的生长模式，彼此远离的圆圈几乎没有共同的模式。
**注意！**由于我们只对模式感兴趣，数据大小的影响应最小化，例如，mainland China 的每日增量数字比许多其他国家/地区高几个数量级。我们不希望这些差异包含在我们的分析中。这里的解决方案是首先将数据转换为平方根，然后将它们归一化为 0 到 1 之间的数字。这样做，我们只在计算不同国家/地区之间的相似性时赶上模式的变化。
图 3 |不同国家/地区增长模式的排序
正如我们从排序中看到的(图 3)，有 5 组用不同的颜色表示(圆圈大小表示确诊病例数)。Mainland China 形成了自己的集群(深绿色)。阿联酋、泰国、台湾、韩国、香港、日本和新加坡形成了另一个集群(浅绿色)。伊朗与伊拉克、马来西亚、巴林、印度、越南和科威特(蓝色)同组。大多数欧洲国家连同美国、加拿大和澳大利亚形成了一个大的集群(红色)。最后，芬兰、菲律宾、印度尼西亚、爱沙尼亚和卡塔尔被归为同一组。
通过这些分类，我们现在可以从曲线矩阵(图 4)中获得更多信息，例如哪些国家/地区具有相似的增长模式，以及它们处于哪个阶段。
根据流行病曲线的定义，Mainland China 现在已经处于第三阶段。这是一个令人鼓舞的迹象。然而，我们应该知道，这些都是建立在人们巨大牺牲的基础上的，通过在今年的节日期间(即中国新年)暂停整个国家，呆在家里，尽量减少户外活动，避免大型集会，如果外出戴口罩。此外，他们在几周内建立了两所新医院，并向武汉派遣了大约 43000 名医务人员。
图 4 |每日增量病例数与分类日期的对比
留给我们考虑的问题是，当疫情在许多其他国家/地区爆发时，我们是否有如此规模的资源来做中国所做的事情，或者我们是否应该迅速和积极主动地采取行动来减缓甚至阻止疫情的到来。
这些把我们带到第二个集群(浅绿色)。这些地区都在很早的时候记录了第一批确诊病例，然而，保持了相对平坦的曲线。这可能归功于他们及时部署了旨在遏制冠状病毒传播的深思熟虑的措施。这再次突出了迅速和主动采取行动的必要性。此外，这也意味着，如果我们坚持遵守所有措施，情况应该会有所改善。
你可能会注意到，韩国也属于这一类。这主要是因为曲线后来出现的高峰是由所谓的患者 31 触发的，他是一个超级传播者，并将它传递给了成千上万的其他人。幸运的是，韩国几乎已经度过了高峰期，正在回到一个合理的水平。
蓝色、黄色和红色组中的国家都处于第一阶段，但曲线风格略有不同。具体来说，蓝色组的特点是早期平坦曲线和晚期爬坡曲线的混合(图 5)。
图 5 |马来西亚和伊朗的累积病例
然而，黄组国家大多拥有确诊病例数的突然增加(图 6)，这可能表明控制失败。
图 6 |卡塔尔和芬兰的累积案例
红色组都是典型的指数增长曲线，是最不想要的情况。这些曲线可能表明在事情变得更糟之前，系统还没有准备好。
图 7 |西班牙和意大利的累积病例
向红色集团内的国家发出警报
如开始所述，分类只检查了生长模式，没有考虑规模。现在，让我们检查红组国家的案例数。
显然，并不是红色组中的每个国家都像意大利、西班牙或德国那样有高确诊病例数(图 8)。话虽如此，如果不采取认真的措施，这些数字肯定会成倍攀升，这进一步意味着本可预防的生命损失将是不可预防的。对这些国家的警告是现在就采取行动，否则就太晚了。
图 8 |截至 AEDT 时间 3 月 18 日的总病例数
“生活是我们所有选择的总和。”
阿尔伯特·加缪
数据源来自:
这是所有的乡亲。和往常一样，我欢迎反馈、建设性的批评以及听到关于您的数据科学项目的信息。可以通过 Linkedin 和我的网站找到我。
使用卷积神经网络对图像进行分类
从头开始建立一个 CNN 来分类图像
简介
你听说过计算机识别图像吗？嗯，这并不神秘，按照这篇代码文章来构建您自己的图像分类器。我们将从 CIFAR 数据集获取图像。然后将它发送到我们自己的神经网络中，在那里计算机识别各种事物，如颜色、大小、形状等。并根据我们提供的样本数据学习识别图像。然后我们将使用学习过的网络来预测新的输入图像是什么。
让我们开始吧！
什么是 CIFAR-10 数据集？
CIFAR-10 数据集由 10 类 60000 幅 32x32 彩色图像组成，每类 6000 幅图像。有 50000 个训练图像和 10000 个测试图像。
数据集分为五个训练批次和一个测试批次，每个批次有 10000 幅图像。测试批次包含从每个类别中随机选择的 1000 个图像。训练批次以随机顺序包含剩余的图像，但是一些训练批次可能包含来自一个类别的比来自另一个类别的更多的图像。在它们之间，训练批次正好包含来自每个类的 5000 个图像。
来源:https://www.cs.toronto.edu/~kriz/cifar.html
这些类是完全互斥的。汽车和卡车之间没有重叠。“汽车”包括轿车、越野车等诸如此类的东西。“卡车”仅包括大卡车。两者都不包括皮卡车。
在本文中，我们将使用 PyTorch 中的数据集。这里还有很多其他很棒的数据集。https://pytorch.org/docs/stable/torchvision/datasets.html
检查 GPU 计算能力
GPU 的并行计算能力将显著提高你的训练速度。请注意，CUDA 是由 NVIDIA 开发的，我们将在下面的代码中使用。
导入数据
在下面的代码中，我们从 torchvision 获取数据集。我已经指定了 20%的训练数据用于验证，以及 30 张图像的批量。我强烈建议您使用验证数据集，我们将在下面看到它如何帮助选择正确的网络配置。
在将图像传递给神经网络之前，我对图像进行了一些变换，比如水平翻转和 20°的随机旋转。对图像应用变换是非常有用的，因为这可以帮助你的网络学习和预测图像，即使它处于不同的方向、颜色、大小等。点击查看 torchvision 提供的各种变换。我们稍后将图像张量作为输入传递给我们的神经网络。
classes 数组包含数据集中的 10 个类。
查看训练数据的图像🔎
拉伸图像
从上面来自训练数据集的样本图像中，我们可以看到我们应用了 RandomRotation(20)的变换。
神经网络架构
我们的模型需要将 RGB 光谱(深度= 3)中的 32×32 像素图像作为输入，并将输出作为 10 个类别(飞机、汽车、鸟、猫、鹿、狗、青蛙、马、船、卡车)之一返回
我已经创建了如下所示的架构，第一个卷积层接受 32x32x3 图像张量的输入。第一层的输出是 32x32x16 张量，每一层之后我们可以看到深度增加。在某些网络架构中，您可能会在每个卷积层之间看到一个池层，以减小规模。尽管池层有助于减小大小，但它也会丢失一些数据。由于我们的输入图像很小，我在每 2 个卷积层后使用了池层。2x2 合并图层后，我们可以看到张量大小从 32x32 减小到 16x16。卷积层 3 和 4 的输入张量分别是 16×16×32 和 16×16×64。
我使用了 25%的压差。通过在训练过程中忽略神经元，Dropout 有助于防止过度拟合。我还创建了一个名为 weights_init_normal 的函数，用正态分布的权重初始化模型。您不需要这样做，但是在较大的模型中，这可以帮助训练和验证损失快速收敛。
作者图片
卷积层充当特征提取器。更多的卷积层有助于识别每幅图像中的细微事物。完全连接的层和输出层充当分类器。
定义损失函数和优化器
我选择了 Adam 优化器，点击这里查看其他优化器，包括 SGD。学习率设定为 0.001。
培训和验证⏳
我们调用带有各种参数的训练方法，如段数、模型、加载器等。我们将来自训练数据集(loaders[‘train’])的图像(数据)传递给模型。然后计算损失并进行反向传播，在此期间，我们根据损失更新权重。model.eval()通知所有层我们处于 eval 模式，因此批 norm 和 dropout 层将在 eval 模式下工作。
训练和验证损失计算为每个时期的平均值，然后打印出来，如下所示。如果在一个时期内验证损失小于以前，我们将模型保存到 model.pt 文件。
训练完成后，从 model.pt 文件中加载模型，该文件将具有所有历元中最小的验证损失。
从上面的输出中，我们可以看到模型在纪元 54 之后被保存。它的验证损失为 0.54
虽然我已经运行了当前模型 60 个历元，但在更早的时候，使用一组不同的超参数，我能够在 15 个历元内获得类似的性能。
策划培训和验证损失
绘制训练和验证损失图，我们可以看到它们在一个点上汇聚，然后开始远离。它显示了我们的模型在最后是如何过度拟合的，这被描述为训练损失的持续减少和验证损失的增加。好在我们创建了验证集来检查这个条件，并且在模型过度拟合之前保存了它；)
测试模型
这个函数类似于训练，但是这里我们通过测试数据集并计算损失。
从上面的输出中，我们可以看到模型在一些类中表现得更好，而在另一些类中表现得不那么好。
可视化少量测试结果
当前的输出显示了所有 20 张正确分类的图片，测试一下你的图片，找出一些错误分类的图片。
关于改进模型的想法
我们看到这个模型在一些课上表现不错，而在另一些课上表现不太好。花了大量的纪元来训练。在训练过程中，我们可以传递更多不太精确的类的图像，以便模型更好地学习。增加卷积层的数量以识别更多的特征，同时优化 dropout 和 epoch 以平衡过度拟合。
尝试调整以下内容，亲自看看性能有何不同，
- 学习率
- 世
- 拒绝传统社会的人
- 批量
- 添加/移除转换
- 添加/删除卷积层
- 更改优化器
我喜欢听你的建议/反馈！
将 400 万个 Reddit 帖子分类到 4k 个子编辑中:一个端到端的机器学习管道
应用多标签文本分类，用 fastText 和 FastAPI 构建一个数据产品。
具有数据工件、执行和 API 端点的端到端 ML 管道。
找到合适的 subreddit 来提交你的帖子可能会很棘手，尤其是对 reddit 的新手来说。有数以千计的具有重叠内容的活动子编辑。如果对人类来说这不是一件容易的事，我没想到对机器来说会更容易。目前，Reddit 用户可以在一个特殊的子编辑中请求合适的子编辑: r/findareddit 。
一位 Reddit 用户请求 subreddit 建议。
在这篇文章中，我分享了如何建立一个端到端的机器学习管道和一个为帖子建议子编辑的实际数据产品。你可以访问数据、代码、API 端点和用户界面，用你的 Reddit 帖子进行尝试。
从 4k 个子编辑中收集 400 万条 Reddit 帖子
我使用 Python Reddit API 包装器( PRAW )请求 5k 个最受欢迎的子编辑，但只得到 4k 个。对于每个帖子，我收集了截至 3 月 17 日的最新 1k 帖子的标题和内容。我把数据导出到一个 CSV 文件中，可以在 S3 下载。
来自 400 万条 Reddit 帖子的数据框架样本。
就数据质量而言，这个数据集远非完美。有些子帖子太笼统，有些帖子彼此非常相似，有些帖子在文本中没有足够的信息来知道它们应该贴在哪里。之前的方法选择了 1k 个子主题的子集，这些子主题在主题方面更加一致。虽然这种数据选择确实会使模型在测试分割中获得更高的分数，但它不一定对真实数据更有用，因为它会错过许多子数据。
众所周知，数据清理会对模型的性能产生很大的影响，数据科学家会花费高达 80%的时间来清理数据。作为一名数据科学家，我经常高估数据转换的影响。为了避免在早期的数据转换上花费太多时间，我更喜欢尽可能快地直接构建一个端到端的简单基线。一旦我有了第一个结果，我就可以运行版本控制的实验来观察每个转换的影响。端到端解决方案还允许您尽早获得最终用户的反馈。
使用 fastText 进行多标签文本分类
在上一篇文章中，我使用 fastText 为文本分类构建了一个通用的 ML 管道。我重用这些代码，在 Reddit 数据集上训练它，使用标题和自我文本作为特征，使用子编辑名称作为标签。在训练数据集中，每个帖子被分配到一个标签，但很自然地会将问题视为多标签问题。在多标签文本分类中，通过概率将每个帖子分配给每个子编辑。
由脸书发布的 fastText 是一个具有两层的神经网络。第一层训练单词向量，第二层训练分类器。正如原文中提到的，fastText 适用于大量标签。收集的数据集包含 3 亿个单词，足以用 Reddit 数据从头开始训练单词向量。最重要的是，fastText 为由两个参数控制的子词创建向量， minn 和 *maxn，*设置最小和最大字符跨度以将一个词拆分成子词。在 Reddit 上，打字错误是常见的，如果不使用子词，特定术语可能会超出词汇表。
机器学习流水线架构
机器学习管道由 5 个通过 Valohai 管道交换数据的执行组成。每个执行都是一个 Python CLI，你可以在 Github 上找到每个执行的代码，在上一篇文章中可以找到关于如何创建一个在云上运行的管道的更多细节。
具有数据工件、执行和 API 端点的端到端 ML 管道。
文本特征被连接，转换为小写，标点符号被删除。然后将数据分为训练(80%)、验证(10%)和测试(10%)。我将自动调优命令设置为在具有 16 个内核的云机器上运行 24 小时，以在验证数据集上找到最佳参数。最后，在所有数据上重新训练模型，并在测试数据集上报告最终指标。对于每次执行， Valohai 负责启动和停止具有适当环境、代码、数据和参数的云机器。
探索预测和指标
自动调优执行聪明地尝试了 9 个不同的参数集来决定一个最终的模型，该模型被训练了 100 个时期，具有 92 维的词向量、多达 3 个词的 n 元语法和 2 到 5 个字符的子词。这导致了 300 万单词的词汇量(包括子单词)和一个训练 7 小时、重 2 GB 的模型。
分类任务可以用经典的指标来评估，如精度、召回率和 f1 值。自动调优执行记录最佳参数，并在验证数据集中报告得分为 0.41 的 f1。
自动调优执行的日志。
在极端多标签文本分类任务中，通常还会报告度量 P@k(进行前 k 个预测时的精度)和 R@k(进行前 k 个预测时的召回)。下面，我们可以看到不同 k 值的测试数据集的精度和召回率。R@k 从进行一次预测(k=1)时的 0.4 变为进行二十次预测(k=20)时的 0.71。
比较不同 k 值的测试执行的度量
标签分类报告
自然，不同的子条目之间的度量也不同。通过子编辑来探究 f1 分数直方图以及预测概率(p@1)和 f1 分数之间的关系是很有趣的。我创建了一个 Google Colab 笔记本来制作基于 test_predictions.csv 的图表。
自然，f1 分数和 P@1(模型给出的第一次预测的概率)之间存在正相关。尽管如此，在测试数据集上，p@1 仍落后于 f1 得分。比如模型说第一个建议有 0.8 的概率，就要取为 0.5。该模型可能需要针对更多的时期进行训练，以更好地调整概率。
指标很重要，但它们不应该阻止你查看数据。相反，度量标准会告诉你应该往哪里看。例如，如果我们考虑 f1 值接近 1 的子网格，我们会发现一个很好的特性泄漏的例子。
在子编辑 r/wood_irl 和 r/anime_irl 的情况下，大多数帖子的标题是子编辑的名称，没有文本和图像。在 r/holdmyfries **，**中，大多数帖子以 HMF 开头，这一特征泄漏可能会阻止模型从其他文本特征中学习。看看表现最差的子编辑，我发现几个流行的子编辑不一定有主题连贯性，比如 r/AskReddit。主题方面最连贯的子主题具有平均 f1 分数，例如 r/MachineLearning 的 f1 分数为 0.4。
子编辑混淆矩阵
该模型不仅与用户分配的子编辑相矛盾，而且与标签空间相矛盾。如果你看看子编辑之间的混淆矩阵，你会发现子编辑有相似的主题。我上传了长格式的混淆矩阵到这个谷歌电子表格，所以你可以用它来找到类似的子编辑。例如，这里有 10 对经常被模型混淆的子网格。label 列指的是人的选择，label@1 列指的是第一个模型选择。
看看类似于 r/MachineLearning 的子编辑，它给出了一些关于为什么模型不总是能够预测人类选择的见解。通常有多种可能的选择。希望该模型仍然可以在数据中存在一些噪声的情况下进行学习，甚至在它以高概率预测不同的子网格时纠正人类的选择。
用 FastAPI 创建预测 API 端点
即使考虑到所有这些限制，R@5 为 0.6 的训练模型也是有用的。这意味着有三分之二的时间，前五个预测包括人类在测试数据集上选择的子集合。备选预测可以帮助用户发现新的子主题，并自己决定是否在那里发布。
为了用最新的帖子提交来测试模型，我使用 FastAPI 创建了一个 API 端点。FastAPI 是优步和微软的机器学习团队使用的 Python web 框架，因为它具有紧凑的代码、使用 Pydantic 的数据验证、自动文档编制以及 Starlette 带来的高性能。
api.py 中的代码足以声明特征和预测模型，将训练好的模型加载到内存中并创建预测端点。
在 Github 上完成 api.py。
将预测 API 端点部署到 Valohai
使用 Valohai 的部署特性，我在 valohai.yaml 配置文件中用 Docker 映像和服务器命令声明了一个端点。
在 Github 上完成 valohai.yaml。
通过 Valohai UI，我可以将端点链接到由之前的执行生成的模型。这都是受版本控制的，因此您可以 A/B 测试不同的版本，进行 canary 发布，并在出现问题时进行回滚。
您可以使用 curl 调用 API 端点，并在请求体上使用 text 特性发出 POST 请求。
curl -X POST "https://valohai.cloud/arimbr/reddit-fasttext/findareddit/production/predict?k=5" -d “{\”text\”:\”I’m wanting to learn the basics of growing food at home. All indoors as I don’t have a suitable yard. So things that can grow in a pot.\”}”
您应该得到这样的 JSON 响应。
{“predictions”:[{“label”:”IndoorGarden”,”probability”:0.33},{“label”:”gardening”,”probability”:0.06},{“label”:”plantclinic”,”probability”:0.04},{“label”:”IWantToLearn”,”probability”:0.03},{“label”:”homestead”,”probability”:0.03}]}
懒得开终端？我们掩护你。Valohai 团队精心制作了一个 UI 来与模型 进行交互。
下一步是什么？
我已经看到了几个方面的改进，使模型更加有用。例如，从用户可能不知道的不太流行的子编辑中收集数据。对于 Reddit 用例，报告的 R@5 的 0.6 分已经帮助用户发现新的子编辑。如果我们从测试数据集中删除包含图像的帖子，分数可能会高得多。在不同的业务案例中，该算法可用于以高 p@1 概率自动分类文档，并支持业务用户手动分类较难的案例。
在我看来，下一步将是监测模型的性能如何随着时间的推移而演变，因为用户在 Reddit 上发布的内容存在自然的概念漂移，并解决这一问题。在下面的文章中，我将收集最新的数据，比较模型度量，并构建一个 CI/CD 机器学习系统，以经常重新训练和发布新模型。
如果你有一个带有文本和标签的数据集，你可以按照这个 教程****对你的数据重新训练管道。您可以使用它来构建生产基准，以对市场中的产品进行分类，支持知识库中的票据或法律文档。
有用的链接
- S3: Reddit 发布数据集
- Github: ML 管道代码
- 谷歌电子表格:指标
- Google Colab: 探索
- 子编辑查找器 UI
最初发表于 https://www.valohai.com。
如何用逻辑回归模型对猫图片进行分类
为二元分类建立两层神经网络
1.介绍
当我全神贯注于学期考试或家务杂事时，我会发现自己总是被猫视频所吸引。更重要的是，猫用可爱的爪子做傻事所带来的快乐超过了拖延的罪恶感。我心想，为什么不把我最大的两个兴趣——猫和机器学习——结合起来，以更好地促进技术进步。因此，用 2 层神经网络(本质上是逻辑回归模型)对猫图像进行即兴分类。
本教程的重点是设计一个简单的逻辑回归算法，用神经网络的思维方式来区分猫图像和非猫图像。
这篇文章仅仅关注教程的抽象概念；要深入了解代码，请参考 Github 资源库这里的。该库还具有 L 层深度神经网络，其性能优于 2 层模型。
2.数据
2.1 数据汇总
给定包含以下内容的数据集:
- 标记为猫(y=1)或非猫(y=0)的 m_train 图像的训练集。
- 标记为 cat (y=1)或非 cat (y=0)的 m_test 图像的测试集。
- 每个图像的形状为(num_px，num_px，3)，其中 3 表示 RGB 分量的 3 个通道。因此，每个图像都是(高度=数量 px)和(宽度=数量 px)的平方。
2.2 数据重塑
为了方便起见，我们应该将图像的形状(num_px，num_px，3)整形为一个 numpy 数组的形状(num _ px∫num _ px∫3，1)。在这之后，我们的训练和测试数据集将被转换成一个 numpy 数组，其中每一列代表一个展平的图像。应该分别有 m_train 和 m_test 列。
图像到矢量转换
2.2 数据预处理
为了表示彩色图像，必须为每个像素指定红色、绿色和蓝色通道(RGB );因此，每个像素值实际上是范围从 0 到 255 的三个数字的向量。
机器学习中一个常见的预处理步骤是对数据集进行居中和标准化，这意味着我们从每个示例中减去整个 numpy 数组的平均值，然后用整个 numpy 数组的标准偏差除以每个示例。但是，对于图片数据集，将数据集的每一行除以 255(像素通道的最大值)更简单、更方便。
3.学习算法的一般架构
学习算法体系结构
展平的输入矩阵将通过加权矩阵的参数 W[i]和偏置向量 b[i]传递。然后通过将参数传递通过 sigmoid 激活函数来预测 Yhat 的值。从参数的值和它们对应的 Yhat 值*，*我们可以通过计算成本函数来最小化成本；然后学习建模的参数。
算法的数学表达
4.构建算法
构建神经网络的主要步骤是:
- 定义模型结构(如输入要素的数量)
- 初始化模型的参数
- 循环:
- 计算电流损耗(正向传播)
- 计算电流梯度(反向传播)
- 使用梯度下降更新参数
我们通常分别实现功能/步骤 1-3，然后将它们集成到一个我们称之为model()的功能中。
4.1 助手功能
我们将首先使用数学表达式实现 sigmoid 函数:
sigmoid 函数
4.2 初始化参数
我们必须将 W 和 b 初始化为零的向量。
**注:**常规上，在更深层次的神经网络(层数和神经元更多)中，我们通常随机初始化向量 W。这是因为第一个隐藏层中的每个神经元将执行相同的计算。因此，即使在梯度下降的多次迭代之后，该层中的每个神经元都将与其他神经元一样计算相同的东西。更多信息请参考 Github 库。
4.3 向前和向后传播
既然我们的参数已经初始化，我们可以开始学习参数的“向前”和“向后”传播步骤。
4.4 优化
既然我们已经初始化了参数并计算了成本函数及其梯度，我们将继续使用梯度下降来更新参数。
目标是通过最小化代价函数j来学习参数 w 和 b 对于一个参数θ，更新规则为**θ = θ − αdθ**，其中α为学习率。
4.5 预测Yhat
前一个函数将输出学习到的 w 和b；因此，w e 能够使用 w 和 b 通过实现predict()函数来预测数据集 X 的标签。计算预测有两个步骤:
- 计算ŷ= a =σ(w . t * x+b)
- 将 a 的条目转换为 0(如果激活< = 0.5)或 1(如果激活>0.5)；将预测存储在矢量
Y_prediction中。
4.6 关键要点
上面实现的功能:
- 初始化( w ， b )。
- 迭代优化损失学习参数( w ， b )。
- 计算成本及其梯度。
- 使用梯度下降更新参数。
- 使用所学的( w ， b )来预测一组给定示例的标签。
5.建模
现在，我们将按照正确的顺序把所有的构建模块(在前面的部分中实现的功能)放在一起，看看整个模型是如何构建的。
培训和测试准确性
训练准确率接近 100%。这是一个很好的健全性检查:我们的模型是有效的，并且有足够高的容量来适应训练数据。另一方面，测试准确率为 70%。考虑到我们使用的小数据集以及逻辑回归是一个线性分类器，对于这个简单的模型来说，这实际上并不坏。
成本函数和梯度
解读:可以看到成本在下降。这表明正在学习参数。但是，您会发现您可以在训练集上对模型进行更多的训练。尝试增加上面单元格中的迭代次数，然后重新运行这些单元格。您可能会看到，训练集的准确性提高了，但测试集的准确性却降低了。这叫做过度拟合。
6.进一步分析
6.1 学习率的选择
为了让梯度下降起作用，你必须明智地选择学习率。学习率 α 决定了我们更新参数的速度。如果学习率过大，我们可能会“超调”最优值。类似地，如果它太小，我们将需要大量的迭代来收敛到最佳值。这就是为什么使用一个合理的学习率是至关重要的。
让我们比较一下我们模型的学习曲线和几种学习率的选择。也可以尝试不同于我们已经初始化的三个变量的值，看看会发生什么。
解读:
- 不同的学习率给出不同的成本，从而得到不同的预测结果。
- 如果学习率过大(0.01)，成本可能会上下振荡。它甚至可能会发散(尽管在这个例子中，使用 0.01 最终仍然是物有所值的)。
- 更低的成本并不意味着更好的模式。你必须检查是否有可能过度拟合；当训练精度大大高于测试精度时，就会发生这种情况。
在深度学习中，通常建议您选择最能最小化成本函数的学习速率。如果您的模型过度拟合，使用其他技术来减少过度拟合，例如超参数调整。
6.2 结果分析
让我们来看一些模型标注错误的图片。这将显示一些标签错误的图像。
标签错误的图像
模型表现不佳的几种图像类型包括:
- 猫的身体在一个不寻常的位置
- 猫出现在相似颜色的背景下
- 不寻常的猫的颜色和种类
- 照像镜头视角
- 图片的亮度
- 比例变化(猫在图像中很大或很小)
7.使用 Github 存储库中您自己的图像进行测试！
这是我在 Unsplash 上找到的一个样本小猫图片，我决定在模型上测试它:
来自 Unsplash
猜猜模型输出是什么:
输出
万岁！虽然这是从一个简单的逻辑回归模型中推导出来的，但它仍然是值得的——猫总是赢家。前往 Github 知识库，深入了解如何使用两层神经网络和一层深度神经网络对猫图像进行分类。
参考
特别感谢 deeplearning.ai ！
[1]用于 2 层和 L 层深度神经网络分类的 Github 知识库:https://github.com/TheClub4/Cat_Classification
[2]对于自动重新加载外部模块:http://stack overflow . com/questions/1907993/auto reload-of-modules-in-ipython
用机器学习对《龙与地下城》中的角色分类
Clint Bustrillos 在 Unsplash 上的照片
几个月前，一个朋友邀请我加入他的在线龙与地下城活动。尽管我有着令人尊敬的书呆子名声，但我从未真正玩过 DnD。我并不是反对它，事实上，它听起来很有趣，我喜欢它鼓励合作和机智的创造力。也许这可以避免我在新冠肺炎的单独禁闭中写论文所带来的单调生活。
我胡乱拼凑了一个我认为会很有趣的角色——，一个变异的阿西玛六刃术士。我并不热衷于阅读大量记录游戏元素的神圣书籍来优化我的术士，但我的新 DnD 同胞轻轻地把我推向了正确的方向，给魅力分配了最大的属性(唉，我有一只出汗的袜子的实际魅力来公正地进行角色扮演。)
在这样做的过程中，我开始思考:实际游戏的平衡性如何？是不是所有的优化都会导致相同的基本角色构建？或者我可以根据一个有限的角色信息子集推断出一个角色的类别吗？
每个分类器都需要数据
为了建立一个分类器并回答这个问题，我需要一个 DnD 字符的数据集。我在他的 Github上找到了一个由 B. Ogan Mancarci 编译的。它包含了超过 7900 个由用户通过他创建的网络应用表格提交的字符条目。他列出了一些关于数据集的潜在警告，这些警告似乎都不会妨碍我正在尝试做的简单研究。我将使用 python 和 pandas 和 sklearn 库作为标准工具集。如果您有兴趣跟随，可以在这个 git 资源库中找到包含该分析的(凌乱的)Jupyter 笔记本。
数据包含许多不同的特征，包括提交条目的用户元数据，以及感兴趣的实际字符数据。这些信息中的大部分是不必要的，因为我们主要感兴趣的是角色的统计数据和生命体征，即:
- 能力分数或属性，即 Cha(risma)、Con(constitution)、Dex(terity)、Int(elligence)、Str(ength)和 Wis(dom)
- 生命值(HP)
- 装甲等级(AC)
- 铸造状态(分类特征，{Cha，Con，Dex，Int，Str，Wis}之一)
提供了关于角色可用的法术和技能的附加信息，但由于以下几个原因，这些信息大多会被忽略:a)许多可能是特定职业所独有的，因此使分类变得琐碎，b)在完全扩展的数据中有数百个法术和技能，这显著增加了适度规模的数据集的维度。这很容易导致后期的过度拟合问题，除非它们能够以不同的方式进行提炼或浓缩。现在，我们也将忽略这些功能和设备。
数据探索
首先，我们将探索数据的一些主要特征，看看是否有任何需要解决的意外情况，或者是否有任何可识别的数据模式可以利用。从一个简单的问题开始:每个类中有多少在完整的数据集中被表示？检查不同类别是否平衡很重要。
与其他十几个类相比，数据集中 Artificer 样本的稀缺性是显而易见的，也是令人担忧的潜在原因。事实证明，工匠职业是 DnD 5e 佳能最近增加的，因此，还没有足够长的时间供玩家大量选择。这种不到整个数据集百分之一的不平衡可能会在以后产生问题。为了简单起见，我们将在本研究的其余部分忽略这个设计者——至少在有更多的设计者数据可用之前。其余的，虽然没有完全平衡，但仍在合理范围内，无需进一步调整。
DnD 为角色提供了追求多个职业的能力，只要满足特定的条件。对于这个练习来说，这增加了一层额外的复杂性，角色的职业没有很好的定义，玩家在潜在的多个不同方向发展他们的角色时会引入模糊性。为了提高我们的敏感度，我们将只考虑只有一个职业的角色构建，剩下的不到 7，000 个角色。现在让我们探索一下前面提到的不同角色属性的分布，看看是否存在可以区分职业的相关性。
能力分数、生命值和护甲等级的分布
不同属性和类别之间的关联热图
从热图中可以看出，某些属性与某些类别的关联可能比其他类别更大。另一方面，一些属性，比如说，战斗/战斗/敏捷施法属性，看起来在所有职业中几乎是一致的，这一点值得注意。
需要警惕的一点是，游戏中的角色进展允许玩家随着游戏的推进增加这些不同的属性。这可能是潜在的混淆，因为一个角色被扮演的时间长度在样本中不是恒定的。下面显示了不同属性与角色等级的关系。
我们看到角色的 HP 与角色的等级相关，Pearson 分数为 0.93，其他属性的趋势要小得多。为了说明这一点，我们将使用角色的 HP 除以角色的等级，而不仅仅是 HP。
在对这些分布的研究中，有一些异常值，与大部分人口相比，这些异常值似乎具有不自然的大值。尽管有许多处理异常值的选项，我们将对 HP/level 特性应用熟悉的 1.5*IQR 规则，删除 79 个观察值。
到目前为止，在这个初步的探索性分析之后，我们已经以增强我们的建模的统计能力的方式清理和准备了数据集，并且我们还基于类和属性之间存在的不同相关性确定了字符属性似乎是类之间可行的鉴别器。我们现在可以动手做一些初步的建模了！
二元建模
虽然最终目标是预测 12 个类别中的一个，但我们可以从一个较低复杂度的分类模型开始，以了解我们可以从数据中预期的性能。为此，我们将手动识别每个类是否是一个施法类，并构建一些基本的二元分类器。
我们应该如何决定我们是否成功开发了一个预测模型？我们需要一个成功指标来评估我们的结果。总的来说，这使我们能够比较一个模型与另一个模型的性能，并表明对模型的改进是否使预测朝着正确的方向发展。一种方法可以是准确性度量。我们的数据并没有严重失衡，所以这可能就足够了，但我们还可以做得更好，通过优化 F1 的分数，努力在精确度和召回率方面做得更好。这通常是特定于问题的，您应该决定哪个更重要，是最小化预测负面错误识别还是正面错误识别案例的频率。在我们的情况下，无论我们以何种方式识别错误，都不一定是危险的，但我们可以尝试惩罚假阳性，并尝试实现至少 80%的真阳性率(TPR)，同时只允许 5%的假阳性率(FPR)。
我们将首先尝试 75%-25%训练/测试数据集分割的逻辑回归分类器，并使用 10 重交叉验证方法。我们可以评估测试集的性能，评估我们的成功指标，并检查混淆矩阵。
这挺好的！我们成功实现了 87%的 TPR 和大约 10%的 FPR。我们可以用 ROC 曲线来更深入地研究这个问题，看看如果稍微调整一下决策边界，我们是否能达到 80/5 的比率。
逻辑回归 ROC 曲线
事实证明，通过对概率阈值的特殊解释，我们确实可以在 TPR 为 80.4%的情况下实现精确的 5% FPR。我们丢失了一些真实的标识，因为这个阈值在分配肯定的标识符以抑制 FPR 时有点保守。我们可以尝试不同的机器学习模型，决策树(DT)，看看它是否允许我们改进我们的建模，并提供更好的 TPR/FPR 比。使用网格搜索交叉验证方法调整 DT 的超参数以改进建模
马上，我们有 92.6%/6.3%的 TPR/FPR，这已经显示出潜在的改善！通过执行相同的练习和检查 ROC 曲线，我们确实找到了一个阈值，在这个阈值内我们可以获得 5%的 FPR 和高达 90%的 TPR！
决策树 ROC 曲线
多类建模
这很好，但是现在我们应该停止训练，解决将 12 个不同的类分类的原始问题。我们可以从同样的逻辑回归和 DT 技术开始。有各种方法来计算一个多类分类的总数值分数，但总的来说，DT 似乎比逻辑回归和另一个模型，支持向量机(SVM)更能成功地对大多数单个类进行分类。以下是(有点复杂的)混淆矩阵，以及多类 DT 的几个成功指标。
这显示了希望，然而，每个职业的建模能力有很大的差异，从成功的(牧师)到相当糟糕的(术士)。
集成学习
也许我们可以尝试使用集成方法来扩展 DT 建模，例如 XGBoost 和随机森林(RF ),从而增加一点复杂性。就其本身而言，XGBoost 并没有明显优于 DT。另一方面，使用 RF，我们似乎仍然能够挤出多一点的辨别能力来改善分类。
在这一点上，就我们能够从我们选择使用的有限数据中提取多少信息而言，我们可能正在接近极限。对于一些职业，即吟游诗人、巫师和术士，由于相似的优化建造，模型似乎很难区分这三个施法者。我们最初忽略了法术的使用，因为它们有效地识别了各自的职业，但也许我们可以注入间接的法术信息，而不用求助于法术本身。具体来说，我们可以将某个特定角色已经学会的个法术作为一个特征。然而，就像 HP 一样，一个角色所知道的法术数量是依赖于等级的，随着等级的提高，新的法术也会被获得。因此，我们将添加一个每级法术的特性到我们的数据集中。
我们可以使用这个新添加的列重新运行我们的 RF 模型。
通过为每个职业注入最少的法术信息，我们确实能够在这些职业之间提供更多一点的分离。它仍然不完美，但我们已经达到了一个可接受的阶段，我们可以回过头来检查使用 RF 模型进行分类的重要特征。
最终随机森林模型的特征重要性
这似乎是明智的，回想一下来自相关矩阵的 Con/Dex/Str casting stat 显示了跨类的一致性。这反映在这个图中，当涉及到分类时，重要性相应地降低。
从这里开始，我们可以继续改进模型，改进现有的特性，删除不重要的特性，或者在模型中加入额外的特性。也许某些种族有利于某些职业的优势，也许某个职业更有利于具有某种道德一致性的角色扮演，更不用说我们从未接触过的武器或技能信息，但可以以类似于法术的方式进行改编。最终，我们应该根据模型在哪里挣扎来决定，并进入需要更多信息来解决的具有最高相似性级别的类。
然而，这篇文章已经写了足够长的时间了，我相信我们已经设法解决了我们试图回答的原始问题。这些职业以独特的方式发展，鼓励不同的角色，让玩家扮演不同的角色。值得一提的是，我们可以总结测试的每个不同多类分类器的不同成功度量分数:
哦，当我们总结事情的时候，也许是为了记录，即使它看起来仍然和我的角色的职业有最大的冲突，我们可以通过我们的小 RF 模型让他看看会发生什么。🤞🏼
🤗
非常感谢 Lance McDiffett，他在一开始就把我拉到了 DnD，并以他作为数据科学家的经验为我的分析提供了宝贵的帮助。
将气候变化推文分类
利用 NLP 和分类技术将推文分类为气候变化信徒或否认者推文
背景
你好！在本文中，我将通过一个分类示例来识别 2017 年至 2019 年的气候变化推文，无论是气候变化“相信者”还是“否认者”。从哈佛数据世界下载了 2000 万条气候变化推文 ID，并进行“水合”(即填充了包含实际推文、推文详情、转发详情、用户信息等的 JSON 文件。)使用[twarc](https://github.com/DocNow/twarc)。然后，推文文件被保存在 mongoDB 数据库中，所有的转发都被过滤掉，剩下的推文在标签和文本预处理的帮助下被分类为“相信者”或“否认者”。这一分类过程涵盖了该项目的第一部分(点击此处查看 github repo)，而下一篇文章涵盖了第二部分(点击此处查看 github repo)，并涉及主题建模和推文聚类，以根据地理位置确定情绪趋势。
如何将这些推文归类为“信徒”或“否认者”？我们不能简单地用情绪分析来区分这两者，因为相信者和否定者都会对气候变化产生积极和消极的情绪。因此，分类器模型是在包含明确的“相信者”或“否定者”标签的推特子集上训练的。标签列表是从 tweet 数据库中手动搜索和评估的；请参见下面的表 1，了解使用的内容。应该指出的是，否认者的推文比相信者的推文少得多，两者的比例分别为 6%和 94%。为了进行度量评估，相信者的推文代表负面情况，否认者的推文代表正面情况。
表 1:“权威”信徒和否认者标签
在执行上述分类流程时，将涵盖以下主题:
- 文本预处理
- 基线模型管道
- 绩效指标评估
- 网格搜索
- 阈值选择
- 整个数据集的分类
文本预处理
一旦 tweets 的子集从全集中提取出来，并进一步分成训练集和测试集，CountVectorizer和TfidfVectorizer被设置成将每个集转换成将用于建模的文档术语矩阵。可以通过 [CountVectorizer](/hacking-scikit-learns-vectorizers-9ef26a7170af) 和 [TfidfVectorizer](/hacking-scikit-learns-vectorizers-9ef26a7170af)构建和实现自定义预处理和标记化功能。首先，预处理函数见下文；所有推文都被清除了以下特征:
- 换行
- URL 的
- 数字
- 大写字母
- 标点
def tweet_preprocessor(tweet): tweet = tweet.replace('\n', ' ') # remove line breaks
tweet = re.sub(r"\bhttps://t.co/\w+", '', tweet) # remove URL's
tweet = re.sub('\w*\d\w*', ' ', tweet) # remove numbers
tweet = re.sub('[%s]' % re.escape(string.punctuation), ' ',
tweet.lower()) # remove capital letters and punctuation
return tweet
接下来，见下面的记号化函数；t okenization 将每条推文分割成一个单词集合(即令牌)。词汇化旨在将每个单词缩减到其基本形式。例如:大笑，大笑，大笑，大笑都会变成大笑。这通过减少唯一单词的数量来降低分析的复杂性。这两种技术都内置在 spaCy 包中，该包在令牌化函数中使用:
# create a spaCy tokenizer
spacy.load('en')
lemmatizer = spacy.lang.en.English()def tweet_tokenizer(doc):
tokens = lemmatizer(doc)
return [token.lemma_ for token in tokens]
除了预处理和标记化，还有许多其他的矢量器超参数需要微调。例如:
- 最大词频:设置一个词可以出现的最大 tweets 数(例如，如果一个词出现在超过 80%的 tweets 中，那么它可能不是 tweets 之间差异的良好指标)。
- 最小词频:设置一个单词必须出现的最少推文数(例如，如果一个单词出现在少于 1%的推文中，那么它可能是一个不相关的术语，甚至可能是一个错别字)。
- ngram range :每条推文中的词应该如何分组？我们只对单词感兴趣吗？成对分组的单词？三胞胎？双人和三人组值得一看，因为他们可以帮助捕捉常见的短语(如“气候变化”)。
- 停用词:除了从推文中删除常用停用词(如“the”、“is”、“are”等。)，所有确定的标签(上面列出的)都作为停用词包含在内。标签呈现了潜在的数据泄漏，这可能导致我们的分类器过度拟合，无法推广到其他推文。
矢量化被集成到分类管道中，这可以在下一节的代码中看到。
基线模型管道
最初管道的目标是挑选出一些潜在的基线模型用于进一步探索。为管道创建了矢量字典和模型字典；矢量器字典包含许多不同的CountVectorizer和TfidfVectorizer变体，例如具有不同的 ngram 范围、max_df 和 min_df，模型字典包含分类器列表。见下文:
矢量词典
vectorizer_dict = {'CV_1': CountVectorizer(ngram_range=(1,3),
max_df = 0.8, min_df = 3,
preprocessor=tweet_preprocessor,
tokenizer=tweet_tokenizer,
stop_words=new_stop_words),
...
'TF_1': TfidfVectorizer(ngram_range=(1,3),
max_df = 0.8, min_df = 3,
preprocessor=tweet_preprocessor,
tokenizer=tweet_tokenizer,
stop_words=new_stop_words),
...}
模型词典
model_dict = {'Logistic Regression': LogisticRegression(),
'Naive Bayes': MultinomialNB(),
'LinearSVM': SGDClassifier(random_state=42),
'Decision Tree': DecisionTreeClassifier(max_depth=6),
'XGBoost': XGBClassifier(max_depth=6)}
由于数据集不平衡，使用SMOTE、ADASYN和RandomOverSampler来评估过采样的效果。没有一个选项执行得很好，所以它们从模型管道中被省略了。基准模型都用精度、召回和 F1 分数性能指标进行了评估。以下是每一个的快速定义:
- 精度:正确的阳性病例预测的百分比
- 回忆:正确预测的阳性病例的百分比
- F1 得分:精确度和召回率的调和平均值。
为了以高效的方式编译结果，在每次管道迭代后，这些指标都存储在一个字典中，同时还有相应的矢量器和模型名称。请参见下面的管道:
class_results_dict = defaultdict(list)for vec_name, vectorizer in vectorizer_dict.items():
X_train_cv = vectorizer.fit_transform(X_train)
X_test_cv = vectorizer.transform(X_test) for mod_name, model in model_dict.items():
model.fit(X_train_cv, y_train);
y_pred_cv = model.predict(X_test_cv) precision_cv = precision_score(y_test, y_pred_cv)
recall_cv = recall_score(y_test, y_pred_cv)
f1_cv = f1_score(y_test, y_pred_cv)
class_results_dict['Vectorizer Type'].append(vec_name)
class_results_dict['Model Name'].append(mod_name)
class_results_dict['Precision'].append(precision_cv)
class_results_dict['Recall'].append(recall_cv)
class_results_dict['F1-score'].append(f1_cv)class_results_df = pd.DataFrame(class_results_dict)
绩效指标评估
在这种情况下，F1 分数是评估每个模型的最佳指标。精确度和召回率都很重要，所以不需要权衡孰轻孰重。换句话说，第一类(假阳性)和第二类(假阴性)错误是相等的。看看class_results_df、CountVectorizer中的 F1 分数，在所有矢量器中，ngram 范围为(1，3)(即 CV_2)的表现最好，最有效的模型是逻辑回归和线性 SVM(SGD 分类器的默认)。请参见下面的表 2 中的class_results_df片段:
表 2:类 _ 结果 _df
Logistic 回归和 ngram 范围为(1，3)的 SGD 分类器通过网格搜索进一步优化超参数。
网格搜索
对于逻辑回归和 SGD 分类器，在进行单个网格搜索时，需要考虑多个超参数。对正则化的类型和强度进行评估，同时对逻辑回归评估不同类型的优化算法，并对 SGD 分类器评估不同类型的损失函数。代码见下文；利用GridSearchCV，其中选择 cv=5 折叠进行交叉验证。
from sklearn.model_selection import GridSearchCV# Logistic Regression
logit_params = [{'penalty': ['none', 'l1', 'l2']},
{'solver': ['liblinear', 'lbfgs']},
{'C':np.logspace(-5,3,num=9,base=10,dtype='float')}]gs_logit = GridSearchCV(LogisticRegression(), logit_params, cv=5,
scoring='f1', error_score=0.0)
gs_logit.fit(X_train_cv, y_train)
y_true, y_pred = y_test, gs_logit.predict(X_test_cv)
f1_score = f1_score(y_true, y_pred)#SGD Classifier
sgd_params = [{'loss':
['hinge','log','modified_huber','squared_hinge']},
{'penalty': ['none', 'l1', 'l2']},
{'alpha':
np.logspace(-4,3,num=8,base=10,dtype='float')}]gs_sgd = GridSearchCV(SGDClassifier(), sgd_params,
cv=5, scoring='f1')
gs_sgd.fit(X_train_ros, y_train_ros)
y_true, y_pred = y_test, gs_sgd.predict(X_test_cv2)
f1_score = f1_score(y_true, y_pred)
两个模型的 F1 分数都通过一个 l2 惩罚进行了优化。逻辑回归使用 lbfgs 解算器表现最佳，SGD 分类器使用 modified_huber 成本函数表现最佳(二次平滑 SVM 模型，其中 gamma = 2 )。
阈值选择
优化每个模型的 F1 分数的下一步是找到最佳概率阈值。分类器的默认阈值设置为 50%，即大于 50%的概率表示拒绝的推文，而小于 50%的概率表示相信的推文。逻辑回归混淆矩阵的视频见下图 1；阈值小部件显示 F1 分数达到最大值，阈值设置为 0.32。
比较两个模型的 F1 得分，逻辑回归得分最高，F1 得分为 0.803 。为了直观地确认 F1 分数，有必要查看精确度-召回曲线(ROC 曲线对于不平衡的数据集不太可靠，因此在这种情况下没有使用 ROC 曲线)。参见下面的图 2:
图 2:逻辑回归精度-召回曲线
可以看出，当精度等于 0.870 且召回等于 0.746 时，曲线的最佳点出现；这些值计算出 F1 分数为 0.803。
为了提高这个分数，测试了不同的“确定的”标签组合(添加某些标签，删除某些标签，等等)。)，但是事实证明，使用表 1 中使用的标签列表时，模型的性能最好。
整个数据集的分类
确定逻辑回归模型和阈值后，对整个数据集进行最终分类。为每条推文生成预测概率，并应用 0.32 的阈值。参见下面的代码:
believer_denier_preds = []
y_final_predict = logit.predict_proba(X_final_test)for i in y_final_predict:
if i[1] < 0.32:
believer_denier_preds.append(0)
else:
believer_denier_preds.append(1)
因为推文没有预先确定的“正确”标签，所以需要人工评估来决定模型是否是有效的分类器。一个很好的初始检查是计算拒绝者推文与相信者推文的比率，并查看它是否与推文训练集中的比率相似(94%相信者对 6%拒绝者)。这个比例是 90%的相信者对 10%的否认者，这与训练集的比例大致相当。更深入的人工检查证实了分类器是有效的。
请随意查看 github repo，了解本文中详细描述的分类过程，位于此处。当在 tweet 数据集上执行主题建模和聚类时，最终会使用这种分类。这个过程的 github repo 可以在这里找到。
感谢阅读！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
