小编den*_*ger的帖子

在 HuggingFace 中，每次调用pipeline()对象时，我都会收到警告：

`"Setting `pad_token_id` to `eos_token_id`:{eos_token_id} for open-end generation."

如何在不抑制所有日志记录警告的情况下抑制此警告？我想要其他警告，但我不想要这个。

我一直在比较Python和R的几个PCA实现的性能,并注意到一个有趣的行为:
虽然在Python中计算稀疏矩阵的PCA似乎是不可能的(唯一的方法是scikit-learn的 TruncatedSVD,但它确实如此)不支持平均居中要求等同于PCA的协方差解决方案.他们的论证是,它会破坏矩阵的稀疏性.其他实现如Facebook的PCA算法或scikit中的PCA/randomPCA方法学习不支持稀疏矩阵出于类似的原因.

虽然所有这些对我来说都是有意义的,但是几个R包,如irlba,rsvd等,能够处理稀疏矩阵(例如生成rsparsematrix),甚至允许特定的center=True参数.

我的问题是,R如何在内部处理它,因为它似乎比类似的Python实现更有效.R是否仍然通过绝对缩放来保持稀疏性(这理论上会伪造结果,但至少保持稀疏性)？或者有没有任何方法可以明确地为零值存储均值,并且只存储一次(而不是分别存储每个值)？

为了得到推迟:R内部如何存储具有均值中心的矩阵而不会爆炸RAM使用.希望足够简洁....

这是一个使用模型进行序列分类的示例，以确定两个序列是否是彼此的释义。这两个例子给出了两种不同的结果。你能帮我解释为什么tokenizer.encode并tokenizer.encode_plus给出不同的结果吗？

示例 1（带有.encode_plus()）：

paraphrase = tokenizer.encode_plus(sequence_0, sequence_2, return_tensors="pt")
not_paraphrase = tokenizer.encode_plus(sequence_0, sequence_1, return_tensors="pt")

paraphrase_classification_logits = model(**paraphrase)[0]
not_paraphrase_classification_logits = model(**not_paraphrase)[0]

示例 2（带有.encode()）：

paraphrase = tokenizer.encode(sequence_0, sequence_2, return_tensors="pt")
not_paraphrase = tokenizer.encode(sequence_0, sequence_1, return_tensors="pt")

paraphrase_classification_logits = model(paraphrase)[0]
not_paraphrase_classification_logits = model(not_paraphrase)[0]

我正在尝试安装sentence-transformers库。但是当我导入它时，会弹出这个错误：

---------------------------------------------------------------------------
ImportError                               Traceback (most recent call last)
<ipython-input-1-c9f0b8c65221> in <module>
----> 1 import h5py

~\Anaconda3\envs\custom_env\lib\site-packages\h5py\__init__.py in <module>
     32         raise
     33 
---> 34 from . import version
     35 
     36 if version.hdf5_version_tuple != version.hdf5_built_version_tuple:

~\Anaconda3\envs\custom_env\lib\site-packages\h5py\version.py in <module>
     15 
     16 from collections import namedtuple
---> 17 from . import h5 as _h5
     18 import sys
     19 import numpy

h5py\h5.pyx in init h5py.h5()

ImportError: DLL load failed while importing defs: The specified procedure could not be found.

我已经安装了h5py库。我缺少什么？

我相当确定这个问题之前已经在 Stackoverflow 上被问过并得到了回答，但我找不到正确的搜索词。

我的情况如下：我在 Matplotlib 中生成单个图形，然后在 LaTeX 图形中排列多个图（为了示例，假设2x2LaTeX 中的子图形网格，带有索引

a)   b)
c)   d)

为了“视觉美观”，我只想描述 a) 和 c) 中的 y 轴刻度，仅描述 c) 和 d) 中的 x 轴刻度。虽然禁用各个子图上的轴刻度非常容易，但不幸的是，它会导致保存的图具有不同的图像大小（如果不存在轴标签，绘图区域会占用更多图像），从而导致布局混乱在我的 LaTeX 图中。

有没有什么方法可以根据图 c) 的大小（具有两个轴刻度）来强制这些图的具体大小？

我目前的尝试是使用plt.savefig([...], bbox_inches='tight', pad_inches=x)，但没有成功。我也愿意使用plt.subplot()，但我更愿意将它们保留为单独的图，以便以后的演示。

作为参考并为您提供一些可使用的 MCVE，想象一下子图 a) 的图（无 x 轴标签和刻度）如下所示：

import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y = [1, 4, 9, 16]
plt.plot(x, y)
plt.xticks([1,2,3,4], [])  # Disable x-axis ticks
plt.xlabel("")  # Disable x-axis label

我在询问NLLLoss损失函数的C 类。

该文件指出：

负对数似然损失。用 C 类训练分类问题很有用。

基本上在那之后的一切都取决于你是否知道 C 类是什么，我以为我知道 C 类是什么，但文档对我来说没有多大意义。特别是当它描述 的预期输入时(N, C) where C = number of classes。这就是我感到困惑的地方，因为我认为 C 类仅指输出。我的理解是，C 类是一个热门的分类向量。我经常在教程中发现NLLLoss经常与 a 配对LogSoftmax来解决分类问题。

我期待NLLLoss在以下示例中使用：

# Some random training data
input = torch.randn(5, requires_grad=True)
print(input)  # tensor([-1.3533, -1.3074, -1.7906,  0.3113,  0.7982], requires_grad=True)
# Build my NN (here it's just a LogSoftmax)
m = nn.LogSoftmax(dim=0)
# Train my NN with the data
output = m(input)
print(output)  # tensor([-2.8079, -2.7619, …

我试图在PyTorch中对简单的0,1标记的数据集执行Logistic回归。标准或损失定义为：criterion = nn.CrossEntropyLoss()。该模型是：model = LogisticRegression(1,2)

我有一个成对的数据点：dat = (-3.5, 0)，第一个元素是数据点，第二个元素是相应的标签。
然后，将输入的第一个元素转换为张量：tensor_input = torch.Tensor([dat[0]])。
然后我将该模型应用到tensor_input： outputs = model(tensor_input)。
然后，将标签转换为张量：tensor_label = torch.Tensor([dat[1]])。
现在，当我尝试执行此操作时，事情就中断了：loss = criterion(outputs, tensor_label)。它给出和错误：RuntimeError: Dimension out of range (expected to be in range of [-1, 0], but got 1)

import torch
import torch.nn as nn

class LogisticRegression(nn.Module):
    def __init__(self, input_size, num_classes):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(input_size, num_classes) 

    def forward(self, x):
        out = self.linear(x)
        return out

model = LogisticRegression(1,2) …

我做了一个实验，但没有得到我期望的结果。

对于第一部分，我使用

trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, 
                                          shuffle=False, num_workers=0)

我保存trainloader.dataset.targets到变量a，并在训练模型之前trainloader.dataset.data保存到变量。b然后，我使用 训练模型trainloader。
训练完成后，我保存trainloader.dataset.targets到变量c和trainloader.dataset.data变量d。最后，我检查a == c和b == d，它们都给出True，这是预期的，因为 的 shuffle 参数DataLoader是False。

对于第二部分，我正在使用

trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, 
                                          shuffle=True, num_workers=0)

我保存trainloader.dataset.targets到变量e，并在训练模型之前trainloader.dataset.data保存到变量。f然后，我使用 训练模型trainloader。训练完成后，我保存trainloader.dataset.targets到变量g和trainloader.dataset.data变量h。我期望e == g和从那时f == h …

from transformers import AutoModel, AutoTokenizer

tokenizer1 = AutoTokenizer.from_pretrained("roberta-base")
tokenizer2 = AutoTokenizer.from_pretrained("bert-base-cased")

sequence = "A Titan RTX has 24GB of VRAM"
print(tokenizer1.tokenize(sequence))
print(tokenizer2.tokenize(sequence))

输出：

['A', '?Titan', '?RTX', '?has', '?24', 'GB', '?of', '?VR', 'AM']

['A', 'Titan', 'R', '##T', '##X', 'has', '24', '##GB', 'of', 'V', '##内存']

Bert 模型使用 WordPiece 分词器。WordPiece 词汇表中没有出现的任何单词都会被贪婪地分解为子单词。例如，“RTX”被分解为“R”、“##T”和“##X”，其中## 表示它是一个子标记。

Roberta 使用 BPE 标记器，但我无法理解

a) BPE 分词器是如何工作的？

b) G 在每个代币中代表什么？

我正在学习一些关于使用 lstm 网络进行情感分析的教程。下面的代码表示它堆叠了 lstm 输出。我不知道它是如何工作的。

lstm_out = lstm_out.contiguous().view(-1, self.hidden_dim)