昇思MindSpore学习笔记5-02生成式--RNN实现情感分类

摘要:

        记录MindSpore AI框架使用RNN网络对自然语言进行情感分类的过程、步骤和方法。

        包括环境准备、下载数据集、数据集加载和预处理、构建模型、模型训练、模型测试等。

一、

情感分类。

RNN网络模型

实现效果:

        输入: This film is terrible

        正确标签: Negative

        预测标签: Negative

        输入: This film is great

        正确标签: Positive

        预测标签: Positive

二、环境准备

%%capture captured_output
# 实验环境已经预装了mindspore==2.2.14,如需更换mindspore版本,可更改下面mindspore的版本号
!pip uninstall mindspore -y
!pip install -i https://pypi.mirrors.ustc.edu.cn/simple mindspore==2.2.14
# 查看当前 mindspore 版本
!pip show mindspore

输出:

Name: mindspore
Version: 2.2.14
Summary: MindSpore is a new open source deep learning training/inference framework that could be used for mobile, edge and cloud scenarios.
Home-page: https://www.mindspore.cn
Author: The MindSpore Authors
Author-email: contact@mindspore.cn
License: Apache 2.0
Location: /home/nginx/miniconda/envs/jupyter/lib/python3.9/site-packages
Requires: asttokens, astunparse, numpy, packaging, pillow, protobuf, psutil, scipy
Required-by: 

手动安装tqdm和requests库

!pip install tqdm requests

三、加载数据

IMDB影评数据集

        Positive

        Negative

预训练词向量

        编码自然语言单词

        获取文本语义特征

选取Glove词向量作为Embedding。

1.下载数据集和预训练词向量

requests库

        http请求

tqdm库

        下载百分比进度

IO方式下载临时文件

保存至指定路径并返回

import os
import shutil
import requests
import tempfile
from tqdm import tqdm
from typing import IO
from pathlib import Path
​
# 指定保存路径为 `home_path/.mindspore_examples`
cache_dir = Path.home() / '.mindspore_examples'
​
def http_get(url: str, temp_file: IO):
    """使用requests库下载数据,并使用tqdm库进行流程可视化"""
    req = requests.get(url, stream=True)
    content_length = req.headers.get('Content-Length')
    total = int(content_length) if content_length is not None else None
    progress = tqdm(unit='B', total=total)
    for chunk in req.iter_content(chunk_size=1024):
        if chunk:
            progress.update(len(chunk))
            temp_file.write(chunk)
    progress.close()
​
def download(file_name: str, url: str):
    """下载数据并存为指定名称"""
    if not os.path.exists(cache_dir):
        os.makedirs(cache_dir)
    cache_path = os.path.join(cache_dir, file_name)
    cache_exist = os.path.exists(cache_path)
    if not cache_exist:
        with tempfile.NamedTemporaryFile() as temp_file:
            http_get(url, temp_file)
            temp_file.flush()
            temp_file.seek(0)
            with open(cache_path, 'wb') as cache_file:
                shutil.copyfileobj(temp_file, cache_file)
    return cache_path

下载IMDB数据集(使用华为云镜像):

imdb_path = download('aclImdb_v1.tar.gz', 'https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/aclImdb_v1.tar.gz')
imdb_path

输出:

100%|██████████| 84125825/84125825 [00:02<00:00, 38051349.02B/s]
'/home/nginx/.mindspore_examples/aclImdb_v1.tar.gz'

2.IMDB加载模块

Python的tarfile库

        读取IMDB数据集tar.gz文件

        所有数据和标签分别进行存放

IMDB数据集解压目录如下:

    ├── aclImdb
    │   ├── imdbEr.txt
    │   ├── imdb.vocab
    │   ├── README
    │   ├── test
    │   └── train
    │         ├── neg
    │         ├── pos
    ...

数据集分两部分加载

        train

                neg

                pos

        Test

                neg

                pos

import re
import six
import string
import tarfile
​
class IMDBData():
    """IMDB数据集加载器
​
    加载IMDB数据集并处理为一个Python迭代对象。
​
    """
    label_map = {
        "pos": 1,
        "neg": 0
    }
    def __init__(self, path, mode="train"):
        self.mode = mode
        self.path = path
        self.docs, self.labels = [], []
​
        self._load("pos")
        self._load("neg")
​
    def _load(self, label):
        pattern = re.compile(r"aclImdb/{}/{}/.*\.txt$".format(self.mode, label))
        # 将数据加载至内存
        with tarfile.open(self.path) as tarf:
            tf = tarf.next()
            while tf is not None:
                if bool(pattern.match(tf.name)):
                    # 对文本进行分词、去除标点和特殊字符、小写处理
                    self.docs.append(str(tarf.extractfile(tf).read().rstrip(six.b("\n\r"))
                                         .translate(None, six.b(string.punctuation)).lower()).split())
                    self.labels.append([self.label_map[label]])
                tf = tarf.next()
​
    def __getitem__(self, idx):
        return self.docs[idx], self.labels[idx]
​
    def __len__(self):
        return len(self.docs)

3.加载训练数据集

imdb_train = IMDBData(imdb_path, 'train')
len(imdb_train)

输出:

25000

mindspore.dataset.Generatordataset接口

加载数据集迭代对象

        加载训练数据集train

        加载测试数据集test

        指定数据集中文本和标签列名

import mindspore.dataset as ds
​
def load_imdb(imdb_path):
    imdb_train = ds.GeneratorDataset(IMDBData(imdb_path, "train"), column_names=["text", "label"], shuffle=True, num_samples=10000)
    imdb_test = ds.GeneratorDataset(IMDBData(imdb_path, "test"), column_names=["text", "label"], shuffle=False)
    return imdb_train, imdb_test

imdb_train, imdb_test = load_imdb(imdb_path)
imdb_train

输出:

<mindspore.dataset.engine.datasets_user_defined.GeneratorDataset at 0xfffed0a44fd0>

4.加载预训练词向量

预训练词向量

Glove(Global Vectors for Word Representation)

        数值化表示输入单词

        构造Embedding层词向量和词表

                Glove

        nn.Embedding层

        查表方式

        输入

                单词对应词表中的index

        输出

                对应表达向量

预训练词向量

Word

Vector

the

0.418 0.24968 -0.41242 0.1217 0.34527 -0.044457 -0.49688 -0.17862 -0.00066023 ...

,

0.013441 0.23682 -0.16899 0.40951 0.63812 0.47709 -0.42852 -0.55641 -0.364 ...

第一列单词作词表

dataset.text.Vocab按序加载

读取每一行Vector

        转为numpy.array

nn.Embedding加载权重

import zipfile
import numpy as np
​
def load_glove(glove_path):
    glove_100d_path = os.path.join(cache_dir, 'glove.6B.100d.txt')
    if not os.path.exists(glove_100d_path):
        glove_zip = zipfile.ZipFile(glove_path)
        glove_zip.extractall(cache_dir)
​
    embeddings = []
    tokens = []
    with open(glove_100d_path, encoding='utf-8') as gf:
        for glove in gf:
            word, embedding = glove.split(maxsplit=1)
            tokens.append(word)
            embeddings.append(np.fromstring(embedding, dtype=np.float32, sep=' '))
    # 添加 <unk>, <pad> 两个特殊占位符对应的embedding
    embeddings.append(np.random.rand(100))
    embeddings.append(np.zeros((100,), np.float32))
​
    vocab = ds.text.Vocab.from_list(tokens, special_tokens=["<unk>", "<pad>"], special_first=False)
    embeddings = np.array(embeddings).astype(np.float32)
    return vocab, embeddings

词表没有覆盖的单词加<unk>标记符

输入长度不一致

        打包batch时填充短文本加<pad>标记符

完成的词表长度为原词表长度+2。

下载Glove词向量

加载生成词表和词向量权重矩阵

glove_path = download('glove.6B.zip', 'https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/glove.6B.zip')
vocab, embeddings = load_glove(glove_path)
len(vocab.vocab())

输出:

100%|██████████| 862182613/862182613 [00:22<00:00, 38245398.49B/s]
400002

使用词表转换the为index id

查询词向量矩阵对应的词向量

idx = vocab.tokens_to_ids('the')
embedding = embeddings[idx]
idx, embedding

输出:

(0,
 array([-0.038194, -0.24487 ,  0.72812 , -0.39961 ,  0.083172,  0.043953,
        -0.39141 ,  0.3344  , -0.57545 ,  0.087459,  0.28787 , -0.06731 ,
         0.30906 , -0.26384 , -0.13231 , -0.20757 ,  0.33395 , -0.33848 ,
        -0.31743 , -0.48336 ,  0.1464  , -0.37304 ,  0.34577 ,  0.052041,
         0.44946 , -0.46971 ,  0.02628 , -0.54155 , -0.15518 , -0.14107 ,
        -0.039722,  0.28277 ,  0.14393 ,  0.23464 , -0.31021 ,  0.086173,
         0.20397 ,  0.52624 ,  0.17164 , -0.082378, -0.71787 , -0.41531 ,
         0.20335 , -0.12763 ,  0.41367 ,  0.55187 ,  0.57908 , -0.33477 ,
        -0.36559 , -0.54857 , -0.062892,  0.26584 ,  0.30205 ,  0.99775 ,
        -0.80481 , -3.0243  ,  0.01254 , -0.36942 ,  2.2167  ,  0.72201 ,
        -0.24978 ,  0.92136 ,  0.034514,  0.46745 ,  1.1079  , -0.19358 ,
        -0.074575,  0.23353 , -0.052062, -0.22044 ,  0.057162, -0.15806 ,
        -0.30798 , -0.41625 ,  0.37972 ,  0.15006 , -0.53212 , -0.2055  ,
        -1.2526  ,  0.071624,  0.70565 ,  0.49744 , -0.42063 ,  0.26148 ,
        -1.538   , -0.30223 , -0.073438, -0.28312 ,  0.37104 , -0.25217 ,
         0.016215, -0.017099, -0.38984 ,  0.87424 , -0.72569 , -0.51058 ,
        -0.52028 , -0.1459  ,  0.8278  ,  0.27062 ], dtype=float32))

四、数据集预处理

预处理

        mindspore.dataset接口

        Vocab处理

                text.Lookup接口

                加载词表

                指定unknown_token

                所有Token对应index id。

        文本序列统一长度

                PadEnd接口

                        定义最大长度 此例为500

                        补齐值(pad_value) 此例为<pad>

                不足的<pad>补齐

                超出的截断

        label数据转为float32格式。

import mindspore as ms
​
lookup_op = ds.text.Lookup(vocab, unknown_token='<unk>')
pad_op = ds.transforms.PadEnd([500], pad_value=vocab.tokens_to_ids('<pad>'))
type_cast_op = ds.transforms.TypeCast(ms.float32)

定义数据集处理流水线

添加指定column操作。

        map接口

imdb_train = imdb_train.map(operations=[lookup_op, pad_op], input_columns=['text'])
imdb_train = imdb_train.map(operations=[type_cast_op], input_columns=['label'])
​
imdb_test = imdb_test.map(operations=[lookup_op, pad_op], input_columns=['text'])
imdb_test = imdb_test.map(operations=[type_cast_op], input_columns=['label'])

分割两部分数据集

    split接口

            训练比例0.7

            验证比例0.3

imdb_train, imdb_valid = imdb_train.split([0.7, 0.3])

输出:

[WARNING] ME(281:281473514793264,MainProcess):2024-07-07-02:08:44.142.068 [mindspore/dataset/engine/datasets.py:1203] Dataset is shuffled before split.

打包数据集

        batch接口

                batch大小

                设置是否丢弃剩余数据(无法整除batch size的部分)

imdb_train = imdb_train.batch(64, drop_remainder=True)
imdb_valid = imdb_valid.batch(64, drop_remainder=True)

五、模型构建

情感分类模型结构

nn.Embedding -> nn.RNN -> nn.Dense

        输入文本(即序列化后的index id列表)

        查表转为向量化表示

        nn.Embedding层加载Glove词向量

        RNN循环神经网络做特征提取

                规避RNN梯度消失问题

                LSTM(Long short-term memory)变种

        RNN连接全连接层nn.Dense

        转化特征为与分类数量相同的size

1.Embedding

Embedding层EmbeddingLookup

        使用index id查找权重矩阵对应id的向量

        输入

                index id序列

        输出

                相同长度矩阵

        例如:

                # 词表大小(index的取值范围)为1000,表示向量的size为100

                embedding = nn.Embedding(1000, 100)

                # 序列长度为16

                input shape: (1, 16)                

                output shape: (1, 16, 100)

        预训练词向量矩阵glove

                nn.Embedding.embedding_table

        对应vocab_size 词表大小400002

        embedding_size  选用的glove.6B.100d向量大小100

2.RNN(循环神经网络)

RNN循环神经网络

Recurrent Neural Network

        输入序列sequence数据

        递归recursion序列演进

        所有节点(循环单元)按链式连接

RNN一般结构

左侧

        RNN Cell循环

                只有一个Cell参数

                在循环计算中更新

右侧

        RNN链式连接平铺

自然语言处理大量应用RNN

    匹配

        RNN的循环特性

        自然语言文本的序列特性

RNN结构拆解

RNN单个Cell结构简单

        梯度消失(Gradient Vanishing)问题

                序列较长时,序列尾部丢失首部信息

        提出LSTM(Long short-term memory)

                门控机制(Gating Mechanism)

                        控制信息流在每个循环步中的留存和丢弃

LSTM结构拆解

MindSpore.nn.LSTM对应公式:

h0:t,(ht,ct)=LSTM(x0:t,(h0,c0))

nn.LSTM隐藏了整个循环神经网络在序列时间步(Time step)上的循环

输入

        序列

        初始状态

输出

        时间步隐状态(hidden state)矩阵

        最后一个时间步隐状态

        输入下一层

                句子的编码特征

时间步Time step

        循环神经网络计算的每一次循环,成为一个Time step。

        输入

                文本序列时,一个Time step对应一个单词

        输出

                h0:t对应每个单词的隐状态集合

                ht,ct对应最后一个单词对应的隐状态

3.Dense

LSTM编码获取句子特征

输入全连接层nn.Dense

变换特征维度为二分类所需的维度1

输出模型预测结果

import math
import mindspore as ms
import mindspore.nn as nn
import mindspore.ops as ops
from mindspore.common.initializer import Uniform, HeUniform
​
class RNN(nn.Cell):
    def __init__(self, embeddings, hidden_dim, output_dim, n_layers,
                 bidirectional, pad_idx):
        super().__init__()
        vocab_size, embedding_dim = embeddings.shape
        self.embedding = nn.Embedding(vocab_size, embedding_dim, embedding_table=ms.Tensor(embeddings), padding_idx=pad_idx)
        self.rnn = nn.LSTM(embedding_dim,
                           hidden_dim,
                           num_layers=n_layers,
                           bidirectional=bidirectional,
                           batch_first=True)
        weight_init = HeUniform(math.sqrt(5))
        bias_init = Uniform(1 / math.sqrt(hidden_dim * 2))
        self.fc = nn.Dense(hidden_dim * 2, output_dim, weight_init=weight_init, bias_init=bias_init)
​
    def construct(self, inputs):
        embedded = self.embedding(inputs)
        _, (hidden, _) = self.rnn(embedded)
        hidden = ops.concat((hidden[-2, :, :], hidden[-1, :, :]), axis=1)
        output = self.fc(hidden)
        return output

4.损失函数与优化器

指定参数实例化网络

选择损失函数和优化器

预测Positive或Negative二分类问题

        nn.BCEWithLogitsLoss(二分类交叉熵损失函数)

hidden_size = 256
output_size = 1
num_layers = 2
bidirectional = True
lr = 0.001
pad_idx = vocab.tokens_to_ids('<pad>')
​
model = RNN(embeddings, hidden_size, output_size, num_layers, bidirectional, pad_idx)
loss_fn = nn.BCEWithLogitsLoss(reduction='mean')
optimizer = nn.Adam(model.trainable_params(), learning_rate=lr)

5.训练逻辑

训练逻辑设计

        读取一个Batch的数据;

        输入网络

                正向计算

                反向传播

                更新权重

        返回loss

tqdm库

        可视化

                训练过程

                loss

def forward_fn(data, label):
    logits = model(data)
    loss = loss_fn(logits, label)
    return loss
​
grad_fn = ms.value_and_grad(forward_fn, None, optimizer.parameters)
​
def train_step(data, label):
    loss, grads = grad_fn(data, label)
    optimizer(grads)
    return loss
​
def train_one_epoch(model, train_dataset, epoch=0):
    model.set_train()
    total = train_dataset.get_dataset_size()
    loss_total = 0
    step_total = 0
    with tqdm(total=total) as t:
        t.set_description('Epoch %i' % epoch)
        for i in train_dataset.create_tuple_iterator():
            loss = train_step(*i)
            loss_total += loss.asnumpy()
            step_total += 1
            t.set_postfix(loss=loss_total/step_total)
            t.update(1)

6.评估指标和逻辑

评估模型

        对比

                模型预测结果

                测试集正确标签

        求预测准确率

IMDB的情感二分类准确率实现代码

def binary_accuracy(preds, y):
    """
    计算每个batch的准确率
    """
​
    # 对预测值进行四舍五入
    rounded_preds = np.around(ops.sigmoid(preds).asnumpy())
    correct = (rounded_preds == y).astype(np.float32)
    acc = correct.sum() / len(correct)
    return acc

评估步骤

        读取一个Batch的数据;

        输入网络

                正向计算

                预测结果

        计算准确率

        tqdm可视化

                评估过程

                Loss

        输出评估loss

        判断模型优劣

评估时网络模型主体不包含损失函数和优化器

评估model.set_train(False)模型评估状态

def evaluate(model, test_dataset, criterion, epoch=0):
    total = test_dataset.get_dataset_size()
    epoch_loss = 0
    epoch_acc = 0
    step_total = 0
    model.set_train(False)
​
    with tqdm(total=total) as t:
        t.set_description('Epoch %i' % epoch)
        for i in test_dataset.create_tuple_iterator():
            predictions = model(i[0])
            loss = criterion(predictions, i[1])
            epoch_loss += loss.asnumpy()
​
            acc = binary_accuracy(predictions, i[1])
            epoch_acc += acc
​
            step_total += 1
            t.set_postfix(loss=epoch_loss/step_total, acc=epoch_acc/step_total)
            t.update(1)
​
    return epoch_loss / total

六、模型训练与保存

模型训练

        设置训练轮数5轮

        保存最优模型变量best_valid_loss

        保存最小loss值轮次模型

num_epochs = 2
best_valid_loss = float('inf')
ckpt_file_name = os.path.join(cache_dir, 'sentiment-analysis.ckpt')
​
for epoch in range(num_epochs):
    train_one_epoch(model, imdb_train, epoch)
    valid_loss = evaluate(model, imdb_valid, loss_fn, epoch)
​
    if valid_loss < best_valid_loss:
        best_valid_loss = valid_loss
        ms.save_checkpoint(model, ckpt_file_name)

输出:

Epoch 0:   0%|          | 0/109 [00:00<?, ?it/s]
|
Epoch 0: 100%|██████████| 109/109 [13:38<00:00,  7.51s/it, loss=0.692]  
Epoch 0: 100%|██████████| 46/46 [00:40<00:00,  1.15it/s, acc=0.524, loss=0.69] 
Epoch 1: 100%|██████████| 109/109 [01:23<00:00,  1.31it/s, loss=0.668]
Epoch 1: 100%|██████████| 46/46 [00:13<00:00,  3.38it/s, acc=0.672, loss=0.615]

每轮Loss逐步下降

准确率逐步提升

七、模型加载与测试

模型测试

加载保存的最优模型

        加载checkpoint

        加载网络权重加载接口

param_dict = ms.load_checkpoint(ckpt_file_name)
ms.load_param_into_net(model, param_dict)

输出:

([], [])

测试集打batch

evaluate评估

得到模型在测试集上的效果

imdb_test = imdb_test.batch(64)
evaluate(model, imdb_test, loss_fn)

输出:

Epoch 0: 100%|█████████▉| 390/391 [01:29<00:00,  4.57it/s, acc=0.666, loss=0.619]
-
Epoch 0: 100%|██████████| 391/391 [03:33<00:00,  1.83it/s, acc=0.666, loss=0.619]
0.6193520278881883

八、自定义输入测试

预测函数

        输入一句评价

        获得评价的情感分类

现实步骤:

        输入句子分词;

        词表对应的index id序列;

        index id序列转为Tensor;

        输入模型

        获得预测结果;

        打印输出预测结果。

实现代码

score_map = {
    1: "Positive",
    0: "Negative"
}
​
def predict_sentiment(model, vocab, sentence):
    model.set_train(False)
    tokenized = sentence.lower().split()
    indexed = vocab.tokens_to_ids(tokenized)
    tensor = ms.Tensor(indexed, ms.int32)
    tensor = tensor.expand_dims(0)
    prediction = model(tensor)
    return score_map[int(np.round(ops.sigmoid(prediction).asnumpy()))]

predict_sentiment(model, vocab, "This film is terrible")

输出:

'Negative'

predict_sentiment(model, vocab, "This film is great")

输出:

'Positive'

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/784587.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

Tomcat的负载均衡、动静分离

一、如何tomcat和nginx负载均衡及动静分离&#xff1a;2台tomcat&#xff0c;3台nginx来实现 1.首先设置tomcat1和tomcat2服务器 关闭两台tomcat的防火墙及安全机制&#xff1a;systemctl stop filwalld setenforce 0 进入tomcat目录的webapps中&#xff0c;创建test 2.配…

PI 接口日志设置

一、全局设置 SAP NetWeaver Administrator ---> 配置 ---> 基础架构 ---> Java系统属性 ---> 选择服务页签 ---> 选择 "XPI Adapter:XI"服务进行设置。 1760915 - FAQ: Staging and Logging in PI 7.3 and higher 2518441 - The tablespace PSAPSR…

亿康源精英盛宴暨亿康源启动成功举办

&#xff08;本台记者报&#xff09;2024年7月7日下午&#xff0c;亿康源精英盛宴暨启动仪式在杭州市中维歌德大酒店盛大举行。此次盛会不仅吸引了行业内的专业人才、著名投资界大咖和科技领域的杰出企业家&#xff0c;还汇聚了众多关注大健康产业的各界人士&#xff0c;共同见…

【Linux】进程间通信——匿名管道

为什么要进行进程间通信&#xff1f; 1.数据传输&#xff1a;一个进程需要将它的数据发送给另一个进程&#xff0c;比如我们有两个进程&#xff0c;一个负责获取数据&#xff0c;另一个负责处理数据&#xff0c;这时第一个进程就要将获取到的数据交给第二个进程 2.资源共享&…

永磁同步电机无速度算法--滑模观测器(反正切、反余弦)

一、原理介绍 在永磁同步电机滑模观测器控制中&#xff0c;转子的位置和转速信息与反动电势密切相关。滑模观测器控制基本设计思路是&#xff1a;利用永磁同步电机的电压、电流信息&#xff0c;通过永磁同步电机数学模型&#xff0c;估算出电机在两相静止坐标系中的反电动势信…

(十) Docker compose 本地部署 apollo

文章目录 1、apollo2、数据库准备3、启动后会用到的几个地址4、docker-compose运行 apollo方式一&#xff1a;使用容器 hostName 作为网络媒介apollo 客户端通过宿主机端口 拉取配置(推荐)apollo 客户端通过 自定义hostName 拉取配置 方式二&#xff1a;使用端口映射固定 ip 作…

transformer网络学习

Transformer encoder-decoder模型之间共享的是Encoder最后一层输出的hidden-state。 GitHub - huggingface/transformers: &#x1f917; Transformers: State-of-the-art Machine Learning for Pytorch, TensorFlow, and JAX. Bert2Bert中&#xff0c;Encoder的hidden-state同…

阿里开源语音理解和语音生成大模型FunAudioLLM

近年来&#xff0c;人工智能&#xff08;AI&#xff09;的进步极大地改变了人类与机器的互动方式&#xff0c;例如GPT-4o和Gemin-1.5等。这种转变在语音处理领域尤为明显&#xff0c;其中高精度的语音识别、情绪识别和语音生成等能力为更直观、更类人的交互铺平了道路。阿里开源…

JAVA Tesseract OCR引擎

Tess4j是一个基于Tesseract OCR引擎的Java库, Tesseract库最初由惠普实验室于1985年开发&#xff0c;后来被Google收购并于2006年开源。识别效果不好&#xff0c;速度还慢&#xff0c;但是好早好早了。 一、POM依赖 <!--OCR识别https://digi.bib.uni-mannheim.de/tesserac…

library source does not match the bytecode for class SpringApplication

library source does not match the bytecode for class SpringApplication 问题描述&#xff1a;springboot源码点进去然后download source后提示标题内容。spring版本5.2.8.RELEASE&#xff0c;springboot版本2.7.18 解决方法&#xff1a;把spring版本改为与boot版本对应的6.…

昇思25天学习打卡营第5天|MindSpore网络模型构建

打卡 目录 打卡 模型类 模型网络&#xff1a;定义与使用 模型层级分解 nn.Flatten 张量转换-演示查看 nn.Dense 全连接层-演示查看 nn.ReLU 非线性激活层-演示查看 nn.SequentialCell 有序网络容器 nn.Softmax 多分类概率预测 模型参数 前置感受&#xff1a;总的来说…

前端面试题25(css常用的预处理器)

在前端开发领域&#xff0c;CSS预处理器在面试中经常被提及&#xff0c;其中最流行的三种预处理器是Sass、LESS和Stylus。下面分别介绍它们的特点和优势&#xff1a; 1. Sass&#xff08;Syntactically Awesome Style Sheets&#xff09; 优势&#xff1a; 变量&#xff1a;允…

【购物车案例】for循环为什么使用key

要做出一个简单的购物车界面。首先&#xff0c;有一个复选框&#xff0c;可以选择商品&#xff0c;后面紧跟的是商品名称&#xff0c;然后&#xff0c;是删除按钮&#xff0c;根据这个需求&#xff0c;先写出一个简单的界面&#xff0c;代码如下&#xff1a; <template>…

思路打开!腾讯造了10亿个角色,驱动数据合成!7B模型效果打爆了

世界由形形色色的角色构成&#xff0c;每个角色都拥有独特的知识、经验、兴趣、个性和职业&#xff0c;他们共同制造了丰富多元的知识与文化。 所谓术业有专攻&#xff0c;比如AI科学家专注于构建LLMs,医务工作者们共建庞大的医学知识库&#xff0c;数学家们则偏爱数学公式与定…

论文解析——Full Stack Optimization of Transformer Inference: a Survey

作者及发刊详情 摘要 正文 主要工作贡献 这篇文章的贡献主要有两部分&#xff1a; 分析Transformer的特征&#xff0c;调查高效transformer推理的方法通过应用方法学展现一个DNN加速器生成器Gemmini的case研究 1&#xff09;分析和解析Transformer架构的运行时特性和瓶颈…

人员定位系统的功能,你知道多少呢?

在此前的文章中&#xff0c;说到了人员定位系统用于化工厂定位这一用途来完善工厂管理&#xff0c;但同时&#xff0c;基于人员定位系统的强大功能&#xff0c;该系统的应用范围也要宽范的多&#xff0c;那么&#xff0c;本篇文章就来为大家介绍一下吧。 人员定位系统的功能简介…

阿里云存储的降本增效与运维

小浩负责公司存储架构层&#xff0c;需要确保存储层不会成为公司业务系统的性能瓶颈&#xff0c;让数据读写达到最佳性能。那么小浩可以从哪些方面着手优化性能呢&#xff1f;他继续求助系统架构师大雷。 小浩&#xff1a;雷哥&#xff0c;PD反馈公司系统最近响应很慢&#xff…

电子设备常用的胶水有哪些?

目录 1、502胶水 2、703胶水 3、704胶水 4、AB胶 5、红胶 6、Underfill 7、导电胶 8、UV胶 9、热熔胶 10、环氧树脂胶 11、硅酮胶 12、聚氨酯胶 13、丙烯酸胶 14、丁基胶 1、502胶水 502胶水&#xff0c;也被称为瞬间胶或快干胶&#xff0c;是一种非常常见的粘合…

加密与安全_密钥体系的三个核心目标之不可否认性解决方案

文章目录 Pre概述不可否认性数字签名&#xff08;Digital Signature&#xff09;证书是什么证书使用流程 PKICA证书层级多级证书证书链是如何完成认证的&#xff1f; 其他疑问1. Alice能直接获取Bob的公钥&#xff0c;是否还需要证书&#xff1f;2. 为什么即使能直接获取公钥也…

2-28 基于matlab提取出频域和时域信号的29个特征

基于matlab提取出频域和时域信号的29个特征&#xff0c;主运行文件feature_extraction&#xff0c;fre_statistical_compute和time_statistical_compute分别提取频域和时域的特征&#xff0c;生成的29个特征保存在生成的feature矩阵中。程序已调通&#xff0c;可直接运行。 2-2…