静态词向量之FFNN训练词向量

最新推荐文章于 2024-03-31 11:30:22 发布
最新推荐文章于 2024-03-31 11:30:22 发布
阅读量507 收藏
点赞数
文章标签： 深度学习 自然语言处理 人工智能 神经网络 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ox180x/article/details/124095636
版权

介绍

本文分享几个好玩的知识点：

  1. 前馈神经网络
  2. bag of words(词袋)
  3. 使用ffnn获取词向量

前馈神经网络

什么叫前馈神经网络呢，emmm，自个去看百度百科定义前馈神经网络。简单来说，就是两个linear加一个激活函数，简单结构如下:

1
2
3
4
5
6
7
8
class FFNN(nn.Module):
    def __init__(self):
        self.linear1 = nn.Linear()
        self.active_func = F.relu
        self.linear2 = nn.Linear()

    def forward(self, x):
        return self.linear2(self.active_func(self.linear1(x)))

其中大名鼎鼎的transformer中也用到了FFNN，所以要认真对待每一种结构哦。

bag of words(词袋)

啥叫词袋呢，emmmm，这个咋解释呢？就是从一堆词取context_size大小的词回来。它没有顺序，所以叫做词袋。比如unigram, bigram, trigram，ngram，都是属于词袋。

而大名鼎鼎的word2vec也是属于词袋这种的哦！这里画重点。

使用ffnn获取词向量

这里就不难理解了，就是换一种方式来实现词向量的获取方式。我在这两采用了两种方式，第一种是以前面两个词为准，获取当前词，这叫做用过去的词来预测未来的词。嘿嘿，如果脑洞大开点的话，是不是有种transformer encoder的感觉😂😂😂。

1. 使用过去词预测当前词

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
# Defined in Section 5.3.1.2

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import Dataset
from tqdm.auto import tqdm

from utils import BOS_TOKEN, EOS_TOKEN
from utils import load_reuters, save_pretrained, get_loader, init_weights


def cal_similar(w):
    v = model.embeddings.weight[vocab[w]]
    values, indices = torch.mm(model.embeddings.weight, v.view(-1, 1)).topk(dim=0, k=3)
    similar_tokens = vocab.convert_ids_to_tokens(indices.view(-1).tolist())
    return similar_tokens


def demos():
    tokens = ['china', 'august', 'good', 'paris']
    for token in tokens:
        s = cal_similar(token)
        print(f'{token}: {s}')
class NGramDataset(Dataset):
    def __init__(self, corpus, vocab, context_size=2):
        self.data = []
        self.bos = vocab[BOS_TOKEN]
        self.eos = vocab[EOS_TOKEN]
        for sentence in tqdm(corpus, desc="Dataset Construction"):
            # 插入句首句尾符号
            sentence = [self.bos] + sentence + [self.eos]
            if len(sentence) < context_size:
                continue
            for i in range(context_size, len(sentence)):
                # here，只取之前的词
                # 模型输入：长为context_size的上文
                context = sentence[i-context_size:i]
                # 模型输出：当前词
                target = sentence[i]
                self.data.append((context, target))

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

    def __getitem__(self, i):
        return self.data[i]

    def collate_fn(self, examples):
        # 从独立样本集合中构建batch输入输出
        inputs = torch.tensor([ex[0] for ex in examples], dtype=torch.long)
        targets = torch.tensor([ex[1] for ex in examples], dtype=torch.long)
        return (inputs, targets)

class FeedForwardNNLM(nn.Module):
    def __init__(self, vocab_size, embedding_dim, context_size, hidden_dim):
        super(FeedForwardNNLM, self).__init__()
        # 词嵌入层
        self.embeddings = nn.Embedding(vocab_size, embedding_dim)
        # 线性变换：词嵌入层->隐含层
        self.linear1 = nn.Linear(context_size * embedding_dim, hidden_dim)
        # 线性变换：隐含层->输出层
        self.linear2 = nn.Linear(hidden_dim, vocab_size)
        # 使用ReLU激活函数
        self.activate = F.relu
        init_weights(self)

    def forward(self, inputs):
        embeds = self.embeddings(inputs).view((inputs.shape[0], -1))
        hidden = self.activate(self.linear1(embeds))
        output = self.linear2(hidden)
        # 根据输出层(logits)计算概率分布并取对数，以便于计算对数似然
        # 这里采用PyTorch库的log_softmax实现
        log_probs = F.log_softmax(output, dim=1)
        return log_probs

embedding_dim = 64
context_size = 2
hidden_dim = 128
batch_size = 1024
num_epoch = 10

# 读取文本数据，构建FFNNLM训练数据集(n-grams)
corpus, vocab = load_reuters()
dataset = NGramDataset(corpus, vocab, context_size)
data_loader = get_loader(dataset, batch_size)

# 负对数似然损失函数
nll_loss = nn.NLLLoss()
# 构建FFNNLM，并加载至device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = FeedForwardNNLM(len(vocab), embedding_dim, context_size, hidden_dim)
model.to(device)
# 使用Adam优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)

model.train()
total_losses = []
for epoch in range(num_epoch):
    total_loss = 0
    for batch in tqdm(data_loader, desc=f"Training Epoch {epoch}"):
        inputs, targets = [x.to(device) for x in batch]
        optimizer.zero_grad()
        log_probs = model(inputs)
        loss = nll_loss(log_probs, targets)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Loss: {total_loss:.2f}")
    total_losses.append(total_loss)
    demos()
# 保存词向量(model.embeddings)
save_pretrained(vocab, model.embeddings.weight.data, "ffnnlm.vec")

2. 使用过去和未来的词预测当前词

是不是像cbow～

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

# Defined in Section 5.3.1.2

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import Dataset
from tqdm.auto import tqdm
from utils import BOS_TOKEN, EOS_TOKEN
from utils import load_reuters, save_pretrained, get_loader, init_weights
from torch.optim.lr_scheduler import ExponentialLR
def cal_similar(w):
    v = model.embeddings.weight[vocab[w]]
    values, indices = torch.mm(model.embeddings.weight, v.view(-1, 1)).topk(dim=0, k=3)
    similar_tokens = vocab.convert_ids_to_tokens(indices.view(-1).tolist())
    return similar_tokens


def demos():
    tokens = ['china', 'august', 'good', 'paris']
    for token in tokens:
        s = cal_similar(token)
        print(f'{token}: {s}')

class NGramDataset(Dataset):
    def __init__(self, corpus, vocab, context_size=2):
        self.data = []
        self.bos = vocab[BOS_TOKEN]
        self.eos = vocab[EOS_TOKEN]
        for sentence in tqdm(corpus, desc="Dataset Construction"):
            # 插入句首句尾符号
            sentence = [self.bos] + sentence + [self.eos]
            if len(sentence) < context_size:
                continue
            for i in range(context_size, len(sentence) - context_size):
                # 就这里哦
                # 模型输入：长为context_size的上文
                left_context = sentence[i-context_size:i]
                right_context = sentence[i+1: i+context_size + 1]
                context = [*left_context, *right_context]
                # 模型输出：当前词
                target = sentence[i]
                self.data.append((context, target))

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

    def __getitem__(self, i):
        return self.data[i]

    def collate_fn(self, examples):
        # 从独立样本集合中构建batch输入输出
        inputs = torch.tensor([ex[0] for ex in examples], dtype=torch.long)
        targets = torch.tensor([ex[1] for ex in examples], dtype=torch.long)
        return (inputs, targets)

class FeedForwardNNLM(nn.Module):
    def __init__(self, vocab_size, embedding_dim, context_size, hidden_dim):
        super(FeedForwardNNLM, self).__init__()
        # 词嵌入层
        self.embeddings = nn.Embedding(vocab_size, embedding_dim)
        # 线性变换：词嵌入层->隐含层
        self.linear1 = nn.Linear(context_size * embedding_dim * 2, hidden_dim)
        # 线性变换：隐含层->输出层
        self.linear2 = nn.Linear(hidden_dim, vocab_size)
        # 使用ReLU激活函数
        self.activate = F.relu
        # init_weights(self)
        self.dp = nn.Dropout(0.1)

    def forward(self, inputs):
        embeds = self.embeddings(inputs).view((inputs.shape[0], -1))
        hidden = self.activate(self.linear1(embeds))
        output = self.linear2(hidden)
        # 根据输出层(logits)计算概率分布并取对数，以便于计算对数似然
        # 这里采用PyTorch库的log_softmax实现
        # output = self.dp(output)
        log_probs = F.log_softmax(output, dim=1)
        return log_probs

embedding_dim = 64
context_size = 2
hidden_dim = 128
batch_size = 10240
num_epoch = 10

# 读取文本数据，构建FFNNLM训练数据集(n-grams)
corpus, vocab = load_reuters()
dataset = NGramDataset(corpus, vocab, context_size)
data_loader = get_loader(dataset, batch_size)

# 负对数似然损失函数
nll_loss = nn.NLLLoss()
# 构建FFNNLM，并加载至device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = FeedForwardNNLM(len(vocab), embedding_dim, context_size, hidden_dim)
model.to(device)
# 使用Adam优化器
optimizer = optim.Adam(model.parameters(), lr=0.01)
scheduler = ExponentialLR(optimizer, gamma=0.9)
model.train()
total_losses = []
for epoch in range(num_epoch):
    total_loss = 0
    for batch in tqdm(data_loader, desc=f"Training Epoch {epoch}"):
        inputs, targets = [x.to(device) for x in batch]
        optimizer.zero_grad()
        log_probs = model(inputs)
        loss = nll_loss(log_probs, targets)
        loss.backward()
        optimizer.step()

        total_loss += loss.item()

    print(f"Loss: {total_loss:.2f}, LR: {scheduler.get_last_lr()[0]}")
    scheduler.step()
    demos()
    total_losses.append(total_loss)

# 保存词向量(model.embeddings)
save_pretrained(vocab, model.embeddings.weight.data, "ffnnlm.vec")

总结

这两者之间就以下几点不同：

  1. NGramDataset那里在获取context_size的词时不一样
  2. 训练时linear1的in_feature大小变了。

其余都一样哦，可以自己跑一跑呢。

ox180x
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
机器学习笔记 - 前馈神经网络(FFNN)用作回归问题的波士顿房价预测
学以致用 知行合一
12-26 4242
FFNN的历史可以追溯到1940年代，它是没有任何循环的网络。数据从输入到输出通过一次传递，而没有以前的任何“状态存储”。 从技术上讲，深度学习中的大多数网络都可以被认为是FFNN，但通常“ FFNN”是指其最简单的变体：紧密连接的多层感知器（MLP）。 深度前馈网络（通常也称为前馈神经网络）或多层感知器（MLP）是典型的深度学习模型。前馈网络的目标是近似某个函数f *。 例如，对于分类器，y = f *（x）将输入x映射到类别y。 前馈网络定义映射y = f（x, θ）并学习参数θ的值，
FF或称FFNN模型：前馈神经网络和感知机
Joycezzz的博客
08-21 1515
Feed forward neural networks and perceptrons目录一、知识基础1.概念2.图解二、模型demo1.库的安装2.学习封装的Layer函数example.pyutility.pydataset.pycost.pyactivation.pynetwork.pyproblem.pyevaluation.pygradient.pyplot.pyoptimization.pytrainer.pymain.py 目录 一、知识基础 1.概念 前馈神经网络和感知机，信息从前（输入）
前馈神经网络（FFNN）和多层感知机（MLP）
ZYM66的博客
09-20 2906
这意味着所有的 MLP 都是 FFNN，但并不是所有的 FFNN 都是 MLP。MLP 使用非线性激活函数，例如 sigmoid、tanh 或 ReLU，否则多个线性层的组合仍然会是线性的。FFNN 的主要特点是它们没有循环或记忆元素，因此与循环神经网络（RNN）和其他包含反馈机制的网络不同。FFNN 是一种更为泛化的术语，用于描述数据在网络中单向传播的网络，从输入层到输出层，没有反馈或循环。MLP 是一个由三种类型的层组成的神经网络：输入层、一个或多个隐藏层和输出层。
【MATLAB第88期】基于MATLAB的6种神经网络（ANN、FFNN、CFNN、RNN、GRNN、PNN）多分类预测模型对比含交叉验证
随风飘摇的土木狗的博客
01-03 3045
1.本文介绍六种类型的神经网络分类预测模型前馈神经网络 (FFNN)人工神经网络 (ANN)级联前向神经网络 (CFNN)循环神经网络 (RNN)广义回归神经网络 (GRNN)概率神经网络 (PNN)2.数据情况357行样本，12输入，1输出，4分类。无交叉验证情况，默认70%训练，30%测试。
神经网络学习（2）：FFNN，P，RNN，LSTM，GRU……
热门推荐
clover_my的博客
05-14 1万+
神经网络学习（2）：P，FF，RBF，DFF，RNN，LSTM，CNN…… THE NEURAL NETWORK ZOO 其中大多数是神经网络，但也有些完全不同。此列表并不全面，仍需不断更新。 将它们绘制为节点映射的一个问题是：它并没有真正显示它们是如何被使用的。例如，变分自动编码机（VAE）可能看起来就像自动编码机（AE），但训练过程实际上是完全不同的。受过训练的网络的用例差别更大，因为VA...
FFNN.rar_ffnn
09-14
在MATLAB环境中，FFNN可以通过神经网络工具箱来创建、训练和应用。 该压缩包中的主要文件是FFNN.pdf，这很可能是一份详细的操作指南或教程，涵盖了FFNN的构建、训练和使用步骤。通常，这样的文档会包括以下内容： ...
ffnn.zip_delphi neural_ffnn_ffnn.zip
09-23
FFNN（Feed Forward Neural Network，前馈神经网络）是一种在人工智能和机器学习领域广泛应用的神经网络模型。在Delphi编程环境中，你可以利用源代码来构建和实现这种神经网络。本压缩包"ffnn.zip_delphi neural_...
利用传统图像分类方法对 FashionMNIST 数据集进行分类
最新发布
06-23
在这个项目中，我们将重点讨论两种主要的方法：支持向量机（SVM）和前馈神经网络（FFNN）。SVM 是一种强大的监督学习模型，尤其适用于小样本数据集，它通过找到最优超平面来实现分类，这个超平面可以最大化两类样本...
matlab代码影响-knowledge-extract-ffnn-mnist:从FFNN上接受MNIST训练的知识摘录
05-22
matlab代码影响在MNIST数据库上训练的前馈神经网络中的知识提取 有点背景 受到用于手写数字识别的神经网络在线演示的启发。 休伯特·艾希纳（Hubert Eichner）。 在MATLAB的MNIST数据集上对网络进行了训练，然后将...
Facet-Vertex-FFNN
05-27
FFNN可到达集的计算 介绍 该存储库用于使用Facet-Vertex关联对Deep ReLU神经网络进行可达性分析。 注意：建议使用64GB RAM生成所有结果。 检查环境 软件 Ubunu 18.04 Python 3.6 Matlab 2019b for plotting Figure...
30个神经网络算法源程序
01-28
神经网络算法源程序大全神经网络算法源程序大全神经网络算法源程序大全神经网络算法源程序大全
神经网络neural network
chuange6363的博客
08-14 225
http://blog.csdn.net/pipisorry/article/details/76095118 前馈神经网络：FFNN模型（feedforward neural network） 固定基函数的线性组合构成的回归模型和分类模型。我们看到,这些模型具有一些有用的分析性质和计算性...
手工计算深度学习模型中的参数数量
喜欢打酱油的老鸟
02-04 2768
https://www.toutiao.com/a6649299295855968782/   2019-01-22 20:37:14   计算深度学习模型的可训练参数的数量被认为太微不足道了，因为您的代码已经可以为您完成此操作。但是我想在这里留下笔记，让我们偶尔参考一下。以下是我们将要运行的神经网络模型： 前馈神经网络（FFNN） 循环神经网络（RNN） 卷积神经网络（CNN）...
机器学习算法 - 从线性回归到前馈神经网络
jeffliu123的博客
11-02 663
在本文中，主要有以下内容: 线性回归:对两个变量之间的线性关系进行建模的回归方法，介绍了L1和L2的损失。 逻辑回归:一种分类算法及一种分类损失，交叉熵损失。 梯度下降优化:一种寻找损失最小化问题最优解的迭代算法。 前馈神经网络:一种由完全连接的层组成的神经网络。 反向传播:一种利用链式法则计算神经网络中损失梯度的算法。 用神经网络进行图像分类:如何将图像在前馈神经网络中输入。
Transformer相关知识
weixin_46042619的博客
03-31 993
Transformer是一种深度学习模型架构，最初由Vaswani等人在2017年的一篇论文中提出，用于处理序列到序列的任务，如机器翻译。它是一种基于注意力机制的模型，相比传统的循环神经网络（RNN）或卷积神经网络（CNN），Transformer在处理长序列时表现更好，并且可以更好地并行化处理。Transformer已经成为自然语言处理领域的重要基础模型，并且在其他领域也有广泛的应用。
Transformer理解实现
追光少年的博客
05-13 1020
注意力机制是一种在现代深度学习模型中无处不在的方法，它有助于提高神经机器翻译应用程序性能的概念。在本文中，我们将介绍Transformer这种模型，它可以通过注意力机制来提高训练模型的速度。在特定任务中，Transformer的表现优于Google神经机器翻译模型。但是，最大的好处来自于Transformer如何适用于并行化。实际上，Google Cloud建议使用Transformer作为参考模型来使用其Cloud TPU产品。因此，我们试试将模型分解开吧，看看它是如何工作的。 ...
Transformer学习笔记
qq_52778783的博客
03-24 2496
一. Transformer诞生背景 Transformer模型是解决序列转录问题的一大创新。在Transformer模型之前，序列转录模型都或多或少的基于复杂的循环或卷积神经网络。 循环神经网络的计算是时序性的，位置的计算必须基于之前所有位置的计算结果，因此循环神经网络上的计算难以并行，效率较低。而且在翻译长句时，循环或卷积神经网络对之前文本的“记忆”是有限的，采用时序计算很可能丢掉之前的重要信息。 为了改善长句翻译过程中信息丢失的问题，诞生了Atte...
前馈神经网络
weixin_30455661的博客
07-11 301
前馈神经网络（ffnn）：由一个输入层，一到多个隐藏层，有一个输出层组成。数据通过网络一层层向后传递，直到输出层，之间没有反馈回路。 前馈神经网络可得到的函数： 1、有一个隐藏层的网络，可形成任意一个连续函数 2、有俩个及以上的隐藏层，可形成任意函数，包括连续函数和离散函数 说明：设计一个计算函数的网络，是无法确定网络有多少层，每层有多少神经元；一般是根据经验设计的，对于新手，还...
神经网络与深度学习（五）前馈神经网络（3）鸢尾花分类
weixin_53651790的博客
10-13 2522
pytorch前馈神经网络实现鸢尾花数据集分类任务
MLP和FFNN的区别
03-26
MLP（多层感知器）和FFNN（前馈神经网络）是两种常见的人工神经网络模型，它们在某些方面有一些相似之处，但也存在一些区别。 MLP是一种基于神经元层级结构的神经网络模型，它由输入层、隐藏层和输出层组成。每个神经元都与前一层的所有神经元相连，通过权重和激活函数来传递和处理信息。MLP可以用于分类和回归任务，并且在处理非线性问题时表现良好。 FFNN是一种特殊类型的MLP，它是指没有反馈连接的前馈神经网络。在FFNN中，信息只能从输入层流向输出层，不存在循环连接。这意味着FFNN是一个有向无环图，信息在网络中只能单向传播。FFNN通常由多个全连接层组成，每个神经元都与前一层的所有神经元相连。 因此，可以说FFNN是MLP的一种特殊形式，即没有反馈连接的多层感知器。FFNN更加简单和直观，容易理解和实现。而MLP则更加灵活，可以处理更加复杂的问题，并且具有更强的表达能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值