【Bert】文本多标签分类

BERT实现多标签文本分类:强大模型的应用与展望 通过修改BERT的输出层、使用标签嵌入技术和结合其他技术,我们可以构建高效的多标签分类模型。在多标签文本分类中,一个重要的挑战是如何处理标签之间的相关性。为了实现多标签文本分类,一种常见的方法是修改BERT的输出层以产生多个输出。在训练过程中,我们使用交叉熵损失来优化模型,使得对于每个标签,模型预测的概率分布接近于真实的标签分布。然后,在预测阶段,模型不仅考虑文本内容,还考虑标签之间的关系。然而,传统的文本分类通常只处理单标签分类问题,即每个文本只能被标记为一个特定的类别。 阅读详情

1. 算法介绍

1.1 参考文献

复旦大学邱锡鹏老师课题组的研究论文《How to Fine-Tune BERT for Text Classification?》。

论文: https://arxiv.org/pdf/1905.05583.pdf

https://mp.weixin.qq.com/s/9MrgIz2bchiCjUGpz6MbGQ

1.2 论文思路

旨在文本分类任务上探索不同的BERT微调方法并提供一种通用的BERT微调解决方法。这篇论文从三种路线进行了探索:

  • (1) BERT自身的微调策略,包括长文本处理、学习率、不同层的选择等方法;

  • (2) 目标任务内、领域内及跨领域的进一步预训练BERT;

  • (3) 多任务学习。微调后的BERT在七个英文数据集及搜狗中文数据集上取得了当前最优的结果。

1.3 代码来源

作者的实现代码: https://github.com/xuyige/BERT4doc-Classification

数据集来源:https://www.kaggle.com/shivanandmn/multilabel-classification-dataset?select=train.csv

项目地址:https://www.kaggle.com/shivanandmn/multilabel-classification-dataset

该数据集包含 6 个不同的标签(计算机科学、物理、数学、统计学、生物学、金融),根据摘要和标题对研究论文进行分类。标签列中的值 1 表示标签属于该标签。每个论文有多个标签为 1。

2. 代码实践

2.1 Import

#2.1 Import

#关于torch的安装可以参考https://blog.youkuaiyun.com/Checkmate9949/article/details/119494673?spm=1001.2014.3001.5501
import torch
from transformers import BertTokenizerFast as BertTokenizer
from utils.plot_results import plot_results
from resources.train_val_model import train_model
from resources.get_data import get_data
from resources.build_model import BertClassifier
from resources.test_model import test_model
from resources.build_dataloader import build_dataloader

2.2 Get data: 分割样本

2.2 Get data

##################################
#            get data
##################################

#该函数见2.2.1
train_df, val_df, test_df = get_data()

# fixed parameters
#Columns: 第三行到倒数第二行
label_columns = train_df.columns.tolist()[3:-1]

num_labels = len(label_columns)
max_token_len = 30


# BERT_MODEL_NAME = "bert-base-uncased"
# bert-base-uncased: for English. bert-base-Chinese
BERT_MODEL_NAME = "model/bert-base-uncased"
#分词
tokenizer = BertTokenizer.from_pretrained(BERT_MODEL_NAME)
def get_data():
    df = pd.read_csv("data/train.csv")
#把标题和摘要合并作为TEXT
    df["TEXT"] = df["TITLE"] + df["ABSTRACT"]

    label_columns = df.columns.tolist()[3:-1]
    print(df[label_columns].sum().sort_values())
#Split data in to train and test: 训练集占比80%
    test_df, train_df = train_test_split(df, test_size=0.8, random_state=42)
#Split data in to valid and test: 分别占比50%
    test_df, val_df = train_test_split(test_df, test_size=0.5, random_state=42)
#输出数据集
    return train_df, val_df, test_df

2.3 Build data loaders 

##################################
#        build data loaders
##################################
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

#训练集使随机抽样random sample
#val and test: squential sample
train_dataloader = build_dataloader(
    train_df, label_columns, tokenizer, max_token_len, trainset=True
)
val_dataloader = build_dataloader(val_df, label_columns, tokenizer, max_token_len)
test_dataloader = build_dataloader(test_df, label_columns, tokenizer, max_token_len)
build_dataloader

import os
import torch
from torch.utils.data import Dataset, DataLoader
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler

#df=train_df

os.environ["TOKENIZERS_PARALLELISM"] = "false"


class text_dataset(Dataset):
    def __init__( df, label_columns, tokenizer, max_token_len):
        data = df
        label_columns = label_columns
        tokenizer = tokenizer
        max_token_len = max_token_len

#返回数据长度
    def __len__(self):
        return len(data)

#根据index获取item
#index=3
    def __getitem__( index):
        data_row = data.iloc[index]
        text = data_row["TEXT"]
        labels = data_row[label_columns]
        encoding = tokenizer.encode_plus(
            text,
            add_special_tokens=True,
            max_length=max_token_len,
            return_token_type_ids=False,
            padding="max_length",
            truncation=True,
            return_attention_mask=True,
            return_tensors="pt",
        )
        return dict(
            text=text,
            input_ids=encoding["input_ids"].flatten(),
            attention_mask=encoding["attention_mask"].flatten(),
            labels=torch.FloatTensor(labels),
        )
#test=__getitem__( index)

def build_dataloader(df, label_columns, tokenizer, max_token_len, trainset=False):
    dataset = text_dataset(df, label_columns, tokenizer, max_token_len)

#随机抽取样本
    if trainset:
        sampler = RandomSampler(df)
#有次序地抽取样本
    else:
        sampler = SequentialSampler(df)

    return DataLoader(dataset, batch_size=10, sampler=sampler)

2.4 Build model

##################################
#        build model
##################################

bert_classifier = BertClassifier(
    num_labels=num_labels, BERT_MODEL_NAME=BERT_MODEL_NAME, freeze_bert=False
)
import torch
import torch.nn as nn
from transformers import BertModel

class BertClassifier(nn.Module):
    def __init__(self, num_labels: int, BERT_MODEL_NAME, freeze_bert=False):
        super().__init__()
        self.num_labels = num_labels
        self.bert = BertModel.from_pretrained(BERT_MODEL_NAME)

        #  hidden size of BERT, hidden size of our classifier, and number of labels to classify
        D_in, H, D_out = self.bert.config.hidden_size, 50, num_labels

        # Instantiate an one-layer feed-forward classifier
        self.classifier = nn.Sequential(
            nn.Dropout(p=0.3),
            nn.Linear(D_in, H),
            nn.ReLU(),
            nn.Dropout(p=0.3),
            nn.Linear(H, D_out),
        )
        # loss
        self.loss_func = nn.BCEWithLogitsLoss()

        if freeze_bert:
            print("freezing bert parameters")
            for param in self.bert.parameters():
                param.requires_grad = False

    def forward(self, input_ids, attention_mask, labels=None):
        outputs = self.bert(input_ids, attention_mask=attention_mask)

        # Extract the last hidden state of the token `[CLS]` for classification task
        last_hidden_state_cls = outputs[0][:, 0, :]

        logits = self.classifier(last_hidden_state_cls)

        if labels is not None:
            predictions = torch.sigmoid(logits)
            loss = self.loss_func(
                predictions.view(-1, self.num_labels), labels.view(-1, self.num_labels)
            )
            return loss
        else:
            return logits

2.5 训练模型,并且通过validation选择最佳参数

##################################
#     train and validate model
##################################

trained_model, training_stats, train_loss_set = train_model(
    bert_classifier,
    train_dataloader,
    val_dataloader=val_dataloader,
    epochs=5,
    evaluation=True,
)

plot_results(training_stats, train_loss_set)
import time
import random
import numpy as np
import torch
from utils.helper_functions import format_time
from transformers import AdamW, get_linear_schedule_with_warmup


def train_model(
    model, train_dataloader, val_dataloader=None, epochs=5, evaluation=False
):
    """Train and validate the BertClassifier model."""
    training_stats = []
    train_loss_set = []
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)
    optimizer, scheduler = build_optimizer_scheduler(
        model=model, epochs=epochs, train_dataloader=train_dataloader
    )
    print("Start training...\n")
    for epoch_i in range(epochs):
        # =======================================
        #               Training
        # =======================================
        print(
            f"{'Epoch':^7} | {'Batch':^7} | {'Train Loss':^12} | {'Val Loss':^10} | {'Val Acc':^9} | {'Elapsed':^9}"
        )
        print("-" * 70)
        t0 = time.time()
        t0_epoch, t0_batch = time.time(), time.time()
        total_loss, batch_loss, batch_counts = 0, 0, 0

        model.train()

        for step, batch in enumerate(train_dataloader):
            batch_counts += 1
            b_input_ids = batch["input_ids"].to(device)
            b_attention_mask = batch["attention_mask"].to(device)
            b_labels = batch["labels"].to(device)
            # b_attention_mask, b_labels = tuple(t.to(device) for t in batch)

            model.zero_grad()

            loss = model(
                input_ids=b_input_ids,
                attention_mask=b_attention_mask,
                labels=b_labels,
            )
            batch_loss += loss.item()
            total_loss += loss.item()
            train_loss_set.append(loss.item())

            loss.backward()

            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
            optimizer.step()
            scheduler.step()

            # Print the loss values and time elapsed for every 20 batches
            if (step % 20 == 0 and step != 0) or (step == len(train_dataloader) - 1):
                time_elapsed = time.time() - t0_batch
                print(
                    f"{epoch_i + 1:^7} | {step:^7} | {batch_loss / batch_counts:^12.6f} | {'-':^10} | {'-':^9} | {time_elapsed:^9.2f}"
                )
                # Reset batch tracking variables
                batch_loss, batch_counts = 0, 0
                t0_batch = time.time()

        # Calculate the average loss over the entire training data
        avg_train_loss = total_loss / len(train_dataloader)
        training_time = format_time(time.time() - t0)

        print("-" * 70)

        # =======================================
        #               Evaluation
        # =======================================
        if evaluation == True:
            avg_val_loss, avg_val_accuracy, validation_time = evaluate(
                model, val_dataloader
            )
            time_elapsed = time.time() - t0_epoch
            print(
                f"{epoch_i + 1:^7} | {'-':^7} | {avg_train_loss:^12.6f} | {avg_val_loss:^10.6f} | {avg_val_accuracy:^9.2f} | {time_elapsed:^9.2f}"
            )
            print("-" * 70)

        # save model
        if (
            len(training_stats) == 0
            or training_stats[-1]["Valid. Loss"] > avg_train_loss
        ):
            model_dir = "model/model.pt"
            torch.save(model.state_dict(), model_dir)

        training_stats.append(
            {
                "epoch": epoch_i + 1,
                "Training Loss": avg_train_loss,
                "Valid. Loss": avg_val_loss,
                "Valid. Accur.": avg_val_accuracy,
                "Training Time": training_time,
                "Validation Time": validation_time,
            }
        )

    print("\n")
    print("Training complete!")
    return model, training_stats, train_loss_set


def evaluate(model, val_dataloader):
    """After the completion of each training epoch, measure the model's performance
    on our validation set.
    """
    # Put the model into the evaluation mode. The dropout layers are disabled during
    # the test time.
    t0 = time.time()
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)
    model.eval()

    # Tracking variables
    avg_val_accuracy = []
    avg_val_loss = []

    # For each batch in our validation set...
    for batch in val_dataloader:
        b_input_ids = batch["input_ids"].to(device)
        b_attention_mask = batch["attention_mask"].to(device)
        b_labels = batch["labels"].to(device)

        # Compute logits
        with torch.no_grad():
            logits = model(b_input_ids, b_attention_mask)

        # Compute loss
        loss_func = model.loss_func
        predictions = torch.sigmoid(logits)
        loss = loss_func(
            predictions.view(-1, model.num_labels), b_labels.view(-1, model.num_labels)
        )
        avg_val_loss.append(loss.item())

        # Get the predictions
        preds = torch.round(predictions)

        # Calculate the accuracy rate
        accuracy = (preds == b_labels).cpu().numpy().mean() * 100
        avg_val_accuracy.append(accuracy)

    # Compute the average accuracy and loss over the validation set.
    avg_val_loss = np.mean(avg_val_loss)
    avg_val_accuracy = np.mean(avg_val_accuracy)
    validation_time = format_time(time.time() - t0)
    return avg_val_loss, avg_val_accuracy, validation_time


def build_optimizer_scheduler(model, epochs, train_dataloader):

    # setting custom optimization parameters for huggingface model and implement a scheduler here as well.
    param_optimizer = list(model.named_parameters())
    no_decay = ["bias", "gamma", "beta"]
    optimizer_grouped_parameters = [
        {
            "params": [
                p for n, p in param_optimizer if not any(nd in n for nd in no_decay)
            ],
            "weight_decay_rate": 0.01,
        },
        {
            "params": [
                p for n, p in param_optimizer if any(nd in n for nd in no_decay)
            ],
            "weight_decay_rate": 0.0,
        },
    ]

    optimizer = AdamW(
        optimizer_grouped_parameters,
        lr=5e-5,  # Default learning rate
        eps=1e-8,  # Default epsilon value
    )

    total_steps = len(train_dataloader) * epochs
    scheduler = get_linear_schedule_with_warmup(
        optimizer,
        num_warmup_steps=0,  # Default value
        num_training_steps=total_steps,
    )

    return optimizer, scheduler

2.6 测试模型

##################################
#           test model
##################################

test_model(
    test_dataloader=test_dataloader,
    BERT_MODEL_NAME=BERT_MODEL_NAME,
    num_labels=num_labels,
    label_columns=label_columns,
)

基于 BERT 实现的情感分析(文本分类)----概念与应用 一文详解Bert的发展由来,及如何使用Bert模型实现情感分析(文本分类任务) 阅读详情

相关推荐

用pytorch进行BERT文本分类

对于我们在上面看到的句子分类示例,我们只关注第一个位置的输出(将特殊的 [CLS] token 传递到该位置)。就像Transformer的普通编码器一样,BERT 将一系列单词作为输入,这些单词不断向上流动。sport(体育),business(商业),politics(政治),tech(科技),entertainment(娱乐)。有4个400多MB的文件,pytorch的模型对应的是436MB的那个文件。最后一步测试的时候,测试的准确率还是比较高的。可以用下面的代码查看model里面的模型。

闲人的专栏 5413

Bert模型做多标签文本分类

参考链接 BERT模型的详细介绍 图解BERT模型:从零开始构建BERT (强推)李宏毅2021春机器学习课程 我们现在来说,怎么把Bert应用到多标签文本分类的问题上。注意,本文的重点是Bert的应用,对多标签文本分类的介绍并不全面 单标签文本分类 对应单标签文本分类来说,例如二元的文本分类,我们首先用一层或多层LSTM提取文本序列特征,然后接一个dropout层防止过拟合,最后激活函数采用sigmoid,或者计算损失的时候使用sigmoid交叉熵损失函数。对于多元分类则激活函数采用softmax,其它没

孤独腹地的博客 1万+

【NLP修炼系列之Bert】Bert多分类&多标签文本分类实战(附源码)

本文是Bert文本多分类和多标签文本分类实战,其中多分类项目是借鉴github中被引用次数比较多的优秀项目,多标签文本分类是我在公司业务中实际用到的线上项目,今天把两个项目都介绍给大家,其实Bert做文本分类项目都大差不差,两个项目的项目结构也都差不多,这样更容易被初学者迅速入手和理解。文本多分类任务用到的数据集是THUCNews数据集中抽取20w新闻标题,文本长度在20-30之间,一共10个类别,每个类别2万条。类别:财经、房产、股票、教育、科技、社会、时政、体育、游戏、娱乐。

二狗的博客 1160

NLP(三十六)使用keras-bert实现文本多标签分类任务

本文将会介绍如何使用keras-bert实现文本多标签分类任务,其中对BERT进行微调。 项目结构 数据集介绍 模型训练 模型评估 模型预测 总结

山阴少年 8128

【NLP】使用 BERT 和 PyTorch Lightning 进行多标签文本分类

了解如何为多标签文本分类(标记)准备带有恶意评论的数据集。我们将使用 PyTorch Lightning 微调 BERT 并评估模型。多标签文本分类(或标记文本)是您在执行 NLP 时会遇到的最常见任务之一。现代基于 Transformer 的模型(如 BERT)利用对大量文本数据的预训练,可以更快地进行微调,使用更少的资源并且在较小的(更)数据集上更准确。我们的模型对有害文本检测有用吗?数据我们的数据集包含潜在的攻击性(有毒)评论,来自。我们有文字(评论)和六种不同的毒性标签。

sikh_0529的博客 4622

Bert_Classifier:bert文本分类,albert,keras_bert,bert4keras,kashgari,fastbert,flask + uwsgi + keras部署模型,时间实体识别,tfidf关键词抽取,tfidf文本相似度

1、run_cnews_classifier.py 原生bert实现的文本分类 原文链接: 2、run_tnews_classifier.py 基于keras_bert实现的文本分类 原文链接: 3、run_lcqmc_similarity.py 基于bert4keras实现的文本相似度计算 原文链接: 4、run_kashgari_classifier.py 基于kashgari实现的文本分类 原文链接: 5、run_ChineseDailyNerCorpus.py 基于kashgari + bert/albert实现的ner 原文链接: 6、Bert_Train.py 基于bert训练模型,并保存为pb格式 原文链接: 7、Bert_Predict.py requests调用tf serving中的bert模型 原文链接: 8、fastbert.py 基于fastbert实现文本分类

【多标签文本分类】BERT for Sequence-to-Sequence Multi-Label Text Classification

·阅读摘要:   本文在已有的SGM和BERT模型上改进,提出了SGM+BERT模型、混合模型。实验证明SGM+BERT模型收敛比BERT快很多,混合模型的效果最好。 ·参考文献:   [1] BERT for Sequence-to-Sequence Multi-Label Text Classification   [2] SGM模型讲解,参考博客:【多标签文本分类】SGM: Sequence Generation Model for Multi-Label Classification   [3] .

十一月廿七风雨大作 8027

金融科技创新中人工智能的应用:8篇优质论文精选(含2023)

随着科技的飞速发展,金融领域正经历着前所未有的变革。在这个过程中,人工智能技术发挥着越来越重要的作用。为了深入探讨金融人工智能的研究和应用,享享特地整理了几篇金融人工智能方面的论文,大家可以看一下金融人工智能方向最新的研究成果!面向金融领域的大型语言模型本文介绍了BloombergGPT,一个基于广泛金融数据训练的500亿参数模型。基于彭博(Bloomberg)广泛数据来源,建立了一个基于彭博数据的3630亿令牌数据集,并结合了额外3450亿通用数据令牌。

2401_82426425的博客 3213

如何用 Python 和 BERT 做多标签(multi-label)文本分类?

10余行代码,借助 BERT 轻松完成多标签(multi-label)文本分类任务。疑问之前我写了《如何用 Python 和 BERT 做中文文本二元分类?》一文,为你讲...

玉树芝兰 8752

sentaurus学习笔记(VDMOS仿真)(三)

在Sentaurus中,这通常意味着在2D仿真中,x轴指向下,y轴指向右。定义了在2D模拟中,网格尺寸按照一定的增长率进行扩展,这里的增长率为2.0,意味着远离最小尺寸区域的网格单元大小将是最小尺寸的两倍。定义了2D模拟中网格单元的最小尺寸为0.001微米,这有助于控制网格的最小大小,从而影响仿真的精度和计算成本。表示启用中等级别的日志信息输出,这有助于用户了解仿真过程中发生的事件和可能的问题。表示启用保存调试文件,这可以帮助用户在仿真过程中检查和验证模型的状态。这行代码设置了仿真过程中使用的线程数。

qq_52640792的博客 1809

TCGA数据下载保姆级教程:用GDC-client从零搞定,附配置文件避坑指南

本文提供TCGA数据下载的完整教程,详细讲解如何使用GDC-client工具从零开始配置到高效获取基因组数据。涵盖环境准备、认证配置、数据检索、高效下载及故障处理等关键步骤,并附配置文件避坑指南,帮助生物医学研究者快速掌握TCGA数据下载技巧。

weixin_30892037的博客 266

Bert系列:基于Bert微调快速实现多标签文本分类

文本分类是指对形如文章,新闻,舆情,评论,用户输入的词条等自然语言文本数据,根据某个业务维度进行自动归类的技术。 多标签分类是指文本可以被归类为一种或者多种不同的类目下,同一个文本实例可以有多个类别标签。相比于多元分类(文本只能归属于一类),多标签文本分类在实际的场景中更为常见,例如

bugyinyin的博客 2744

ColorOS13系统账户锁与密码锁破解全指南:从恢复模式到激活绕过

本文针对ColorOS13系统用户,详细解析了忘记锁屏密码(数字/图案锁)和遭遇OPPO账户锁(激活锁)的合法解决方案。核心是通过官方恢复模式进行格式化操作清除锁屏密码,并强调账户锁需通过密码找回或官方售后等正规途径解除。文章旨在帮助设备合法所有者恢复使用权,并提供了安全操作指南与数据备份建议。

weixin_28304023的博客 969

Bert-Multi-Label-Text-Classification: 利用BERT进行多标签文本分类的高效解决方案

该项目是基于谷歌的预训练模型BERT(Bidirectional Encoder Representations from Transformers),用于执行多标签文本分类任务。如果你的工作或研究涉及到对文本数据进行分类,尤其当需要处理的标签不止一个时,此项目将是一个强大的工具。 ## **项目简介** 是一个开源的Python实现,它利用transformers库(由Hugging Fa

gitblog_00032的博客 1290

沉降预测算法-指数曲线法

沉降预测的指数曲线法原理和代码实现

yh523的博客 1010

华为自研 ERP、Oracle EBS 与 SAP 上线时系统配置思路设计差异深度分析

本文对比分析了华为自研ERP、Oracle EBS和SAP S/4HANA三大ERP系统在上线配置思路上的核心差异。从架构设计看,华为采用分布式微服务架构,SAP采用分层服务架构,Oracle采用集中式一体化架构;在模块配置上,华为以业务场景为导向,SAP基于行业模板,Oracle强调模块独立性;数据迁移方面,华为侧重业务规则清洗,SAP注重数据质量监控,Oracle依赖标准化工具;流程适配上,华为系统随流程调整,SAP在框架内优化,Oracle需定制开发;定制开发模式差异明显,华为采用插件化扩展,SAP使

金牌架构师 1456

Bert实现多标签文本分类

多标签文本分类 Bert简介 两个任务 Bert是按照两个任务进行预训练的,分别是遮蔽语言任务(Masked Language Model)和句子预测任务(NextSentence Prediction)。 遮蔽语言任务(Masked Language Model) 对输入的语句中的字词 随机用 [MASK] 标签覆盖,然后模型对mask位置的单词进行预测。这个过程类似CBOW训练的过程,我们利用这个训练任务从而得到每个字符对应的embedding。特别的,[CLS]字符的embedding我们可以视为整个

孤独腹地的博客 1万+

DSP篇--C6678功能调试系列之SPI调试

SPI传输数据分为线上直接收发和通过EDMA的数据传输两种。第一种是直接将数据放在线上(SPIDAT1),在寄存器(SPIBUF)中写入命令实现数据的收发;第二种需要配置EDMA,将数据buffer直接作为EDMA的数据源进行传输,其需要配置的参数和中断与EDMA一致。

nanke_yh的博客 1261

Bert多标签文本分类开源项目指南

Bert多标签文本分类项目致力于解决自然语言处理(NLP)领域中的一个关键任务——多标签文本分类。该项目利用预训练的BERT模型从Hugging Face库中提取特征,结合PyTorch框架实现对科学论文的自动标签分配。每一篇论文可能涉及多个主题或领域,因此这是一个典型的多标签分类场景。 **项目特点**: - **深度集成BERT**: 利用了BERT的强大语言理解能力。 - **多标签支持

gitblog_00515的博客 1150

怎么调用onenet平台的API从而读取我们的设备数据和下发命令,做到控制开关

怎么调用onenet平台的API从而读取我们的设备数据和下发命令,做到控制开关 1、首先是怎么读取数据 读取的API是:http://api.heclouds.com/devices/datapoints?devIds=629063002 其中devids这个指的是你的设备ID 然后在我们的headers里面添加一些必要参数,就可以调用了 其中api-key的是你产品里面的master-apikey 把我们的参数写好就可以调用了,选择get方式,点击发送 这个value就是我们需要获取到的参数值了,

zyh960的博客 2万+

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

【BERT-多标签文本分类实战】之五——BERT模型库的挑选与Transformers

在大规模无监督语料上训练得到最终参数之后,是要把参数保存下来,之后有新的数据集要跑的时候,我们需要把这些参数数据载入到模型。这个符号有特殊的意义,BERT 包含 12 个 Transformer 层,每层接受一组 token 的 embeddings 列表作为输入,并产生相同数目的 embeddings 作为输出(当然,它们的值是不同的)。在以输入为两个句子的任务中(例如:句子 A 中的问题的答案是否可以在句子 B 中找到),该符号为这两个句子的分隔符。想要深入使用,大家仔细看看上面贴的文档,写得非常好。

十一月廿七风雨大作 1万+

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

【BERT-多标签文本分类实战】之一——实战项目总览

很多数据集都是英文的,比如多标签文本数据集、层次结构标签文本数据集,想在方向上更进一步的话,必须得学会处理英文文本。而随着近些年的发展,bert算是表现超级好的几种模型之一,所以有必要跑一跑bert相关的模型。目前来看,如果方向是文本分类的话,英文文本分类、中文文本分类都需要掌握。如果需要本组件的源代码,请扫描关注我的公众号,回复“bert实战”。您还可以浏览我的另外一个项目博客【英文单标签文本分类实战】。[4]另一个项目【英文单标签文本分类实战】[3]实战前需要掌握的知识。[2]代码获取地址。......

十一月廿七风雨大作 1万+

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

bert简介_tensorflow 2.0+ 基于BERT的多标签文本分类

在多标签分类的问题中,模型的训练集由实例组成,每个实例可以被分配多个类别,表示为一组目标标签,最终任务是准确预测测试数据的标签集。例如:文本可以同时涉及宗教、政治、金融或教育,也可以不属于其中任何一个。电影按其抽象内容可分为动作片、喜剧片和浪漫片。电影有可能属于多种类型,比如周星驰的《大话西游》,同时属于浪漫片与喜剧片。多标签和多分类有什么区别?在多分类中,每个样本被分配到一个且只有一个标签:水果...

weixin_39946239的博客 4010

【层级多标签文本分类】MSML-BERT 模型的层级多标签文本分类方法研究

层级多标签文本分类相比普通的多标签文本分类更具有挑战性,因为文本的多个标签组织成树状 的层次结构。当前方法使用相同的模型结构来预测不同层级的标签,忽略了它们之间的差异性和多样性。 并且没有充分地建模层级依赖关系,造成各层级标签尤其是下层长尾标签的预测性能差,且会导致标签不 一致性问题。...

wuli_乖 6163

tensorflow 2.0+ 基于预训练BERT模型的多标签文本分类

tensorflow 2.0+ 基于BERT的多标签文本分类 在多标签分类的问题中,模型的训练集由实例组成,每个实例可以被分配多个类别,表示为一组目标标签,最终任务是准确预测测试数据的标签集。例如: 文本可以同时涉及宗教、政治、金融或教育,也可以不属于其中任何一个。 电影按其抽象内容可分为动作片、喜剧片和浪漫片。电影有可能属于多种类型,比如周星驰的《大话西游》,同时属于浪漫片与喜剧片。 多标签和多分类有什么区别? 在多分类中,每个样本被分配到一个且只有一个标签:水果可以是苹果或梨,但不能同时是苹果和

xiaoniu0991的博客 4836
上一篇: 提取Oilprice新闻信息,并使用R包进行情感分析
下一篇: 【西瓜书阅读笔记】绪论
Checkmate9949
博客等级 码龄5年 6176粉丝 43原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值