实验：ML-LHY-HW8:seq2seq

最新推荐文章于 2022-01-27 21:48:41 发布
最新推荐文章于 2022-01-27 21:48:41 发布
阅读量318 收藏 1
点赞数
分类专栏： # 实验 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29598161/article/details/113773377
版权

笔记：ML-LHY: Attention-based Model / Conditional Generation by RNN & Attention实验，本文代码在TA代码上轻微修改。

Dataset

data example(train, validation, test)：

it 's none of your concern . 	這不關 你 的 事 。 
she has a habit of bi@@ ting her na@@ ils . 	她 有 咬 指甲 的 習慣 。 
he is a teacher . 	他 是 老師 。 
japan re@@ lies on ar@@ a@@ b countries for oil . 	日本 靠 阿拉伯 國家 提供 石油 。 
i 'll dream about you . 	我會 夢到 你 的 。 
i borrowed tom 's phone this morning . 	我 今天 早上 跟 Tom 藉手機 。 
she does n't know how to play golf . 	她 不 知道 怎麼 打 高爾夫球 。 
tears ro@@ lled down my chee@@ ks . 	淚水 沿着 我 的 面頰 流 了 下來 。 
that 's soft . 	這 很 軟 。 
do n't open this door , please . 	請 不要 打開 此門 。 
what exactly does tom do ? 	湯姆 究竟 在 做 什麼 ？ 
there 's a book here . 	這裡 有 一本 書 。 
tom was the first to rea@@ ct . 	湯姆 是 最先 作出 反應 的 。 
i 'm going to check out at eight . 	我會 在 八點鐘 的 時候 登出 。 
is this your notebook ? 	這是 你 的 書 嗎 ？ 
how could things get worse ? 	事情 怎麼 變糟 的 ？ 
i hope this is the right one . 	我 希望 這是 對 的 。 
i play tennis an hour a day . 	我 每天 打一 小時 網球 。 
...

将训练数据每行分割成英文和中文sequence，并且将sequence中每个word装换为index，使用LabelTransform转换成一样长度的index token。

# data.py
import re
import json
import torch.utils.data as data
import numpy as np
import os
import torch


class LabelTransform(object):
    def __init__(self, size, pad):
        self.size = size
        self.pad = pad

    def __call__(self, label):
        label = np.pad(label, (0, (self.size - label.shape[0])), mode='constant', constant_values=self.pad)
        return label


class EN2CNDataset(data.Dataset):
    def __init__(self, root, max_output_len, set_name):
        self.root = root

        self.word2int_cn, self.int2word_cn = self.get_dictionary('cn')
        self.word2int_en, self.int2word_en = self.get_dictionary('en')

        # 載入資料
        self.data = []
        with open(os.path.join(self.root, f'{set_name}.txt'), "r") as f:
            for line in f:
                self.data.append(line)
        print(f'{set_name} dataset size: {len(self.data)}')

        self.cn_vocab_size = len(self.word2int_cn)
        self.en_vocab_size = len(self.word2int_en)
        self.transform = LabelTransform(max_output_len, self.word2int_en['<PAD>'])

    def get_dictionary(self, language):
        # 載入字典
        with open(os.path.join(self.root, f'word2int_{language}.json'), "r") as f:
            word2int = json.load(f)
        with open(os.path.join(self.root, f'int2word_{language}.json'), "r") as f:
            int2word = json.load(f)
        return word2int, int2word

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

    def __getitem__(self, Index):
        # 先將中英文分開
        sentences = self.data[Index]
        sentences = re.split('[\t\n]', sentences)
        sentences = list(filter(None, sentences))
        # print (sentences)
        assert len(sentences) == 2

        # 預備特殊字元
        BOS = self.word2int_en['<BOS>']
        EOS = self.word2int_en['<EOS>']
        UNK = self.word2int_en['<UNK>']

        # 在開頭添加 <BOS>，在結尾添加 <EOS> ，不在字典的 subword (詞) 用 <UNK> 取代
        en, cn = [BOS], [BOS]
        # 將句子拆解為 subword 並轉為整數
        sentence = re.split(' ', sentences[0])
        sentence = list(filter(None, sentence))
        # print (f'en: {sentence}')
        for word in sentence:
            en.append(self.word2int_en.get(word, UNK))
        en.append(EOS)

        # 將句子拆解為單詞並轉為整數
        # e.g. < BOS >, we, are, friends, < EOS > --> 1, 28, 29, 205, 2
        sentence = re.split(' ', sentences[1])
        sentence = list(filter(None, sentence))
        # print (f'cn: {sentence}')
        for word in sentence:
            cn.append(self.word2int_cn.get(word, UNK))
        cn.append(EOS)

        en, cn = np.asarray(en), np.asarray(cn)

        # 用 <PAD> 將句子補到相同長度
        en, cn = self.transform(en), self.transform(cn)
        en, cn = torch.LongTensor(en), torch.LongTensor(cn)

        return en, cn

在这里插入图片描述

Model

Encoder

使用的多层双向GRU(参考笔记：ML-LHY-21: Recurrent Neural Network(RNN) 循环神经网络):

class Encoder(nn.Module):
    def __init__(self, en_vocab_size, emb_dim, hid_dim, n_layers, dropout, device):
        super().__init__()
        # 这里的Embedding层参数没有预先训练，可以参考H4进行预训练
        self.embedding = nn.Embedding(en_vocab_size, emb_dim)
        self.hid_dim = hid_dim
        self.n_layers = n_layers
        self.rnn = nn.GRU(emb_dim, hid_dim, n_layers, dropout=dropout, batch_first=True, bidirectional=True)
        self.dropout = nn.Dropout(dropout)

    def forward(self, input):
        # input = [batch size, sequence len, vocab size(其实就是索引，把其看做one hot code，长度为vocab size)]
        embedding = self.embedding(input)
        outputs, hidden = self.rnn(self.dropout(embedding))
        # outputs = [batch size, sequence len, hid dim * directions]
        # hidden =  [num_layers * directions, batch size  , hid dim]
        # outputs 是最上層RNN的輸出

        return outputs, hidden

在这里插入图片描述

Decoder

class Decoder(nn.Module):
    def __init__(self, cn_vocab_size, emb_dim, hid_dim, n_layers, dropout, isatt, device):
        super().__init__()
        self.cn_vocab_size = cn_vocab_size
        self.hid_dim = hid_dim * 2
        self.n_layers = n_layers
        self.embedding = nn.Embedding(cn_vocab_size, emb_dim)
        self.isatt = isatt
        self.attention = Attention(self.hid_dim, device)
        # 如果使用 Attention Mechanism 會使得輸入維度變化，請在這裡修改
        # e.g. Attention 接在輸入後面會使得維度變化，所以輸入維度改為 ，这里是相连，由于我们选择相加，所以维度不需要改变
        # self.input_dim = emb_dim + hid_dim * 2 if isatt else emb_dim
        self.input_dim = emb_dim
        self.rnn = nn.GRU(self.input_dim, self.hid_dim, self.n_layers, dropout=dropout, batch_first=True)
        self.embedding2vocab1 = nn.Linear(self.hid_dim, self.hid_dim * 2)
        self.embedding2vocab2 = nn.Linear(self.hid_dim * 2, self.hid_dim * 4)
        self.embedding2vocab3 = nn.Linear(self.hid_dim * 4, self.cn_vocab_size)
        self.dropout = nn.Dropout(dropout)

    def forward(self, input, hidden, encoder_outputs):
        # input = [batch size, vocab size]
        # hidden = [batch size, n layers * directions, hid dim]
        # Decoder 只會是單向，所以 directions=1
        input = input.unsqueeze(1)
        embedded = self.dropout(self.embedding(input))
        # embedded = [batch size, 1, emb dim]
        if self.isatt:
            attn = self.attention(encoder_outputs, hidden)
            # 在這裡決定如何使用 Attention，e.g. 这里是相加 当然也可以 接在後面， 請注意維度變化
        for i in range(hidden.shape[0]):
            hidden[i] += attn # embedding 相加
        output, hidden = self.rnn(embedded, hidden)
        # output = [batch size, 1, hid dim]
        # hidden = [num_layers, batch size, hid dim]

        # 將 RNN 的輸出轉為每個詞出現的機率
        output = self.embedding2vocab1(output.squeeze(1))
        output = self.embedding2vocab2(output)
        prediction = self.embedding2vocab3(output)
        # prediction = [batch size, vocab size]
        return prediction, hidden

在这里插入图片描述
Attention：

Attention部分是个人实现，仅供参考！

match函数是有2层hidden layer的NN

class Attention(nn.Module):
    def __init__(self, hid_dim, device):
        super(Attention, self).__init__()
        self.hid_dim = hid_dim
        self.device = device
        self.match_nn = nn.Sequential(
            nn.Linear(self.hid_dim * 2, self.hid_dim * 4),
            nn.Linear(self.hid_dim * 4, self.hid_dim * 2),
            nn.Linear(self.hid_dim * 2, 1),
        )

    def match(self, h, z):
        alpha = self.match_nn(torch.cat((h, z), dim=1))
        return alpha

    def forward(self, encoder_outputs, decoder_hidden):
        # encoder_outputs = [batch size, sequence len, hid dim * directions]
        # decoder_hidden = [num_layers, batch size, hid dim]
        encoder_outputs = encoder_outputs.permute(1, 0, 2)
        sl = encoder_outputs.shape[0]
        batch_size = encoder_outputs.shape[1]

        alphas = torch.zeros(sl, batch_size).to(self.device)
        for i in range(sl):
            h = encoder_outputs[i]
            # 一般來說是取 Encoder 最後一層的 hidden state 來做 attention
            z = decoder_hidden[-1]
            alpha = self.match(h, z).squeeze()
            alphas[i] = alpha
        alphas = alphas.softmax(dim=0)

        attention = torch.zeros(batch_size, self.hid_dim).to(self.device)
        for i in range(sl):
            alpha = alphas[i].unsqueeze(1)
            h = encoder_outputs[i]
            attention = attention + h * alpha # 做weigh sum

        return attention

这部分就没画在图里面，参考：笔记：ML-LHY: Attention-based Model / Conditional Generation by RNN & Attention
在这里插入图片描述
在这里插入图片描述

Seq2Seq

这部分是总的模型，完整model代码

# model.py
import torch.nn as nn
import torch
import random


class Attention(nn.Module):
    def __init__(self, hid_dim, device):
        super(Attention, self).__init__()
        self.hid_dim = hid_dim
        self.device = device
        self.match_nn = nn.Sequential(
            nn.Linear(self.hid_dim * 2, self.hid_dim * 4),
            nn.Linear(self.hid_dim * 4, self.hid_dim * 2),
            nn.Linear(self.hid_dim * 2, 1),
        )

    def match(self, h, z):
        alpha = self.match_nn(torch.cat((h, z), dim=1))
        return alpha

    def forward(self, encoder_outputs, decoder_hidden):
        # encoder_outputs = [batch size, sequence len, hid dim * directions]
        # decoder_hidden = [num_layers, batch size, hid dim]
        encoder_outputs = encoder_outputs.permute(1, 0, 2)
        sl = encoder_outputs.shape[0]
        batch_size = encoder_outputs.shape[1]

        alphas = torch.zeros(sl, batch_size).to(self.device)
        for i in range(sl):
            h = encoder_outputs[i]
            # 一般來說是取 Encoder 最後一層的 hidden state 來做 attention
            z = decoder_hidden[-1]
            alpha = self.match(h, z).squeeze()
            alphas[i] = alpha
        alphas = alphas.softmax(dim=0)

        attention = torch.zeros(batch_size, self.hid_dim).to(self.device)
        for i in range(sl):
            alpha = alphas[i].unsqueeze(1)
            h = encoder_outputs[i]
            attention = attention + h * alpha

        return attention


class Encoder(nn.Module):
    def __init__(self, en_vocab_size, emb_dim, hid_dim, n_layers, dropout, device):
        super().__init__()
        # 这里的Embedding层参数没有预先训练，可以参考H4进行预训练
        self.embedding = nn.Embedding(en_vocab_size, emb_dim)
        self.hid_dim = hid_dim
        self.n_layers = n_layers
        self.rnn = nn.GRU(emb_dim, hid_dim, n_layers, dropout=dropout, batch_first=True, bidirectional=True)
        self.dropout = nn.Dropout(dropout)

    def forward(self, input):
        # input = [batch size, sequence len, vocab size(其实就是索引，把其看做one hot code，长度为vocab size)]
        embedding = self.embedding(input)
        outputs, hidden = self.rnn(self.dropout(embedding))
        # outputs = [batch size, sequence len, hid dim * directions]
        # hidden =  [num_layers * directions, batch size  , hid dim]
        # outputs 是最上層RNN的輸出

        return outputs, hidden


class Decoder(nn.Module):
    def __init__(self, cn_vocab_size, emb_dim, hid_dim, n_layers, dropout, isatt, device):
        super().__init__()
        self.cn_vocab_size = cn_vocab_size
        self.hid_dim = hid_dim * 2
        self.n_layers = n_layers
        self.embedding = nn.Embedding(cn_vocab_size, emb_dim)
        self.isatt = isatt
        self.attention = Attention(self.hid_dim, device)
        # 如果使用 Attention Mechanism 會使得輸入維度變化，請在這裡修改
        # e.g. Attention 接在輸入後面會使得維度變化，所以輸入維度改為
        # self.input_dim = emb_dim + hid_dim * 2 if isatt else emb_dim
        self.input_dim = emb_dim
        self.rnn = nn.GRU(self.input_dim, self.hid_dim, self.n_layers, dropout=dropout, batch_first=True)
        self.embedding2vocab1 = nn.Linear(self.hid_dim, self.hid_dim * 2)
        self.embedding2vocab2 = nn.Linear(self.hid_dim * 2, self.hid_dim * 4)
        self.embedding2vocab3 = nn.Linear(self.hid_dim * 4, self.cn_vocab_size)
        self.dropout = nn.Dropout(dropout)

    def forward(self, input, hidden, encoder_outputs):
        # input = [batch size, vocab size]
        # hidden = [batch size, n layers * directions, hid dim]
        # Decoder 只會是單向，所以 directions=1
        input = input.unsqueeze(1)
        embedded = self.dropout(self.embedding(input))
        # embedded = [batch size, 1, emb dim]
        if self.isatt:
            attn = self.attention(encoder_outputs, hidden)
            # TODO: 在這裡決定如何使用 Attention，e.g. 相加 或是 接在後面， 請注意維度變化
        for i in range(hidden.shape[0]):
            hidden[i] += attn
        output, hidden = self.rnn(embedded, hidden)
        # output = [batch size, 1, hid dim]
        # hidden = [num_layers, batch size, hid dim]

        # 將 RNN 的輸出轉為每個詞出現的機率
        output = self.embedding2vocab1(output.squeeze(1))
        output = self.embedding2vocab2(output)
        prediction = self.embedding2vocab3(output)
        # prediction = [batch size, vocab size]
        return prediction, hidden


class Seq2Seq(nn.Module):
    def __init__(self, encoder, decoder, device):
        super().__init__()
        self.encoder = encoder
        self.decoder = decoder
        self.device = device
        assert encoder.n_layers == decoder.n_layers, \
            "Encoder and decoder must have equal number of layers!"

    def forward(self, input, target, teacher_forcing_ratio):
        # input  = [batch size (50), input len (60), vocab size]
        # target = [batch size (50), target len (60), vocab size]
        # teacher_forcing_ratio 是有多少機率使用正確答案來訓練
        batch_size = target.shape[0]
        target_len = target.shape[1]
        vocab_size = self.decoder.cn_vocab_size

        # 準備一個儲存空間來儲存輸出(vocab_size 用于概率one hot code)
        outputs = torch.zeros(batch_size, target_len, vocab_size).to(self.device)
        # 將輸入放入 Encoder
        encoder_outputs, hidden = self.encoder(input)
        # Encoder 最後的隱藏層(hidden state) 用來初始化 Decoder
        # encoder_outputs 主要是使用在 Attention
        # 因為 Encoder 是雙向的RNN，所以需要將同一層兩個方向的 hidden state 接在一起
        # hidden =  [num_layers * directions, batch size  , hid dim]  --> [num_layers, directions, batch size  , hid dim]
        hidden = hidden.view(self.encoder.n_layers, 2, batch_size, -1)
        hidden = torch.cat((hidden[:, -2, :, :], hidden[:, -1, :, :]), dim=2)
        # 取的 <BOS> token
        input = target[:, 0]
        preds = []
        for t in range(1, target_len):
            output, hidden = self.decoder(input, hidden, encoder_outputs)
            outputs[:, t] = output
            # 決定是否用正確答案來做訓練
            teacher_force = random.random() <= teacher_forcing_ratio
            # 取出機率最大的單詞
            top1 = output.argmax(1)
            # 如果是 teacher force 則用正解訓練，反之用自己預測的單詞做預測
            input = target[:, t] if teacher_force and t < target_len else top1
            preds.append(top1.unsqueeze(1))
        preds = torch.cat(preds, 1)
        return outputs, preds

    def inference(self, input, target):
        ########
        # TODO #
        ########
        # 在這裡實施 Beam Search
        # 此函式的 batch size = 1
        # input  = [batch size, input len, vocab size]
        # target = [batch size, target len, vocab size]
        batch_size = input.shape[0]
        input_len = input.shape[1]  # 取得最大字數
        vocab_size = self.decoder.cn_vocab_size

        # 準備一個儲存空間來儲存輸出
        outputs = torch.zeros(batch_size, input_len, vocab_size).to(self.device)
        # 將輸入放入 Encoder
        encoder_outputs, hidden = self.encoder(input)
        # Encoder 最後的隱藏層(hidden state) 用來初始化 Decoder
        # encoder_outputs 主要是使用在 Attention
        # 因為 Encoder 是雙向的RNN，所以需要將同一層兩個方向的 hidden state 接在一起
        # hidden =  [num_layers * directions, batch size  , hid dim]  --> [num_layers, directions, batch size  , hid dim]
        hidden = hidden.view(self.encoder.n_layers, 2, batch_size, -1)
        hidden = torch.cat((hidden[:, -2, :, :], hidden[:, -1, :, :]), dim=2)
        # 取的 <BOS> token
        input = target[:, 0]
        preds = []
        for t in range(1, input_len):
            output, hidden = self.decoder(input, hidden, encoder_outputs)
            # 將預測結果存起來
            outputs[:, t] = output
            # 取出機率最大的單詞
            top1 = output.argmax(1)
            input = top1
            preds.append(top1.unsqueeze(1))
        preds = torch.cat(preds, 1)
        return outputs, preds


def save_model(model, optimizer, store_model_path, step):
    torch.save(model.state_dict(), f'{store_model_path}/model_{step}.ckpt')
    return


def load_model(model, load_model_path):
    print(f'Load model from {load_model_path}')
    model.load_state_dict(torch.load(f'{load_model_path}.ckpt'))
    return model


def build_model(config, en_vocab_size, cn_vocab_size, device):
    # 建構模型
    encoder = Encoder(en_vocab_size, config.emb_dim, config.hid_dim, config.n_layers, config.dropout, device)
    decoder = Decoder(cn_vocab_size, config.emb_dim, config.hid_dim, config.n_layers, config.dropout, config.attention,
                      device)
    model = Seq2Seq(encoder, decoder, device)
    print(model)
    # 建構 optimizer
    optimizer = torch.optim.Adam(model.parameters(), lr=config.learning_rate)
    print(optimizer)
    if config.load_model:
        model = load_model(model, config.load_model_path)
    model = model.to(device)

    return model, optimizer

总model图：
在这里插入图片描述
在这里插入图片描述

其他

剩下就是训练流程代码
请参考TA的代码或者本文代码(文件已整理)
本文网络图
本文对应课程笔记

snoopy_21
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从RNN到Attention到Transformer系列-Attention介绍及代码实现
AI-Mei的博客
05-12 1148
深度学习知识点总结 专栏链接:深度学习知识点总结_Mr.小梅的博客-CSDN博客本专栏主要总结深度学习中的知识点，从各大数据集比赛开始，介绍历年冠军算法；同时总结深度学习中重要的知识点，包括损失函数、优化器、各种经典算法、各种算法的优化策略Bag of Freebies (BoF)等。 本章介绍从RNN到Attention到Transformer系列-Attention介绍及代码实现。 目录 3.4 Attention介绍 3.4.1Encode 3.4.2Attention 3.4...
pytorch中nn.Embedding和nn.LSTM和nn.Linear
wangyangjingjing的博客
02-22 4354
CLASS torch.nn.Embedding(num_embeddings: int, embedding_dim: int, padding_idx: Optional[int] = None, max_norm: Optional[float] = None, norm_type: float = 2.0, scale_grad_by_freq: bool = False, sparse: bool = False, _weight: Optional[.
Pytorch实战_Seq2seq模型
hello_JeremyWang的博客
01-27 3623
1. Sequence-to-Sequence 简介 大多数常见的 sequence-to-sequence (seq2seq) model 为 encoder-decoder model，主要由两个部分组成，分别是 Encoder 和 Decoder，而这两个部分大多数是由 recurrent neural network (RNN) 实现。 Encoder 是将一连串的输入，如文字、影片、声音讯号等，编码为单个向量，这个向量可以想像为整个输入的抽象表示，包含了整个输入的资讯。 Decoder 是將 En
hw8_seq2seq库函数总结
weixin_43963453的博客
02-23 181
这里写目录标题npnp.pad() np np.pad()
Hung-Yi Lee homework[8]: Sequece to Sequence
CRR的博客
08-03 478
Hung-Yi Lee homework[8]: Sequece to Sequence
DeepLearning-LHY21-Notes-master
最新发布
06-12
深度学习 HTML 链接 01_Regression_P1 02_Regression_P2 03_GeneralGuidance_Overfitting 04_Local Minimum And Saddle Point 05_Batch and Momentum 06_Adaptive Learning Rate 07_Batch ...26_Expl
LHY-2020-:课程安排：http
03-30
LHY-2020-深度学习-笔记 总课程设置： ://speech.ee.ntu.edu.tw/~tlkagk/courses_ML20.html 每章的视频，笔记，作业范例，说明，代码，补充知识点 01_课程简介 视频：Introduction（课程概述），Rule（助教介绍工具...
matlab流量代码程序-lhy_experiment:刘红雨毕业论文代码
05-23
2. **数据处理与信号分析** MATLAB提供了丰富的工具箱进行数据处理和信号分析，例如滤波器设计、频谱分析、时间序列分析等。在流量控制中，可能需要对流量数据进行预处理，如去除噪声，提取特征，或者进行实时监控...
lhy-admin-web
05-13
【lhy-admin-web】是一个基于Java的Web项目模板，它采用了Spring、SpringMVC、MyBatis和Maven等核心技术，旨在为开发者提供一个快速搭建后台管理系统的基础框架。这个项目的主要目标是简化开发流程，让开发者能够更...
react-music-lhy:基于react16+ react-router4+ typescript react-redux的移动端音乐播放器
05-06
一个适合练手的react项目 项目正在用hooks重构 体会vue与react项目区别 声明：本项目参考了滴滴大佬的vue项目，原vue项目请关注 项目运行 后端项目启动 安装mysql ...登录用户: mysql -uroot -p ...2、alias与tsconfig
pytorch官方教程3 translation with seq2seq and attention
ronghwa_lu
11-29 306
前言 在看李宏毅的hw8：seq-to-seq时，发现要动手完成下面任务，懵了。 我还是个初学者，虽然我最近看了李宏毅关于语音辨识部分,也看完hw4，但代码能力还是0。 网上找不到这次作业任务的实现，找到pytorch官网关于seq-to-seq的实现，先学一下。 资料 知识都是借鉴和查出来的。 pytorch官网，建议还是看英文。 csdn博客，也是应用attention原理在hw4作业的那一位，but他也没实现hw8。 torchtext：对此模块没了解过 We hope after you com
NLP入门（三）：seq2seq之GRU对齐文本和机器翻译
WYXHAHAHA123的博客
03-31 3074
首先来回顾之前用到的两种seq2seq模型（sequence to sequence） （1）和（2）编码器结构完全相同，只不过（1）使用的是单向LSTM，（2）使用的是单向的GRU，二者的重要区别在于decoder部分。看RNN的输入，要看它左边的箭头（time step时间节点）和下面的箭头（与RNN的层数相关）。 注意：编码器中时间节点t的hidden state用h(t)表示，...
numpy.pad()函数用法
zzy_pphz的博客
08-28 1730
numpy.pad（） 方法参数：pad(array, pad_width, mode, **kwargs) 方法返回：填充后的数组 参数解释： array：表示需要填充的数组； pad_width：表示每个轴（axis）边缘需要填充的数值数目。 参数输入方式为：（(before_1, after_1), … (before_N, after_N)），其中(before_1, after_1)表示第1轴两边缘分别填充before_1个和after_1个数值。 mode：表示填充的方式（取值：str字符串或用
【PyTorch】Caught RuntimeError in DataLoader worker process 0和invalid argument 0: Sizes of tensors mus
热门推荐
upup
07-03 2万+
报错如下： Traceback (most recent call last): File "/home/jiang/miniconda3/envs/Net/lib/python3.6/site-packages/tqdm/std.py", line 1178, in __iter__ for obj in iterable: File "/home/jiang/miniconda3/envs/Net/lib/python3.6/site-packages/torch/utils/data/
论文笔记：ImageNet Classification with Deep Convolutional Neural Networks（AlexNet）
upup
05-31 9928
一、基本信息 标题：ImageNet Classification with Deep Convolutional Neural Networks 时间：2012 出版源：Neural Information Processing Systems (NIPS) 论文领域：深度学习，计算机视觉 引用格式：Krizhevsky A, Sutskever I, Hinton G E. Imagenet classification with deep convolutional neural networks[C
Keras中evaluate/evaluate_generator和predict/predict_generator理解
upup
09-26 8485
具体各个函数参数可以查看官方文档 evaluate/evaluate_generator evaluate接收的参数更为简单，大多数情况只需指定x和y。 evaluate_generator需要指定datagenerator。自定义datagenerator，带来的好处就是可以异步加载数据到内存，支持多线程等。 下面以evaluate_generator为例，介绍使用方法： # Loss Function model_func = { 'loss': tensor_angle_loss, '
论文笔记：Deep Residual Learning for Image Recognition（ResNet）
upup
06-09 4890
一、基本信息 标题：Deep Residual Learning for Image Recognition 时间：2015 第一作者：Kaiming He 论文领域：深度学习、计算机视觉、CNN 引用格式：He K, Zhang X, Ren S, et al. Deep residual learning for image recognition[C]//Proceedings of the IEEE conference on computer vision and pattern recognit
论文笔记：Going deeper with convolutions（GoogLeNet）
upup
06-07 3382
一、基本信息 标题：Going deeper with convolutions 时间：2014 出版源：IEEE 论文领域：深度学习，CNN 引用格式：Szegedy C, Liu W, Jia Y, et al. Going deeper with convolutions[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2015: 1-9. 二、研究背景 随着移动设备和嵌入式发展，算法
Keras自定义数据生成器和数据增强教程
upup
09-24 2718
本文翻译：A detailed example of how to use data generators with Keras 。主要是想分享其通用框架和自定义数据增强。 By Afshine Amidi and Shervine Amidi 数据增强的动机 在小规模数据集上，我们往往一次性把数据读入内存。但是随着数据越来越多，数据集加载本身就已经占用很多内存，如果再进行数据增强，很可能导致内存无法一次性读取这么多数据。我们需要一个灵活的数据读取和增强方式。 所以这篇博客将要展示如实时生成数据集和数.
get data from Nacos error,dataId:inspur-digital-bspplus-lhy
10-27
根据提供的引用内容，您遇到的问题可能是由于nacos读取配置文件默认使用UTF-8，而您的项目默认编码格式为GBK，导致无法正常读取配置文件。解决办法有两种： 1. 添加启动参数-Dfile.encoding=utf-8，这样就能正常启动...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值