手把手教你玩Hugging Face

典型使用大语言模型帮助AI开发的例子

Huggingface 超详细介绍

Hugging Face使用入门

HuggingFace快速熟悉

HuggingFace知识库

Youtube HuggingFace视频教程

B站HuggingFace视频教程

学习Huggingface笔记

有问题可以直接咨询大语言模型，点击进入(选择使用claude-3-opus模型)

Huggingface默认的模型下载地址：C:\Users\[帐户]\.cache\huggingface\hub

典型使用大语言模型帮助AI开发的例子

点击访问大语言模型(选择使用claude-3-opus模型)

问AI：

如何从头使用HuggingFace的情感分析，根据客户的商品的评论获得客户对商品的满意度

AI回答：

使用HuggingFace进行情感分析,根据客户商品评论获得满意度,可以按照以下步骤:

1.安装必要的库

pip install transformers torch datasets

2.加载预训练模型和分词器

from transformers import AutoModelForSequenceClassification, AutoTokenizer

model_name = "uer/roberta-base-finetuned-jd-binary-chinese"  # 使用在京东二分类数据集上微调的中文RoBERTa模型

model = AutoModelForSequenceClassification.from_pretrained(model_name)

tokenizer = AutoTokenizer.from_pretrained(model_name)

3.准备客户评论数据,可以从文件读取,或定义一个评论列表,例如:

reviews = [

    "这个产品质量很好,我非常满意!",

    "收到货后有点失望,和描述的不太一样。",

    "买了好几次了,一如既往的好。",

    "服务态度不好,快递也慢,不会再买了。"

]

4.对评论进行预处理和编码

def preprocess(text):

    return tokenizer(text, padding=True, truncation=True, return_tensors='pt')

encoded_reviews = [preprocess(review) for review in reviews]

5.使用模型进行推理预测

import torch

def predict(model, encoded_text):

    with torch.no_grad():

        output = model(**encoded_text)

        scores = output.logits.softmax(dim=1)

        return scores.tolist()

results = [predict(model, encoded_review) for encoded_review in encoded_reviews]

6.解释满意度结果

for review, result in zip(reviews, results):

    pos_score, neg_score = result[0]

    print(f"评论: {review}")

    print(f"满意度: {pos_score:.2%}, 不满意度: {neg_score:.2%}")

    print()

输出示例:

评论: 这个产品质量很好,我非常满意!

满意度: 99.27%, 不满意度: 0.73%

评论: 收到货后有点失望,和描述的不太一样。 

满意度: 7.44%, 不满意度: 92.56%

评论: 买了好几次了,一如既往的好。

满意度: 99.57%, 不满意度: 0.43%

评论: 服务态度不好,快递也慢,不会再买了。

满意度: 0.38%, 不满意度: 99.62%

以上就是使用HuggingFace的Transformers库进行中文评论情感分析的完整流程。可以根据具体需求,选择合适的预训练模型,并对代码进行适当调整。对于大规模数据,还可以使用datasets库高效处理和批量预测。

Huggingface 超详细介绍

点击查看原文

Huggingface是一个流行的自然语言处理(NLP)库(NLP两派: BERT系 GPT系 ),提供了许多预训练的模型和工具,可以方便地进行各种NLP任务。

Hugginceface下载的模型默认位置：C:\Users\xn\.cache\huggingface

使用Huggingface的步骤如下:

安装Huggingface库:

首先,您需要安装Huggingface库。可以使用pip进行安装:

pip install transformers

导入所需的模块:

在Python脚本中,导入需要使用的Huggingface模块:

from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification

加载预训练模型:

Huggingface提供了许多预训练的模型,可以直接加载并使用。例如,加载一个用于文本分类的模型:

model_name = "distilbert-base-uncased-finetuned-sst-2-english"

model = AutoModelForSequenceClassification.from_pretrained(model_name)

tokenizer = AutoTokenizer.from_pretrained(model_name)

准备输入数据:

将要处理的文本转换为模型可接受的格式。通常使用分词器(Tokenizer)将文本转换为模型可以理解的数字表示。

text = "This movie was great!"

inputs = tokenizer(text, return_tensors="pt")

进行预测或推理:

使用加载的模型对输入数据进行预测或推理。

outputs = model(**inputs)

predictions = outputs.logits.argmax(dim=-1)

predicted_label = model.config.id2label[predictions.item()]

print(predicted_label)  # Output: POSITIVE

使用Pipeline简化流程:

Huggingface提供了Pipeline功能,可以简化常见任务的流程。例如,使用Sentiment Analysis Pipeline进行情感分析:

sentiment_pipeline = pipeline("sentiment-analysis")

result = sentiment_pipeline("This movie was great!")

print(result)  # Output: [{'label': 'POSITIVE', 'score': 0.9998}]

完整的示例代码:

from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification

# 加载预训练模型

model_name = "distilbert-base-uncased-finetuned-sst-2-english"

model = AutoModelForSequenceClassification.from_pretrained(model_name)

tokenizer = AutoTokenizer.from_pretrained(model_name)

# 准备输入数据

text = "This movie was great!"

inputs = tokenizer(text, return_tensors="pt")

# 进行预测

outputs = model(**inputs)

predictions = outputs.logits.argmax(dim=-1)

predicted_label = model.config.id2label[predictions.item()]

print(predicted_label)  # Output: POSITIVE

# 使用Pipeline简化流程

sentiment_pipeline = pipeline("sentiment-analysis")

result = sentiment_pipeline("This movie was great!")

print(result)  # Output: [{'label': 'POSITIVE', 'score': 0.9998}]

以上是使用Huggingface进行NLP任务的基本步骤和示例代码。Huggingface还提供了许多其他功能和模型,可以根据具体任务的需求进行选择和使用。

Hugging face 起初是一家总部位于纽约的聊天机器人初创服务商，他们本来打算创业做聊天机器人，然后在github上开源了一个Transformers库，虽然聊天机器人业务没搞起来，但是他们的这个库在机器学习社区迅速大火起来。目前已经共享了超100,000个预训练模型，10,000个数据集，变成了机器学习界的github。

其之所以能够获得如此巨大的成功，一方面是让我们这些甲方企业的小白，尤其是入门者也能快速用得上科研大牛们训练出的超牛模型。另一方面是，这种特别开放的文化和态度，以及利他利己的精神特别吸引人。huggingface上面很多业界大牛也在使用和提交新模型，这样我们就是站在大牛们的肩膀上工作，而不是从头开始，当然我们也没有大牛那么多的计算资源和数据集。

在国内huggingface也是应用非常广泛，一些开源框架本质上就是调用transfomer上的模型进行微调（当然也有很多大牛在默默提供模型和数据集）。很多nlp工程师招聘的条目上也明摆着要求熟悉huggingface transformer库的使用。简单介绍了他们多么牛逼之后，我们看看huggingface怎么玩吧。因为他既提供了数据集，又提供了模型让你随便调用下载，因此入门非常简单。你甚至不需要知道什么是GPT，BERT就可以用他的模型了（当然看看我写的BERT简介还是十分有必要的）。下面初步介绍下huggingface里面都有什么，以及怎么调用BERT模型做个简单的任务。

huggingface的官方网站：http://www.huggingface.co. 在这里主要有以下大家需要的资源。

Datasets：数据集，以及数据集的下载地址

Models：各个预训练模型

course：免费的nlp课程，可惜都是英文的

docs：文档

可以参考学习笔记：

attention与sef-attention介绍

transformer模型结构介绍

Bert简单介绍

Transformers库github地址在：https://github.com/huggingface/transformers

安装方法，在命令行执行（conda的话在anaconda propmt）：

pip install transformers # 安装最新的版本

pip install transformers == 4.0 # 安装指定版本

# 如果你是conda的话

conda install -c huggingface transformers  # 4.0以后的版本才会有

测试下安装是否成功

from transformers import pipeline  # 引入一个pipeline试试看，如果不报错说明安装成功

# 因为NLP通常是多个任务顺序而成，所以通常使用pipeline，流水线工作

一般transformer模型有三个部分组成：1.tokennizer，2.Model，3.Post processing。如下图所示，图中第二层和第三层是每个部件的输入/输出以及具体的案例。我们可以看到三个部分的具体作用：Tokenizer就是把输入的文本做切分，然后变成向量，Model负责根据输入的变量提取语义信息，输出logits；最后Post Processing根据模型输出的语义信息，执行具体的nlp任务，比如情感分析，文本自动打标签等；可见Model是其中的核心部分，Model又可以分为三种模型，针对不同的NLP任务，需要选取不同的模型类型：Encoder模型（如Bert，常用于句子分类、命名实体识别（以及更普遍的单词分类）和抽取式问答。），Decoder模型（如GPT，GPT2，常用于文本生成），以及sequence2sequence模型（如BART，常用于摘要，翻译，生成性问答等）

模型大概分为三类：

1.config

控制模型的名称、最终输出的样式、隐藏层宽度和深度、激活函数的类别等。这些参数我补齐了说明，对于初学者来说，大家一般不需要调整。这些参数都可以通过configuration类更改。

2. tokenizer（包含三个文件）

这些文件是tokenizer类生成的，或者处理的，只是处理文本，不涉及任何向量操作。

vocab.txt是词典文件（打开就是单个字符，我这里用的是bert-base-chinsese，可以看到里面都是保留符号和单个汉字索引，字符）

tokenizer.json和config是分词的配置文件，根据vocab信息和你的设置更新，里面把vocab都按顺序做了索引，将来可以根据编码生成one-hot向量，然后跟embeding训练的矩阵相乘，就可以得到该字符的向量。下图是tokenizer.json内容。

模型文件一般是tensor flow（上图中的h5文件）和py-torch（上图中的bin文件）的都有，因为作者只是单纯的在学习torch，所以以后的文章都只介绍torch。

BERT模型的使用

介绍完了模型库都有哪些内容，下面我们可以导入模型试一试怎么使用啦。

3.1 导入模型

利用官方的hub导入模型；下面导入了一个BertModel；在官方的教程中推进使用pipeline导入模型的方法；

import torch

from transformers import BertModel, BertTokenizer, BertConfig

# 首先要import进来

tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')

config = BertConfig.from_pretrained('bert-base-chinese')

config.update({'output_hidden_states':True}) # 这里直接更改模型配置

model = BertModel.from_pretrained("bert-base-chinese",config=config)

利用pipeline的方式也是一样的可以导入模型哈，方式如下：

from transformers import AutoModel

checkpoint = "bert-base-chinese"

model = AutoModel.from_pretrained(checkpoint)

因为huggingface官网在国外，自动下载可能比较费劲，笔者在公司下载速度还是非常快的。

默认下载地址在这里：

1）使用 Windows 模型保存的路径在 C:\Users\[用户名]\.cache\torch\transformers\ 目录下，根据模型的不同下载的东西也不相同

2）使用 Linux 模型保存的路径在 ~/.cache/torch/transformers/ 目录下

如果自动下载总是中断的话，可以考虑用国内的源，或者手工下载之后指定位置。（huggingface官网，选择models菜单，然后搜索自己想要的模型，然后把里面的文件下载下来，其中体积较大的有tf的有torch的，根据自己需要下载）。

import transformers

MODEL_PATH = r"D:\\test\\bert-base-chinese"

# 导入模型

tokenizer = transformers.BertTokenizer.from_pretrained(r"D:\\test\\bert-base-chinese\\bert-base-chinese-vocab.txt") 

# 导入配置文件

model_config = transformers.BertConfig.from_pretrained(MODEL_PATH)

# 修改配置

model_config.output_hidden_states = True

model_config.output_attentions = True

# 通过配置和路径导入模型

model = transformers.BertModel.from_pretrained(MODEL_PATH,config = model_config)

3.2 使用模型

上一步我们已经把模型加载进来了，在这里，尝试一下这个模型怎么样，看看能不能把相关的语义带入进来。我们之前文章介绍了bert的两个任务（MLM和NSP），这一节，我们一起测试这两个任务的效果。首先我们逐步来看看BERT每个部分的输出都是什么，我们可以看看哪些好玩的东西。

tokenizer

上面代码可以看到他实例化了BertTokenizer类，它是基于WordPiece方法的，先看看他有哪些参数：

( vocab_file，do_lower_case = True，do_basic_tokenize = True，never_split = None，unk_token = '[UNK]'，sep_token = '[SEP]'，pad_token = '[PAD]'，cls_token = '[CLS]'，mask_token = '[MASK]'，tokenize_chinese_chars = True，strip_accents = None，**kwargs )

vocab_file:这里是放置词典的地址，do_lower_case,是否都变成小写，默认是True哦，do_basic_tokenize，做wordpiece之前是否要做basic tokenize；下面的都是一些关键字的确认。还有就是是否分开中文字符，因为bert是面向英文的所有有这些设置，一般不用改，当然我们这里的案例也只是读取了预训练模型。

我们来个小案例看看，分出来的字符是什么样子的。示例如下，可以看出BERT对中文是字符级别的分词，对待英文是到sub-word级别的：

# 上文的示例代码已经实例话了，这里不重复了；

print(tokenizer.encode("生活的真谛是美和爱"))  # 对于单个句子编码

print(tokenizer.encode_plus("生活的真谛是美和爱","说的太好了")) # 对于一组句子编码

# 输出结果如下：

[101, 4495, 3833, 4638, 4696, 6465, 3221, 5401, 1469, 4263, 102]

{'input_ids': [101, 4495, 3833, 4638, 4696, 6465, 3221, 5401, 1469, 4263, 102, 6432, 4638, 1922, 1962, 749, 102], 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,

1, 1, 1, 1, 1], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

# 也可以直接这样用

sentences = ['网络安全开发分为三个层级',

             '车辆系统层级网络安全开发',

             '车辆功能层级网络安全开发',

             '车辆零部件层级网络安全开发',

             '测试团队根据车辆网络安全目标制定测试技术要求及测试计划',

             '测试团队在网络安全团队的支持下，完成确认测试并编制测试报告',

             '在车辆确认结果的基础上，基于合理的理由，确认在设计和开发阶段识别出的所有风险均已被接受',]

test1 = tokenizer(sentences)

print(test1)  # 对列表encoder

print(tokenizer("网络安全开发分为三个层级"))  # 对单个句子encoder

我们来看一下这个输出：对于单个句子是上面那种，他只输出句子tok之后的id，我们注意到已经加好[CLS],[SEP]等标识符了；（查询tokenizer可知，101是[CLS],102是[SEP]）除了input_ids之外，还自动编码了token_type_ids，attention_mask

当然除了这种直接调用模型之外，还可以利用pipeline方法来

model

model实例化了BertModel类，除了初始的 Bert、GPT 等基本模型，针对不同的下游任务，定义了 BertForQuestionAnswering，BertForMultiChoice，BertForNextSentencePrediction 以及 BertForSequenceClassification 等下游任务模型。模型导出时将生成 config.json 和 pytorch_model.bin 参数文件，这两个文件前面已将介绍了，一个是配置文件一个是torch训练后save的文件。那下面我们来看看这个怎么使用吧。因为中文是字符级的tok，所以做MLM任务不是很理想，所以下面我用英文的base模型示例一个MLM任务；

from transformers import pipeline

# 运行该段代码要保障你的电脑能够上网，会自动下载预训练模型，大概420M

unmasker = pipeline("fill-mask",model = "bert-base-uncased")  # 这里引入了一个任务叫fill-mask，该任务使用了base的bert模型

unmasker("The goal of life is [MASK].", top_k=5) # 输出mask的指，对应排名最前面的5个，也可以设置其他数字

# 输出结果如下，似乎都不怎么有效哈。

[{'score': 0.10933303833007812,

  'token': 2166,

  'token_str': 'life',

  'sequence': 'the goal of life is life.'},

 {'score': 0.03941883146762848,

  'token': 7691,

  'token_str': 'survival',

  'sequence': 'the goal of life is survival.'},

 {'score': 0.032930608838796616,

  'token': 2293,

  'token_str': 'love',

  'sequence': 'the goal of life is love.'},

 {'score': 0.030096106231212616,

  'token': 4071,

  'token_str': 'freedom',

  'sequence': 'the goal of life is freedom.'},

 {'score': 0.024967126548290253,

  'token': 17839,

  'token_str': 'simplicity',

  'sequence': 'the goal of life is simplicity.'}]

任务训练

废话不多说了，上代码，大家去看详细的代码注释吧，由于设置多个epoch和较大的batchsize，我的电脑完全带动不起来，大家放到gpu计算，记得to device到GPU上。拷贝下来直接就能用。

# _*_ coding:utf-8 _*_

# 利用深度学习做情感分析，基于Imdb 的50000个电影评论数据进行；

import torch

from torch.utils.data import DataLoader,Dataset

import os

import re

from random import sample

import numpy as np

import torch.nn as nn

import torch.nn.functional as F

import torch.optim as optim

from transformers import BertModel, BertTokenizer

from tqdm import tqdm

# 路径需要根据情况修改，要看你把数据下载到哪里了

# 数据下载地址在斯坦福官网，网上搜索就有

data_base_path = r"./imdb_test/aclImdb"

# 这个里面是存储你训练出来的模型的，现在是空的

model_path = r"./imdb_test/aclImdb/mode"

#1. 准备dataset，这里写了一个数据读取的类，并把数据按照不同的需要进行了分类；

class ImdbDataset(Dataset):

    def __init__(self,mode,testNumber=10000,validNumber=5000):

        # 在这里我做了设置，把数据集分成三种形式，可以选择 “train”默认返回全量50000个数据，“test”默认随机返回10000个数据，

        # 如果是选择“valid”模式，随机返回相应数据

        super(ImdbDataset,self).__init__()

        # 读取所有的训练文件夹名称

        text_path =  [os.path.join(data_base_path,i)  for i in ["test/neg","test/pos"]]

        text_path.extend([os.path.join(data_base_path,i)  for i in ["train/neg","train/pos"]])

        if mode=="train":

            self.total_file_path_list = []

            # 获取训练的全量数据，因为50000个好像也不算大，就没设置返回量，后续做sentence的时候再做处理

            for i in text_path:

                self.total_file_path_list.extend([os.path.join(i,j) for j in os.listdir(i)])

        if mode=="test":

            self.total_file_path_list = []

            # 获取测试数据集，默认10000个数据

            for i in text_path:

                self.total_file_path_list.extend([os.path.join(i,j) for j in os.listdir(i)])

            self.total_file_path_list=sample(self.total_file_path_list,testNumber)

        if mode=="valid":

            self.total_file_path_list = []

            # 获取验证数据集，默认5000个数据集

            for i in text_path:

                self.total_file_path_list.extend([os.path.join(i,j) for j in os.listdir(i)])

            self.total_file_path_list=sample(self.total_file_path_list,validNumber)

    def tokenize(self,text):

        # 具体要过滤掉哪些字符要看你的文本质量如何

        # 这里定义了一个过滤器，主要是去掉一些没用的无意义字符，标点符号，html字符啥的

        fileters = ['!','"','#','$','%','&','\(','\)','\*','\+',',','-','\.','/',':',';','<','=','>','\?','@'

            ,'\[','\\','\]','^','_','`','\{','\|','\}','~','\t','\n','\x97','\x96','”','“',]

        # sub方法是替换

        text = re.sub("<.*?>"," ",text,flags=re.S) # 去掉<...>中间的内容，主要是文本内容中存在<br/>等内容

        text = re.sub("|".join(fileters)," ",text,flags=re.S) # 替换掉特殊字符，'|'是把所有要匹配的特殊字符连在一起

        return text # 返回文本

    def __getitem__(self, idx):

        cur_path = self.total_file_path_list[idx]

   # 返回path最后的文件名。如果path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素。

        # cur_filename返回的是如：“0_3.txt”的文件名

        cur_filename = os.path.basename(cur_path)

        # 标题的形式是：3_4.txt 前面的3是索引，后面的4是分类

        # 如果是小于等于5分的，是负面评论，labei给值维1，否则就是1

        labels = []

        sentences = []

        if int(cur_filename.split("_")[-1].split(".")[0]) <= 5 :

            label = 0

        else:

            label = 1

        # temp.append([label])

        labels.append(label)

        text = self.tokenize(open(cur_path,encoding='UTF-8').read().strip()) #处理文本中的奇怪符号

        sentences.append(text)

        # 可见我们这里返回了一个list，这个list的第一个值是标签0或者1，第二个值是这句话；

        return sentences,labels

    def __len__(self):

        return len(self.total_file_path_list)

# 2. 这里开始利用huggingface搭建网络模型

# 这个类继承再nn.module,后续再详细介绍这个模块

# 

class BertClassificationModel(nn.Module):

    def __init__(self,hidden_size=768):

        super(BertClassificationModel, self).__init__()

        # 这里用了一个简化版本的bert

        model_name = 'distilbert-base-uncased'

        # 读取分词器

        self.tokenizer = BertTokenizer.from_pretrained(pretrained_model_name_or_path=model_name)

        # 读取预训练模型

        self.bert = BertModel.from_pretrained(pretrained_model_name_or_path=model_name)

        for p in self.bert.parameters(): # 冻结bert参数

                p.requires_grad = False

        self.fc = nn.Linear(hidden_size,2)

    def forward(self, batch_sentences):   # [batch_size,1]

        sentences_tokenizer = self.tokenizer(batch_sentences,

                                             truncation=True,

                                             padding=True,

                                             max_length=512,

                                             add_special_tokens=True)

        input_ids=torch.tensor(sentences_tokenizer['input_ids']) # 变量

        attention_mask=torch.tensor(sentences_tokenizer['attention_mask']) # 变量

        bert_out=self.bert(input_ids=input_ids,attention_mask=attention_mask) # 模型

        last_hidden_state =bert_out[0] # [batch_size, sequence_length, hidden_size] # 变量

        bert_cls_hidden_state=last_hidden_state[:,0,:] # 变量

        fc_out=self.fc(bert_cls_hidden_state) # 模型

        return fc_out

# 3. 程序入口，模型也搞完啦，我们可以开始训练，并验证模型的可用性

def main():

    testNumber = 10000    # 多少个数据参与训练模型

    validNumber = 100   # 多少个数据参与验证

    batchsize = 250  # 定义每次放多少个数据参加训练

    trainDatas = ImdbDataset(mode="test",testNumber=testNumber) # 加载训练集,全量加载，考虑到我的破机器，先加载个100试试吧

    validDatas = ImdbDataset(mode="valid",validNumber=validNumber) # 加载训练集

    train_loader = torch.utils.data.DataLoader(trainDatas, batch_size=batchsize, shuffle=False)#遍历train_dataloader 每次返回batch_size条数据

    val_loader = torch.utils.data.DataLoader(validDatas, batch_size=batchsize, shuffle=False)

    # 这里搭建训练循环，输出训练结果

    epoch_num = 1  # 设置循环多少次训练，可根据模型计算情况做调整，如果模型陷入了局部最优，那么循环多少次也没啥用

    print('training...(约1 hour(CPU))')

    # 初始化模型

    model=BertClassificationModel()

    optimizer = optim.AdamW(model.parameters(), lr=5e-5) # 首先定义优化器，这里用的AdamW，lr是学习率，因为bert用的就是这个

    # 这里是定义损失函数，交叉熵损失函数比较常用解决分类问题

    # 依据你解决什么问题，选择什么样的损失函数

    criterion = nn.CrossEntropyLoss()

    print("模型数据已经加载完成,现在开始模型训练。")

    for epoch in range(epoch_num):

        for i, (data,labels) in enumerate(train_loader, 0):

            output = model(data[0])

            optimizer.zero_grad()  # 梯度清0

            loss = criterion(output, labels[0])  # 计算误差

            loss.backward()  # 反向传播

            optimizer.step()  # 更新参数

            # 打印一下每一次数据扔进去学习的进展

            print('batch:%d loss:%.5f' % (i, loss.item()))

        # 打印一下每个epoch的深度学习的进展i

        print('epoch:%d loss:%.5f' % (epoch, loss.item()))

    #下面开始测试模型是不是好用哈

    print('testing...(约2000秒(CPU))')

    # 这里载入验证模型，他把数据放进去拿输出和输入比较，然后除以总数计算准确率

    # 鉴于这个模型非常简单，就只用了准确率这一个参数，没有考虑混淆矩阵这些

    num = 0

    model.eval()  # 不启用 BatchNormalization 和 Dropout，保证BN和dropout不发生变化,主要是在测试场景下使用；

    for j, (data,labels) in enumerate(val_loader, 0):

        output = model(data[0])

        # print(output)

        out = output.argmax(dim=1)

        # print(out)

        # print(labels[0])

        num += (out == labels[0]).sum().item()

        # total += len(labels)

    print('Accuracy:', num / validNumber)

if __name__ == '__main__':

    main()

Hugging Face使用入门

点击查看原文

点击进入Hugging Face

Hugging Face的主要功能都在最上面的一行，包括：模型（Models）、数据集（Datasets）、空间（Spaces）。其他还有：说明文档（Docs）、解决方案（Solutions）、报价（Pricing）。另外在折叠的菜单里，还有交流社区（Community）、以及机器学习的一些课程等等。

在这里，我们先着重说一下这个Spaces。这是Hugging Face区别于github的一个特殊功能。就是可以把你的模型和代码运行在它的服务器上，并且可以公开提供给别人用！

具体怎么做呢？举个简单的例子：现在大火的ChatGPT很好玩，但是由于众所周知的原因，不给我们用了！爬墙又很麻烦，梯子有可能不稳定，普通人也不会用。Hugging Face这时候就派上用场了！因为它是个美国网站，且没有被墙，它的服务都运行在美国，所以在这上面用你的ChatGPT API Key就不会被封！

打开这个Space：Chatgpt Demo - a Hugging Face Space by cuiyuan605

就可以用你的OpenAI API Key跟ChatGPT畅聊了！

如果你觉得用别人的Space不放心，那可以将它一键克隆到你的账号

Hugging Face提供了三种动态交互的方式：Gradio、Streamlit和Docker。

这里重点说一下Gradio，这是一个python的web服务库。是专门为机器学习应用，封装的一个前后端库。用法很简单

我们先用一个简单的例子，让你可以快速用起来。

首先，创建一个Space，Space SDK选择Gradio：

然后，在Files中创建文件requirements.txt，用于指定项目的依赖库。比如在这里，我们可以将文件内容编辑为：

transformers

torch

接下来，创建文件app.py，用于实现交互界面。我们将文件内容编辑为：

import gradio as gr  

def greet(name): 

    return "Hello " + name + "!!" 

iface = gr.Interface(fn=greet, inputs="text", outputs="text") 

iface.launch()

保存文件后，点击App选项页，等它build一会儿，一个简单的Gradio项目就成功啦！

之后每次更新仓库，都会重新构建和启动App，你也可以用git把项目拉到本地进行开发，开发完成后上传代码，方法和github一样。clone的地址在Settings后面那个三个点的菜单里。

是不是是很简单，是不是打开了一个新世界的大门，只要把项目设为public，就可以将服务提供给其他人用啦。不过免费的空间只有2CPU和16G内存，且每48小时就会将你的服务自动停止。需要更长的服务时间，更多硬件资源，甚至GPU资源，那就需要马内了，毕竟世上没有免费的午餐！

下面的Streamlit和Docker只做简单的介绍。

Streamlit也是一个python的前后端库，只不过它并不是专为机器学习应用开发的，而是更偏向于可视化数据展示。此外，它还有个重要的功能，就是能够把页面嵌入到其他的网站，也就是说你可以把Hugging Face上服务，嵌入到你的个人网站里！开不开心，意不意外！具体方法可以参考文档：Streamlit Spaces

至于Docker则是一个更加独立自由的空间，用过的都说好！具体使用方法可以参考官方文档：Your First Docker Space: Text Generation with T5

这里顺便说一下，Docker这个示例是跑不通的！官方文档写错了，需要把Dockerfile的最后一行：

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

改为：

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

除了Spaces以外，Hugging Face还提供了各路大佬上传的各种模型和数据集，让我们可以站在大佬的肩膀上看世界，不用苦逼的造轮子。

不过模型和数据文件一般都比较大，需要用到lfs(Large File Storge)大文件存储，用之前记得先装一下：

git lfs intall

然后git clone走起

我们除了可以直接下载这些模型和数据集以外，还可以对模型进行自动训练。

或者直接将模型部署为API或者Space

数据集的clone地址藏在这里哦：

下面，我们就开心的玩起来吧！

Huggingface快速熟悉

HuggingFace 10分钟快速入门（一）

HuggingFace快速入门（二），利用AI模型快速搭建APP

HuggingFace 快速入门（三），HF的Agent快速搭建AI Agent

agent自动串联模型输出结果,点击进入hugging face agent的文档

agent简化调用一个命令下去就得到所要结果

需要安装hugingface_hub

pip install huggingface_hub>=0.14.1 git+https://github.com/huggingface/huggingface_hub

Youtube HuggingFace视频教程

B站HuggingFace视频教程

点击进入原视频

学习Huggingface笔记

tokenizer作用

模型的tokenizer规整输入的文本为id，以便输入到模型处理

from transformers import  AutoTokenizer

checkpoint="distilbert-base-uncased-finetuned-sst-2-english" #根据这个模型所对应的来加载

tokenizer=AutoTokenizer.from_pretrained(checkpoint) 

raw_inputs=[

"I've been waiting for a this course ny whole life.",

"I hate this so much!",

inputs =tokenizer(raw_inputs,padding=True,truncation=True,return_tensors="pt") 

print(inputs)

模型的加载与使用

from transformers import AutoModel

checkpoint="distilbert-base-uncased-finetuned-sst-2-english"

model=Autowodel.from_pretrained(checkpoint)

outputs=model(**inputs)