使用Kili和HuggingFace AutoTrain进行意见分类

介绍

了解用户需求对于任何与用户相关的业务来说都是至关重要的。但这也需要大量的辛勤工作和分析，而这是非常昂贵的。为什么不利用机器学习呢？通过使用Auto ML，可以减少编码量。

在本文中，我们将利用HuggingFace AutoTrain和Kili构建一个用于文本分类的主动学习流水线。Kili是一个通过质量训练数据创建的数据中心方法来赋能机器学习的平台。它提供了协作数据标注工具和API，使可靠的数据集构建和模型训练之间的快速迭代成为可能。主动学习是一个过程，其中您将标记的数据添加到数据集中，然后进行迭代地重新训练模型。因此，它是无限的，并且需要人类来标记数据。

作为本文的一个具体示例用例，我们将使用来自Google Play Store的VoAGI用户评论来构建我们的流水线。然后，我们将使用我们构建的流水线对评论进行分类。最后，我们将对分类的评论应用情感分析。然后我们将分析结果，更容易理解用户的需求和满意度。

使用HuggingFace进行自动训练

自动化机器学习是指自动化机器学习流程的一个术语。它还包括数据清洗、模型选择和超参数优化。我们可以使用🤗 transformers进行自动化的超参数搜索。超参数优化是一个困难且耗时的过程。

虽然我们可以通过使用transformers和其他强大的API自己构建我们的流水线，但也可以使用AutoTrain进行完全自动化。AutoTrain是建立在许多强大的API（如transformers、datasets和inference-api）之上的。

数据清洗、模型选择和超参数优化步骤在AutoTrain中都是完全自动化的。可以充分利用这个框架为特定任务构建可供生产使用的SOTA转换器模型。目前，AutoTrain支持二分类和多标签文本分类、标记分类、抽取式问答、文本摘要和文本评分。它还支持英语、德语、法语、西班牙语、芬兰语、瑞典语、印地语、荷兰语等许多语言。如果您的语言在AutoTrain中不受支持，也可以使用自定义模型和自定义分词器。

Kili

Kili是一个面向数据中心业务的端到端AI训练平台。Kili提供了优化的标注功能和质量管理工具来管理您的数据。您可以快速注释图像、视频、文本、pdf和语音数据，同时控制数据集的质量。它还具有用于GraphQL和Python的强大API，极大地简化了数据管理。

它可在线或本地使用，并且可以在计算机视觉、自然语言处理和OCR上实现现代机器学习技术。它支持文本分类、命名实体识别（NER）、关系抽取等NLP/OCR任务。它还支持计算机视觉任务，如目标检测、图像转录、视频分类、语义分割等等！

Kili是一种商业工具，但您也可以创建一个免费的开发者帐户来尝试Kili的工具。您可以从定价页面了解更多信息。

项目

我们将以评论分类和情感分析为例，来了解一个移动应用程序的见解。

我们从Google Play Store中提取了大约4万条VoAGI的评论。我们将逐步对此数据集中的评论文本进行标注。然后我们将构建一个评论分类的流水线。在建模过程中，第一个模型将使用AutoTrain准备。然后我们还将构建一个不使用AutoTrain的模型。

项目的所有代码和数据集都可以在GitHub存储库中找到。

数据集

让我们首先看一下原始数据集，

这个数据集中有10列和40130个样本。我们需要的唯一列是content，即用户的评论。在开始之前，我们需要定义一些类别。

我们定义了4个类别，

• 订阅：由于VoAGI有一个订阅选项，与用户对订阅功能的意见相关的任何内容都应属于此类别。
• 内容：VoAGI是一个分享平台，有许多从诗歌到高级人工智能研究的作品。有关各种主题的用户意见，内容质量应属于此类别。
• 界面：关于用户界面、搜索文章、推荐引擎以及与界面相关的任何内容都应属于此类别。这也包括与支付相关的问题。
• 用户体验：用户对应用程序的一般想法和意见。此类别应该是一般的抽象，不属于其他类别。

对于标注部分，我们首先需要在Kili平台上创建一个项目。我们可以使用平台的Web界面或API来完成。让我们看看两者的使用方式。

使用Web界面：

从项目列表页面开始，我们创建一个多类文本分类项目。

之后，在项目页面上，您可以通过点击“添加资源”按钮来添加您的数据。目前，您最多可以添加25000个样本，但如果您联系Kili的销售团队，可以扩展此限制。

创建项目之后，我们需要添加作业。我们可以从“设置”页面准备一个标注界面。

虽然我们定义了4个类别，但难免会遇到应该具有多个类别或完全奇怪的评论。为了捕捉这些情况，我将添加两个额外的标签（不用于建模）。

在我们的示例中，我们添加了两个额外的标签（Other，Multi-label）。我们还添加了一个命名实体识别（NER）作业，只是为了在标注时指定我们如何决定一个标签。最终的界面如下所示

从左侧菜单中可以看到，还可以在“说明”页面上放置一个描述您标签的链接。我们还可以从“成员”页面添加其他成员到我们的项目，或从“质量管理”页面添加质量度量。更多信息可以在文档中找到。

现在，让我们使用Python API创建我们的项目：

首先，我们需要导入所需的库

( notebooks/kili_project_management.ipynb )

import os
#我们将处理数据（一个csv文件）
import pandas as pd

#API客户端
from kili.client import Kili
#为什么不使用漂亮的进度条呢？
from tqdm import tqdm

from dotenv import load_dotenv
load_dotenv()

为了访问平台，我们需要对客户端进行身份验证

API_KEY = os.getenv('KILI_API_KEY')
# 初始化并验证Kili客户端
kili = Kili(api_key = API_KEY)

现在我们可以开始准备我们的界面了，界面只是一个Python字典。我们将定义我们的作业，然后填充标签。由于所有标签也可以有子标签，因此我们也将标签作为字典传递。

labels = ['用户体验', '订阅', '内容', '其他', '多标签']
entity_dict = {
    '用户体验': '#cc4125',
    '订阅': '#4543e6',
    '内容': '#3edeb6',
}
project_name = '用于主题分类的用户评论数据集'
project_description = "VoAGI的应用程序评论从Google Play商店中获取用于主题分类"

interface = {
    'jobs': {
        'JOB_0': {
            'mlTask': '分类',
            'instruction': '标签',
            'required': 1,
            'content': {
                "categories": {},
                "input": "单选",
            },
        },
        'JOB_1': {
            'mlTask': "命名实体识别",
            'instruction': '实体',
            'required': 1,
            'content': {
                'categories': {},
                "input": "单选"
            },
        },
    }
}

# 填充作业的界面json
for label in labels:
    # 将标签转换为大写并将空格替换为下划线(_)
    # 例如 用户体验 -> USER_EXPERIENCE
    # 这是填充界面的首选方式
    label_upper = label.strip().upper().replace(' ', '_')
    # 
    content_dict_0 = interface['jobs']['JOB_0']['content']
    categories_0 = content_dict_0['categories']
    category = {'name': label, 'children': []}
    categories_0[label_upper] = category

for label, color in entity_dict.items():
    label_upper = label.strip().upper().replace(' ', '_')
    content_dict_1 = interface['jobs']['JOB_1']['content']
    categories_1 = content_dict_1['categories']
    category = {'name': label, 'children': [], 'color': color}
    categories_1[label_upper] = category

# 现在我们可以创建我们的项目了
# 此方法返回创建的项目的id
project_id = kili.create_project(json_interface=interface,
                            input_type='文本',
                            title=project_name,
                            description=project_description)['id']

我们准备将数据上传到项目中。可以使用append_many_to_dataset方法将数据导入到平台中。通过使用Python API，我们可以按批次最多导入100个数据。以下是一个简单的上传数据的函数：

def import_dataframe(project_id:str, dataset:pd.DataFrame, text_data_column:str, external_id_column:str, subset_size:int=100) -> bool:
    """
    参数：
    输入：
        - project_id (str)：指定要加载数据的项目，这也是在创建项目时返回的
        - dataset (pandas DataFrame)：具有适当的id和文本输入列的数据集
        - text_data_column (str)：指定哪一列是文本输入数据
        - external_id_column (str)：指定哪一列是id
        - subset_size (int)：指定一次导入的样本数。不能超过100
    
    输出：
        无
    
    返回：
        根据过程成功与否返回True或False

    """

    assert subset_size <= 100, "Kili只允许一次最多上传100个资源到应用程序中"


    L = len(dataset)

    # 将25000设置为上传限制，可以更改
    if L>25000:
        print('Kili Projects当前支持默认最大25000个样本。导入前25000个样本...')
        L=25000

    i = 0

    while i+subset_size < L:
        
        subset = dataset.iloc[i:i+subset_size]

        externalIds = subset[external_id_column].astype(str).to_list()
        contents = subset[text_data_column].astype(str).to_list()
        
        kili.append_many_to_dataset(project_id=project_id,
                                    content_array=contents,
                                    external_id_array=externalIds)

        i += subset_size

    return True

它简单地将给定的dataset DataFrame导入到由project_id指定的项目中。

我们可以从文档字符串中看到参数，我们只需要传递我们的数据集以及相应的列名即可。当我们加载数据时，我们只需使用我们获得的样本索引。然后，上传数据就完成了！

dataset_path = '../data/processed/lowercase_cleaned_dataset.csv'
df = pd.read_csv(dataset_path).reset_index() # 重置索引以获取索引

import_dataframe(project_id, df, 'content', 'index')

使用Python API并不难，我们使用的辅助方法涵盖了许多困难。我们还使用了另一个脚本来检查更新数据集时的新样本。有时，在数据集更新后，模型性能会下降。这是由于简单的错误，如错误标记和引入数据集偏差。该脚本只是对两个给定数据集版本的不同样本进行身份验证，然后将其移动到待审核。我们可以通过update_properties_in_assets方法更改样本的属性：

( scripts/move_diff_to_review.py )

# 设置Kili客户端和参数
from kili.client import Kili
from dotenv import load_dotenv
import os
import argparse

import pandas as pd

load_dotenv()

parser = argparse.ArgumentParser()
parser.add_argument('--first',
                    required=True,
                    type=str,
                    help='第一个数据框的路径')
parser.add_argument('--second',
                    required=True,
                    type=str,
                    help='第二个数据框的路径')

args = vars(parser.parse_args())

# 设置Kili连接
API_KEY = os.getenv('KILI_API_KEY')
kili = Kili(API_KEY)

# 读取数据框
df1 = pd.read_csv(args['first'])
df2 = pd.read_csv(args['second'])

# 将两个数据框连接起来，应该会得到常见元素的重复项
# 然后我们可以删除重复的元素，以获取两个数据框之间的不同元素
diff_df = pd.concat((df1, df2)).drop_duplicates(keep=False)
diff_ids = diff_df['id'].to_list()

# 更改应该以数组形式给出，其中包含每个样本的更改。
# 这就是为什么将 [‘TO_REVIEW’] * len(diff_df) 传递给 status_array 参数
kili.update_properties_in_assets(diff_ids,
                                 status_array=['TO_REVIEW'] * len(diff_ids))

print('设置%d个条目待审核！' % len(diff_df))

标注

现在我们已经上传了源数据，平台上有一个内置的标注界面，非常容易使用。在注释数据时，可用的键盘快捷键非常有帮助。我们使用界面时毫不费力，有自动定义的快捷键，它简化了标注过程。我们可以通过点击界面右上角的键盘图标来查看快捷键，它们在标注界面上也会以下划线字符显示。

一些样本非常奇怪，所以我们决定在标记时跳过它们。总体来说，由于Kili内置的平台，这个过程要容易得多。

导出标记数据

使用Python API可以轻松导出标记数据。下面的脚本将标记和审核过的样本导出到一个数据框中，然后将其保存为给定的名称的CSV文件。

( scripts/prepare_dataset.py )

import argparse
import os

import pandas as pd
from dotenv import load_dotenv
from kili.client import Kili

load_dotenv()

parser = argparse.ArgumentParser()
parser.add_argument('--output_name',
                    required=True,
                    type=str,
                    default='dataset.csv')
parser.add_argument('--remove', required=False, type=str)
args = vars(parser.parse_args())

API_KEY = os.getenv('KILI_API_KEY')
dataset_path = '../data/processed/lowercase_cleaned_dataset.csv'
output_path = os.path.join('../data/processed', args['output_name'])


def extract_labels(labels_dict):
    response = labels_dict[-1]  # 选择样本的最新版本
    label_job_dict = response['jsonResponse']['JOB_0']
    categories = label_job_dict['categories']
    # 所有样本都有一个标签，我们可以通过索引直接选择它
    label = categories[0]['name']
    return label


kili = Kili(API_KEY)
print('已验证身份！')
# 查询将返回包含匹配元素的列表（在此情况下为项目）
# 由于我们只有一个带有这个名称的项目，我们可以直接选择第一个索引
project = kili.projects(
    search_query='用于主题分类的用户评论数据集')[0]
project_id = project['id']

# 我们可以自定义返回的字段
# 下面的字段基本上足够了，
# labels.jsonResponse 包含了标记数据
returned_fields = [
    'id', 'externalId', 'labels.jsonResponse', 'skipped', 'status'
]
# 为了将样本与 externalId 匹配，我也读取了原始数据集
dataset = pd.read_csv(dataset_path)

# 我们可以将数据作为数据框提取
df = kili.assets(project_id=project_id,
                 status_in=['已标记', '已审核'],
                 fields=returned_fields,
                 format='pandas')

print('获取到了样本！')

# 我们将跳过已经跳过的样本
df_ns = df[~df['skipped']].copy()

# 提取已标记的样本
df_ns.loc[:, 'label'] = df_ns['labels'].apply(extract_labels)
# 将 externalId 列返回为字符串，让我们将其转换为整数
# 用作索引
df_ns.loc[:, 'content'] = dataset.loc[df_ns.externalId.astype(int), 'content']

# 现在我们可以删除 `labels` 列了
df_ns = df_ns.drop(columns=['labels'])

# 我们将删除多标签的样本
df_ns = df_ns[df_ns['label'] != '多标签'].copy()

# 如果给定了 remove 参数，则还要删除指定标签的样本
if args['remove']:
    df_ns = df_ns.drop(index=df_ns[df_ns['label'] == args['remove']].index)

print('数据获取完成')
print('数据集共有 %d 个样本' % (len(df_ns)))
print('将处理后的数据集保存到: %s' % os.path.abspath(output_path))

df_ns.to_csv(output_path, index=False)

print('完成！')

很棒！我们现在有了标记的数据作为一个csv文件。让我们在HuggingFace中创建一个数据集库，并将数据上传到那里！

非常简单，只需点击您的个人资料图片，然后选择新数据集选项。

然后输入库的名称，选择许可证（如果需要），完成！

现在我们可以从文件和版本选项卡的添加文件中上传数据集。

在上传数据后，数据集查看器会自动可用，我们可以轻松查看样本！

还可以使用datasets包将数据集上传到Hugging Face的数据集中心。

建模

让我们尝试主动学习。我们迭代地标记和微调模型。在每次迭代中，我们在数据集中标记50个样本。样本数量如下所示：

让我们先试试AutoTrain：

首先，打开AutoTrain

1. 创建一个项目

1. 我们可以选择之前创建的数据集存储库或重新上传数据集。然后我们需要选择拆分类型，我将选择自动。

1. 训练模型

AutoTrain将尝试不同的模型并选择最佳模型。然后自动执行超参数优化。数据集也会自动处理。

价格完全取决于您的用例。它可以低至10美元，也可以比当前价值更昂贵。

大约20分钟后训练完成，结果非常好！

最佳模型的准确率接近89%。

现在我们可以使用这个模型进行分析，设置整个过程只需要大约30分钟。

不使用AutoTrain进行建模

我们将使用Ray Tune和Hugging Face的Trainer API来搜索超参数并微调预训练的深度学习模型。我们选择了在推文上进行微调的roBERTa基础情感分类模型。我们在google的协作平台上对模型进行了微调，并且可以在GitHub存储库的notebooks文件夹中找到。

Ray Tune是一种常用的用于超参数优化的库，内置了许多SOTA算法。还可以使用Optuna和SigOpt。我们还使用[Async Successive Halving Algorithm (ASHA)作为调度程序，HyperOpt作为搜索算法。这基本上是一个起点。您可以使用不同的调度程序和搜索算法。

我们将做什么？

• 导入必要的库（十几个）并准备数据集类
• 定义需要的函数和方法来处理数据
• 加载预训练模型和分词器
• 运行超参数搜索
• 使用最佳结果进行评估

让我们从导入必要的库开始！（所有代码都在notebooks/modeling.ipynb和google协作笔记本中）

# general data science/utilization/visualization imports
import json
import os
import random

# progress bar
from tqdm import tqdm

# data manipulation / reading
import numpy as np
import pandas as pd

# visualization
import plotly.express as px
import matplotlib.pyplot as plt

# pre-defined evaluation metrics
from sklearn.metrics import (accuracy_score, f1_score,
                             precision_score, recall_score)

from sklearn.model_selection import train_test_split
# torch imports
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Dataset, random_split
# huggingface imports
import transformers
from datasets import load_metric
from transformers import (AutoModelForSequenceClassification, AutoTokenizer, 
                          Trainer, TrainingArguments)

# ray tune imports for hyperparameter optimization
from ray.tune.schedulers import ASHAScheduler, PopulationBasedTraining
from ray.tune.suggest.hyperopt import HyperOptSearch

我们将为我们用于可重复性的库设置一个种子

def seed_all(seed):
    torch.manual_seed(seed)
    random.seed(seed)
    np.random.seed(seed)

SEED=42
seed_all(SEED)

现在让我们定义我们的数据集类！

class TextClassificationDataset(Dataset):
    def __init__(self, dataframe):
        self.labels = dataframe.label.to_list()
        self.inputs = dataframe.content.to_list()
        self.labels_to_idx = {k:v for k,v in labels_dict.items()} # copy the labels_dict dictionary

    def __len__(self):
        return len(self.inputs)

    def __getitem__(self, idx):
        if type(idx)==torch.Tensor:
            idx = list(idx)

        input_data = self.inputs[idx]
        target = self.labels[idx]
        target = self.labels_to_idx[target]

        return {'text': input_data, 'label':target}

我们可以通过指定HuggingFace hub存储库轻松下载模型。还需要导入指定模型的分词器。在超参数优化期间，我们需要提供一个初始化模型的函数。模型将在该函数中定义。

我们要优化的度量标准是准确性，我们希望该值尽可能高。因此，我们需要加载度量标准，然后定义一个函数来获取预测结果并计算首选的度量标准。

model_name = 'cardiffnlp/twitter-roberta-base-sentiment'
# 我们将执行搜索以优化模型的准确性，
# 我们需要首先指定并加载准确性度量标准
metric = load_metric("accuracy")


# 由于我们已经输入了模型名称，我们可以加载分词器
# 我们也可以加载模型，但我将在model_init函数中进行描述。
tokenizer = AutoTokenizer.from_pretrained(model_name)


def model_init():
    """
    通过新初始化的模型执行超参数优化，
    因此我们需要为每个搜索运行重新初始化并返回以`model_name`选择的预训练模型
    """
    return AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=4, return_dict=True, ignore_mismatched_sizes=True)

# 计算准确性的函数
def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions = np.argmax(logits, axis=-1) # 选择具有最大值的索引
    return metric.compute(predictions=predictions, references=labels)

在定义度量计算和模型初始化函数之后，我们可以加载数据：

file_name = "dataset-11.csv"

dataset_path = os.path.join('data/processed', file_name)
dataset = pd.read_csv(dataset_path)

我还定义了两个字典，用于将标签映射到索引和索引映射到标签。

idx_to_label = dict(enumerate(dataset.label.unique()))
labels_dict = {v:k for k,v in idx_to_label.items()}

现在我们可以定义超参数搜索的算法和调度程序。

scheduler =  ASHAScheduler(metric='objective', mode='max')
search_algorithm = HyperOptSearch(metric='objective', mode='max', random_state_seed=SEED)
# 参数搜索的运行次数
n_trials =  40

在将文本数据传递给模型之前，我们还需要对其进行分词处理，我们可以使用加载的分词器轻松完成这一点。Ray Tune在黑盒设置中工作，因此我使用分词器作为默认参数进行了解决。否则，将会出现关于分词器定义的错误。

def tokenize(sample, tokenizer=tokenizer):
    tokenized_sample = tokenizer(sample['text'], padding=True, truncation=True)
    tokenized_sample['label'] = sample['label']
    return tokenized_sample

另一个实用函数，返回分层和分词处理的Torch数据集拆分：

def prepare_datasets(dataset_df, test_size=.2, val_size=.2):
    train_set, test_set = train_test_split(dataset_df, test_size=test_size,
                                        stratify=dataset_df.label, random_state=SEED)

    train_set, val_set = train_test_split(train_set, test_size=val_size,
                                        stratify=train_set.label, random_state=SEED)

    # 先对数据帧进行洗牌
    train_set = train_set.sample(frac=1, random_state=SEED)
    val_set = val_set.sample(frac=1, random_state=SEED)
    test_set = test_set.sample(frac=1, random_state=SEED)

    # 将数据帧转换为torch数据集
    train_dataset = TextClassificationDataset(train_set)
    val_dataset = TextClassificationDataset(val_set)
    test_dataset = TextClassificationDataset(test_set)

    # 对数据集进行分词处理
    tokenized_train_set = train_dataset.map(tokenize)
    tokenized_val_set = val_dataset.map(tokenize)
    tokenized_test_set = test_dataset.map(tokenize)

    # 最后返回处理后的数据集
    return tokenized_train_set, tokenized_val_set, tokenized_test_set

现在我们可以进行搜索了！让我们首先处理数据：

tokenized_train_set, tokenized_val_set, tokenized_test_set = prepare_datasets(dataset)

training_args = TrainingArguments(
    'trial_results',
    evaluation_strategy="steps",
    disable_tqdm=True,
    skip_memory_metrics=True,
)

trainer = Trainer(
    args=training_args,
    tokenizer=tokenizer,
    train_dataset=tokenized_train_set,
    eval_dataset=tokenized_val_set,
    model_init=model_init,
    compute_metrics=compute_metrics
    )

best_run = trainer.hyperparameter_search(
    direction="maximize", 
    n_trials=n_trials,
    backend="ray",
    search_alg=search_algorithm,
    scheduler=scheduler
    )

我们分别进行了20次和40次的搜索，结果如下所示。20次运行的F1、召回率和精确度得分的加权平均值。

40次运行的F1、召回率和精确度得分的加权平均值。

性能在第三个数据集版本时有所提升。在数据标注的某个点上，我错误地对数据集引入了过多的偏见。正如我们所看到的，随着样本方差的增加，其性能变得更加合理。最终模型保存在Google Drive，并可以从此处下载，也可以通过download_models.py脚本进行下载。

最终分析

现在我们可以使用微调的模型进行最终分析了。我们只需加载数据、处理数据，并从模型中获取预测结果。然后我们可以使用预训练的情感分析模型，希望能得到一些见解。

我们使用Google Colab进行推断（此处），然后将结果导出到result.csv中。可以在GitHub代码库的results文件夹中找到它。然后我们在另一个google collaboratory笔记本中分析结果，以获得交互式体验。因此，您也可以轻松地进行交互。

现在让我们来看看结果！

我们可以看到给定的得分非常积极。总的来说，用户喜欢这个应用程序。

这也与情感分析相吻合，大部分评论都是积极的，而负面评论的数量最少。

正如上面所示，模型的性能是可以理解的。积极得分明显高于其他得分，就像情感分析图所显示的那样。

至于之前定义的类别，似乎模型预测大部分评论都是关于用户体验的（不包括与其他类别相关的经验）：

我们还可以看到在定义的类别上的情感预测：

我们不会对评论进行详细分析，对潜在问题的基本了解就足够了。因此，从最终数据中得出简单的结论就足够了：

• 可以理解大部分关于订阅的评论都是负面的。付费内容通常不受移动应用程序的欢迎。
• 界面方面有很多负面评论。这可能是进一步分析的线索。也许对功能有误解，或者某个功能不像用户想象的那样工作。
• 人们普遍喜欢文章，大部分人都有良好的体验。

关于图表的重要说明：我们没有按应用程序版本筛选评论。当我们看最新的当前版本（4.5）的结果时，似乎应用程序的界面会让用户困惑或者有烦人的错误。

结论

现在我们可以使用预训练模型来尝试理解移动应用程序的潜在缺点。然后就更容易分析特定功能了。

在这个示例中，我们使用了HuggingFace强大的API和AutoTrain，以及Kili易于使用的界面。使用AutoTrain进行建模只花了30分钟，它选择了模型并为我们进行了训练。相比我自己开发模型，AutoTrain显然更高效。

所有的代码、数据集和脚本都可以在GitHub上找到。您也可以尝试AutoTrain模型。

虽然我们可以将此视为一个有效的起点，但我们应该收集更多的数据并尝试构建更好的流水线。更好的流水线将导致更有效的改进。