pytorch导入Word2Vec的问题

初学者在pytorch中构建的TectCNN模型导入Word2Vec向量的时候总出问题，还请襄助。
模型：

class TextCNN(nn.Module):
    def __init__(self, num_classes: object, num_embeddings: object = -1, embedding_dim: object = 128, kernel_sizes: object = [3, 4, 5, 6],
                 num_channels: object = [256, 256, 256, 256], embeddings_pretrained: object = None) -> object:

        super(TextCNN, self).__init__()
        self.num_classes = num_classes
        self.num_embeddings = num_embeddings
        # embedding层
        if self.num_embeddings > 0:
            # embedding之后的shape: torch.Size([8, 81, 128])，引入word2vec[112,128]后为[8,81,128,128],
            self.embedding = nn.Embedding(num_embeddings, embedding_dim)
            if embeddings_pretrained is not None:
                self.embedding = self.embedding.from_pretrained(embeddings_pretrained, freeze=False)#pretained:[112,128]
                self.embedding.weight.requires_grad = True
        # 卷积层
        self.cnn_layers = nn.ModuleList()  # 创建多个一维卷积层
        for c, k in zip(num_channels, kernel_sizes):
            cnn = nn.Sequential(
                nn.Conv1d(in_channels=embedding_dim,
                          out_channels=c,
                          kernel_size=k),
                nn.BatchNorm1d(c),
                nn.ReLU(inplace=True),
            )
            self.cnn_layers.append(cnn)
        # 最大池化层
        self.pool = GlobalMaxPool1d()
        # 输出层
        self.classify = nn.Sequential(
            nn.Dropout(p=0.2),
            nn.Linear(sum(num_channels), self.num_classes)
        )

    def forward(self, input):
        print('input_shape',input.shape)
        if self.num_embeddings > 0:
            # 得到词嵌入(b,context_size)-->(b,context_size,embedding_dim)
            input = self.embedding(input)
            # (batch_size, context_size, channel)->(batch_size, channel, context_size)
        print(input.shape)
        input = input.permute(0, 2, 1)
        print(input.shape)
        y = []
        for layer in self.cnn_layers:
            x = layer(input)
            x = self.pool(x).squeeze(-1)
            y.append(x)
        y = torch.cat(y, dim=1)
        out = self.classify(y)
        return out

获取词典的Word2Vec向量:

    def get_embedding_weight(self):
        #wvmodel = self.model.load_model('data/vectors.txt')

        vocab_size = self.num_embeddings
        embed_size = 128
        weight = torch.zeros(vocab_size, embed_size)

        #word_to_idx = {word: i+1 for i, word in enumerate(self.vocabulary)}

        for i in range(len(self.word_to_idx)):
            try:
                index = self.word_to_idx[self.model.wv.index2word[i]]
            except:
                continue
            weight[index, :] = torch.from_numpy(self.model.wv.get_vector(
                self.idx_to_word[self.word_to_idx[self.model.wv.index2word[i]]]))
            print('weight:',weight[index])
        return weight

将向量提供给模型中的embeddings_pretrained：

self.weight=dataset.get_embedding_weight()

model = build_models.get_models(net_type=self.cfg.net_type,
                                        num_classes=self.cfg.num_classes,
                                        num_embeddings=self.cfg.num_embeddings,
                                        embedding_dim=128,
                                        is_train=True,
                                        pretrained=self.weight,)

def get_models(net_type, num_classes, num_embeddings, embedding_dim=128, context_size=None, is_train=True,
               pretrained=None, **kwargs):
    model = textcnn.TextCNN(num_classes=num_classes, num_embeddings=num_embeddings, embedding_dim=embedding_dim,
                                embeddings_pretrained=pretrained)

训练数据集的--getitem--函数：

    def __getitem__(self, index):

        text, label = copy.deepcopy(self.item_list[index])  # fix a bug: 
        #text, label = augment.random_text_crop(text, label, self.context_size, token=self.pad_token, p=0.)
        # 将字词映射为ID序号
        # text_id = self.map_word_to_idx(text, unknown=self.padding)
        embedding = self.get_word_embedding(text)

        label = self.class_to_idx[label]
        # label = self.class_dict[label]
        if len(embedding) > 0:
            embedding = np.asarray(embedding, dtype=np.int64)#float32)
            label = np.asarray(label, dtype=np.int32)
            embedding = torch.from_numpy(embedding)
            label = torch.from_numpy(label).long()
        else:
            index = int(random.uniform(0, len(self)))
            return self.__getitem__(index)
        return embedding, label

    def get_word_embedding(self, words):
        embedding = self.word2vec.get_words_vector(words)
        return embedding

    def get_vector(self, key, norm=False):
        """Get the key's vector, as a 1D numpy array."""
        return self.model.wv.get_vector(key, norm=norm)

现在的错误是：Expected 2D (unbatched) or 3D (batched) input to conv1d, but got input of size: [8, 128, 81, 128]，
之前还出现过各种错误，比如：
number of dimensions in the tensor input does not match the length of the desired ordering of dimensions
expected tensor for argument #1 'indices' to have one of the following scalar types: long, int; but got torch.cuda.floattensor instead (while checking arguments for embedding)
RuntimeError: expected type torch.FloatTensor but got torch.cuda.FloatTensor
等等，还请帮忙解决一下问题，让代码能正常运行。

题主，这个问题我来替你解决(参考结合AI智能、文心一言)，若有帮助，还望采纳，点击回答右侧采纳即可。

这个错误提示告诉我们 conv1d 函数需要接收一个2D或3D的输入，但是现在传入的输入大小为 [8, 128, 81, 128]，这是一个 4D 的张量。

解决办法：

1. 确认输入张量维度是否正确，如果不是2D或3D的张量，那么可以通过 reshape 函数将其转换为2D或3D的张量。

2. 检查代码中是否有不必要的维度或者多余的维度。

3. 可以尝试在输入张量上应用 squeeze 函数来降低维度。

4. 确认传入神经网络的 batch_size 是否正确，如果 batch_size 的值与输入张量的第一个维度不匹配，那么传入的张量大小也会出现错误。

你的代码根本不通啊，是GPT生成的么？
哪怕你去github找几个例子代码也比这 GPT的靠谱。

结合GPT给出回答如下请题主参考
首先，导入Word2Vec需要使用Python中的gensim模块。您可以在安装了PyTorch的环境中执行以下命令来安装gensim：

pip install gensim

接下来，您需要加载已经训练好的Word2Vec模型，并将其用于TextCNN模型中。

以下是一个可能的解决方案：

import gensim
import torch.nn as nn

# 加载已经训练好的Word2Vec模型
model = gensim.models.Word2Vec.load('path_to_your_word2vec_model')

class TextCNN(nn.Module):
    def __init__(self, embedding_size, num_filters, filter_sizes, num_classes):
        super(TextCNN, self).__init__()
        self.embedding = nn.Embedding(len(model.wv.vocab), embedding_size)
        self.embedding.weight.data.copy_(torch.from_numpy(model.wv.vectors))
        self.conv_layers = nn.ModuleList([
            nn.Conv2d(1, num_filters, (filter_size, embedding_size)) for filter_size in filter_sizes
        ])
        self.dropout = nn.Dropout(0.5)
        self.fc = nn.Linear(num_filters * len(filter_sizes), num_classes)
    
    def forward(self, x):
        x = self.embedding(x)
        x = x.unsqueeze(1)  # 添加一个维度作为通道数
        x_conv = []
        for conv in self.conv_layers:
            x_conv.append(nn.functional.relu(conv(x)).squeeze(3))
        x_pool = []
        for conv_out in x_conv:
            x_pool.append(nn.functional.max_pool1d(conv_out, conv_out.shape[2]).squeeze(2))
        x = torch.cat(x_pool, 1)
        x = self.dropout(x)
        x = self.fc(x)
        return x

这里假设您已经训练好了Word2Vec模型，并将其保存在了本地文件中，可以通过gensim.models.Word2Vec.load方法加载。

在TextCNN模型的初始化函数中，首先创建一个embedding层，其大小为(len(model.wv.vocab), embedding_size)，这是因为Word2Vec模型中包含的单词数量即为模型的vocab长度。

然后将Word2Vec模型中的vectors复制到embedding层中，这样就可以获得单词的预训练向量。

最后，将这个embedding层放入TextCNN模型中，并使用它来进行训练和预测。

import gensim
import torch.nn as nn
# 加载已经训练好的Word2Vec模型
model = gensim.models.Word2Vec.load('path_to_your_word2vec_model')
class TextCNN(nn.Module):
    def __init__(self, embedding_size, num_filters, filter_sizes, num_classes):
        super(TextCNN, self).__init__()
        self.embedding = nn.Embedding(len(model.wv.vocab), embedding_size)
        self.embedding.weight.data.copy_(torch.from_numpy(model.wv.vectors))
        self.conv_layers = nn.ModuleList([
            nn.Conv2d(1, num_filters, (filter_size, embedding_size)) for filter_size in filter_sizes
        ])
        self.dropout = nn.Dropout(0.5)
        self.fc = nn.Linear(num_filters * len(filter_sizes), num_classes)
    def forward(self, x):
        x = self.embedding(x)
        x = x.unsqueeze(1)  # 添加一个维度作为通道数
        x_conv = []
        for conv in self.conv_layers:
            x_conv.append(nn.functional.relu(conv(x)).squeeze(3))
        x_pool = []
        for conv_out in x_conv:
            x_pool.append(nn.functional.max_pool1d(conv_out, conv_out.shape[2]).squeeze(2))
        x = torch.cat(x_pool, 1)
        x = self.dropout(x)
        x = self.fc(x)
        return x

援引讯飞星火：
根据您提供的代码和错误信息，问题可能出在输入数据的维度与模型期望的维度不匹配。在这里，我注意到在get_word_embedding函数中，您使用了self.word2vec.get_words_vector(words)来获取词向量。但是，get_words_vector函数可能返回的是一个3D张量（batch_size, seq_length, word_dim），而模型期望的输入是一个2D（batch_size, input_dim）或3D（batch_size, seq_length, input_dim）张量。

为了解决这个问题，您可以尝试将get_words_vector返回的3D张量转换为2D张量。具体操作如下：

1. 修改TextCNN类中的get_word_embedding方法，将self.word2vec.get_words_vector(words)替换为以下代码：

def get_word_embedding(self, words):
    # 获取词向量
    word_vectors = self.word2vec.get_words_vector(words)
    
    # 将3D张量转换为2D张量
    word_vectors = word_vectors.squeeze(0)
    
    return word_vectors

这里，我们使用squeeze(0)函数将3D张量从形状(batch_size, seq_length, word_dim)转换为形状(batch_size, word_dim)的2D张量。

2. 修改__getitem__方法中的embedding变量的定义，将其更改为：

embedding = torch.tensor([self.get_word_embedding(text)], dtype=torch.float32)

这样，您可以将一个单词的词向量作为输入传递给模型。注意，这里我们使用torch.tensor将一个包含一个元素的列表转换为张量，并指定数据类型为torch.float32。

希望这些修改能解决您遇到的问题。如果还有其他问题，请随时告诉我。

引用chatgpt内容作答：
根据你提供的代码和错误信息，你的问题可能与数据处理和模型输入维度不匹配有关。首先，让我们解决当前的错误：

Expected 2D (unbatched) or 3D (batched) input to conv1d, but got input of size: [8, 128, 81, 128]

这个错误表明，在卷积层中，输入的维度不符合预期。卷积层期望的输入维度应该是三维的 [batch_size, num_channels, sequence_length]，但你的输入维度似乎是四维的 [batch_size, embedding_dim, context_size, 128]。

为了解决这个问题，你需要确保在将数据传递给模型之前对其进行适当的处理。你的模型似乎预期接收文本序列的嵌入表示作为输入，因此你需要调整数据处理部分，以便将文本序列转换为正确的输入维度。这可能涉及到对文本进行分词、将词汇索引转换为嵌入向量等步骤。

另外，你还可能需要检查以下几个方面以确保代码正常运行：

1、确保你的模型和数据都位于相同的设备上，可以使用.to(device)方法将模型和数据移动到GPU或CPU。

2、在使用nn.Embedding时，确保词汇表的大小等于num_embeddings。

3、确保数据的形状与模型的输入形状匹配。

4、确保你的模型的前向传播方法(forward)正确处理输入数据的维度。

5、在训练时，确保损失函数和优化器的设置正确。
首先，让我们解决卷积层输入维度的问题。

1、修改 forward 方法，确保输入的维度正确。根据你的模型设计，输入应该是文本序列的嵌入表示。这需要你首先将文本转换为嵌入向量，然后再传递给卷积层。

def forward(self, input):
    if self.num_embeddings > 0:
        # 得到词嵌入 (batch_size, context_size) -> (batch_size, context_size, embedding_dim)
        input = self.embedding(input)
    # (batch_size, context_size, embedding_dim) -> (batch_size, embedding_dim, context_size)
    input = input.permute(0, 2, 1)
    
    y = []
    for layer in self.cnn_layers:
        x = layer(input)
        x = self.pool(x).squeeze(-1)
        y.append(x)
    
    y = torch.cat(y, dim=1)
    out = self.classify(y)
    return out

2、确保数据处理部分正确。在 getitem 方法中，你应该首先将文本序列转换为嵌入向量，然后再传递给模型。同时，确保你的数据处理返回的嵌入向量维度是正确的。

def __getitem__(self, index):
    text, label = copy.deepcopy(self.item_list[index])
    
    embedding = self.get_word_embedding(text)
    
    label = self.class_to_idx[label]
    
    if len(embedding) > 0:
        label = np.asarray(label, dtype=np.int32)
        embedding = torch.from_numpy(embedding).float()  # 使用float类型的嵌入向量
        label = torch.from_numpy(label).long()
    else:
        index = int(random.uniform(0, len(self)))
        return self.__getitem__(index)
    
    return embedding, label

这里假设 self.get_word_embedding(text) 会将文本序列转换为嵌入向量。确保这个函数的实现正确，将文本正确地转换为嵌入向量。

请确保在模型训练时，你的数据处理部分和模型的设备 (device) 保持一致。另外，还需要适当设置损失函数和优化器来训练你的模型。

引用 皆我百晓生 小程序回复内容作答：
根据您提供的代码和错误信息，我注意到您在使用TextCNN模型时遇到了一些问题。首先，关于错误"Expected 2D (unbatched) or 3D (batched) input to conv1d, but got input of size: [8, 128, 81, 128]"，这是因为您的输入维度不正确。您的输入应该是一个3D张量，而不是4D张量。您可以尝试在输入之前使用torch.squeeze()函数来删除多余的维度，例如：

input = input.squeeze(0)  # 删除多余的维度

此外，关于错误"expected tensor for argument #1 'indices' to have one of the following scalar types: long, int; but got torch.cuda.floattensor instead (while checking arguments for embedding)"，这是因为您的输入类型不正确。nn.Embedding层的输入应该是整数类型（torch.LongTensor或torch.IntTensor），而不是浮点类型。您可以尝试将输入转换为整数类型，例如：

input = input.long()  # 将输入转换为整数类型

最后，关于错误"RuntimeError: expected type torch.FloatTensor but got torch.cuda.FloatTensor"，这是因为您的模型和输入数据在不同的设备上。您可以尝试将模型和输入数据都移动到相同的设备上，例如：

model = model.to(device)  # 将模型移动到相同的设备上
input = input.to(device)  # 将输入数据移动到相同的设备上

请注意，上述代码中的device是指您希望在其上运行模型和输入数据的设备，例如torch.device("cuda")表示使用GPU。

希望这些解决方案能够帮助您解决问题并使代码能够正常运行。如果您还有其他问题，请随时提问。

根据您提供的代码和错误信息，我看到您遇到了一些问题。以下是我对这些问题的解释和可能的解决方法：

1. 第一个错误 "Expected 2D (unbatched) or 3D (batched) input to conv1d, but got input of size: [8, 128, 81, 128]" 是因为您的输入数据维度不正确。conv1d层期望的输入维度应该是 [batch_size, embedding_dim, sequence_length]，但您的输入维度似乎是 [batch_size, embedding_dim, context_size, embedding_dim]。这可能是因为在数据集的__getitem__函数中，您的embedding的维度是错误的。您可以尝试调整embedding的维度，确保它是 [embedding_dim, sequence_length]。

2. 第二个错误 "number of dimensions in the tensor input does not match the length of the desired ordering of dimensions" 可能是因为在embedding层中，您的索引维度不正确。embedding层期望的索引维度应该是 [batch_size, sequence_length]，但是您的索引维度似乎是 [batch_size, embedding_dim, context_size, embedding_dim]。您可以尝试调整索引的维度，确保它是 [batch_size, sequence_length]。

3. 第三个错误 "expected type torch.FloatTensor but got torch.cuda.FloatTensor" 表示您的数据类型不匹配。您可以尝试在使用数据之前将数据转换为正确的数据类型。例如，您可以使用.float() 将数据转换为浮点数类型。

参考gpt：
结合自己分析给你如下建议：
Pytorch+Text-CNN+Word2vec+电影评论情感分析实战 - 知乎：这个网页介绍了如何使用Pytorch和Text-CNN模型来进行电影评论情感分析，以及如何加载预训练的Word2vec词向量。它给出了完整的代码和注释，以及一些可视化的结果。
PyTorch实现Word2Vec - 知乎：这个网页介绍了如何使用Pytorch来实现Word2vec模型，以及如何使用Skip-gram和负采样的方法来训练词向量。它也给出了完整的代码和注释，以及一些测试的结果。
详细的 Word2Vec 模型搭建笔记（pytorch版本） - CSDN博客：这个网页介绍了如何使用Pytorch来搭建Word2vec模型，以及如何使用CBOW和负采样的方法来训练词向量。它也给出了完整的代码和注释，以及一些测试的结果。
根据这些信息，我为你分析了你的代码中可能出现的问题，以及一些可能的解决方案。请注意，这些分析和建议可能不是完整或正确的，你需要根据你的实际情况进行调整和测试。

在你的TextCNN类中，你定义了一个embeddings_pretrained参数，用于接收预训练的词向量权重。但是，在你的forward函数中，你没有使用这个参数，而是直接调用了self.embedding(input)，这样会导致你使用随机初始化的词向量而不是预训练的词向量。为了解决这个问题，你需要在forward函数中使用self.embedding.weight.data.copy_(embeddings_pretrained)来将预训练的词向量权重复制到self.embedding.weight中。
在你的get_embedding_weight函数中，你使用了self.model.wv.get_vector方法来获取词向量。但是，这个方法返回的是一个numpy数组，而不是一个torch张量。为了解决这个问题，你需要在返回weight之前使用torch.from_numpy(weight)来将numpy数组转换为torch张量。
在你的__getitem__函数中，你返回了text和label两个值，但是没有返回embedding。这样会导致在训练时无法获取预训练的词向量。为了解决这个问题，你需要在返回值中加上embedding。

你这里的forward就有问题了，人家注释明确告诉你这里的是三维的数据，但是你下面的input.permute里面的参数是四维的，假如下面这里通道转换没有报错，那就是你的输入本身就有问题了，这就会导致后续的一系列的报错，因为下面的self.cnn_layers里面的卷积核是nn.Conv1d(），这个要求你要么是2D的数据，要么是3D的数据，而你现在的input是4D的，所以报错。这个跟你在推理的时候输入的数据有关，而当前你没有给出这部分数据，所以暂时不清楚你的数据处理部分是哪里的错误导致的input变为4D的数据。

Pytorch+Text-CNN+Word2vec+电影评论情感分析实战_基于pytorch的影评情感分析_音程的博客-CSDN博客 文章目录0.前言1.电影评论数据集0.前言很多人喜欢使用IMDB数据集来做电影评论情感分析示范，但这却是我极其不建议的，因为其一般被很多官方的库都收录，所以有很多接口用于处理这个数据集，这让我们无法体验到真实场景，一旦碰到真正的数据集，我们将手都动不了。于是乎，有了这一篇。1.电影评论数据集..._基于pytorch的影评情感分析 https://blog.csdn.net/qq_43391414/article/details/118557836

TextCNN pytorch实现 - 知乎 首发于公众号："Finisky Garden"。原文载于： TextCNN pytorch实现 TextCNN 是一种经典的DNN文本分类方法，自己实现一遍可以更好理解其原理，深入模型细节。本文并非关于TextCNN的完整介绍，假设读者比较… https://zhuanlan.zhihu.com/p/360476566

模型期望的输入是一个形状为 [batch_size, context_size] 的整数张量，而您的输入似乎是一个四维张量 [batch_size, embedding_dim, context_size, embedding_dim]，这导致了错误。
检查您的 getitem 函数，确保它返回形状为 [batch_size, context_size] 的整数张量。您可以使用 torch.LongTensor 来确保数据类型正确。请确保在 get_word_embedding 函数中，将文本转换为适当的整数表示。

def get_word_embedding(self, words):
    embedding = self.word2vec.get_words_vector(words)
    return embedding

【以下回答由 GPT 生成】

首先，你需要确保已经安装了gensim包来进行Word2Vec的处理。你可以使用以下命令来安装：

pip install gensim

然后，你需要下载预训练的Word2Vec模型。你可以在这里找到一些预训练的Word2Vec模型。选择一个适合你任务的模型，下载之后，你可以使用以下代码加载并导入这些向量。

import gensim

def load_word2vec(file_path):
    model = gensim.models.KeyedVectors.load_word2vec_format(file_path, binary=False)
    return model

# 以下为示例，你需要根据你下载的模型进行具体的调整
word2vec_path = "path/to/word2vec/model.bin"
word2vec_model = load_word2vec(word2vec_path)

接下来，在你的TextCNN模型中，你需要修改相关代码，将预训练的Word2Vec向量导入到你的Embedding层中。

if self.num_embeddings > 0:
    self.embedding = nn.Embedding(num_embeddings, embedding_dim)
    if embeddings_pretrained is not None:
        self.embedding.weight.data.copy_(torch.from_numpy(embeddings_pretrained.vectors))
        self.embedding.weight.requires_grad = True

注意，embeddings_pretrained这个参数现在应该是你加载的Word2Vec模型，而不是一个嵌入矩阵。这里使用torch.from_numpy将Word2Vec模型中的向量数据转换成Tensor，并将其赋值给Embedding层的权重。

最后，你需要修改forward方法中的代码，以适应Word2Vec向量的输入。

input = input.permute(0, 2, 1)  # (b, seq_len, embedding_dim) -> (b, embedding_dim, seq_len)
out = [cnn_layer(input) for cnn_layer in self.cnn_layers]  # [(6, 256, 73), (6, 256, 72), (6, 256, 71), (6, 256, 70)]
out = [self.pool(o.permute(0, 2, 1)).squeeze(-1) for o in out]  # (6, 256)

这里需要将输入的维度转换成(batch_size, embedding_dim, seq_len)的形式，以适应TextCNN模型的输入要求。

希望这些修改可以帮助你成功导入Word2Vec向量。如果你还有其他问题，请随时向我提问。

感觉到找了问题所在，看了很多例子，都是把vocab字典用word2vec向量化以后传递给embedding.from_pretrained方法，训练集数据不进行向量化。而我多此一举，不仅把vocab字典向量化传递，还把训练集数据每个词向量化输入给模型，导致出现问题。。。

Word2Vec 的pytorch 实现（简单）
可以参考下

Word2Vec 的pytorch 实现（简单）_pytorch word2vec_我也要做小太阳的博客-CSDN博客 import gcimport torch import numpy as np from torch import nn,optimimport matplotlib.pyplot as pltfrom torch.utils.data import DataLoader,TensorDatasetdevice = torch.device("cuda" if torch.cuda.is_available() else "cpu")devicedevice(type='cuda')_pytorch word2vec https://blog.csdn.net/qq_39215918/article/details/123255248

基于pytorch实现Word2Vec（skip-gram+Negative Sampling）_pytorch word2vec_乌云tail的博客-CSDN博客 目录word2vec简介语料处理数据预处理训练模型近似训练法参数设定预测及可视化word2vec简介2013 年，Google 团队发表了 word2vec 工具。word2vec 工具主要包含两个模型：跳字模型（skip-gram）和连续词模型（continuous bag of words，简称 CBOW），以及两种高效训练的方法：负采样（negative sampling）和层序 softmax（hierarchical softmax）。类似于f(x)->_pytorch word2vec https://blog.csdn.net/qq_24668285/article/details/121754529

Expected 2D (unbatched) or 3D (batched) input to conv1d, but got input of size: [8, 128, 81, 128]：

这个错误表明您试图将错误维度的输入传递给conv1d层。conv1d层的输入应该是2D（未批处理）或3D（批处理）的张量。请检查输入的维度是否正确，可能需要调整张量的形状

这是由于pytorch新版本与老版本之间不兼容导致的

1，重构代码；
2，配置老版本的环境 pytorch=1.10。

：Expected 2D (unbatched) or 3D (batched) input to conv1d, but got input of size: [8, 128, 81, 128]
这个错误提示的是，你的数据输入尺寸不符合Conv1D层的期望输入。

expected tensor for argument #1 'indices' to have one of the following scalar types: long, int; but got torch.cuda.floattensor instead (while checking arguments for embedding)

这个错误提示的是，你在使用embedding layer的时候，输入的类型是float，但是期望的类型是long或int。

参考gpt
您在导入Word2Vec向量时遇到了问题。根据您提供的代码，您可以尝试以下几点来解决问题：

1. 确保Word2Vec向量的维度与您的模型中的embedding_dim一致。在您的模型中，embedding_dim默认为128，因此您需要确保Word2Vec向量的维度也是128。

2. 确保您正确地加载了Word2Vec向量，并将其传递给模型的embeddings_pretrained参数。您可以使用torch.nn.Embedding的from_pretrained方法加载预训练的Word2Vec向量。

3. 在加载预训练的Word2Vec向量后，您可以通过将embedding.weight.requires_grad设置为True来确保该层的权重可以进行梯度更新。

4. 确保输入数据的形状与您的模型匹配。根据您的代码，您的输入应该是一个形状为(batch_size, context_size)的张量。

输入参数与期望参数不一致导致的

输入维度不匹配，要修改一下

首先你的代码是在哪个环境下运行的，可否换个环境运行，比如降低版本