小编Szy*_*zke的帖子

问题

我正在 PyTorch 中训练一个用于二元分类的深度学习模型，并且我有一个包含不平衡类比例的数据集。10%我的少数派课程由给定的观察结果组成。为了避免模型学习只预测多数类，我想WeightedRandomSampler在torch.utils.data我的DataLoader.

假设我有1000观察结果（900在类中0，100在类中1），并且我的数据加载器的批量大小100为。

如果没有加权随机抽样，我预计每个训练周期将包含 10 个批次。

问题

• 使用此采样器时，每个时期只会对 10 个批次进行采样 - 因此，由于少数类别现在在训练批次中所占比例过高，模型是否会在每个时期“错过”大部分类别的大部分？
• 使用采样器是否会导致每个 epoch 采样超过 10 个批次（这意味着相同的少数类观察结果可能会出现多次，并且训练速度也会减慢）？

我正在尝试使用270标签解决一个多标签问题，并且我已将目标标签转换为一种热编码形式。我正在使用BCEWithLogitsLoss(). 由于训练数据不平衡，我正在使用pos_weight参数，但我有点困惑。

pos_weight（张量，可选）——正例的权重。必须是长度等于类数的向量。

我是否需要将每个标签的正值的总数作为张量给出，或者它们的权重意味着其他东西？

我试图通过创建三个类在 TensorFlow 2.0 中构建自动编码器：编码器、解码器和自动编码器。因为我不想手动设置输入形状，所以我试图从编码器的 input_shape 推断解码器的输出形状。

import os
import shutil

import numpy as np
import tensorflow as tf
from tensorflow.keras import Model
from tensorflow.keras.layers import Dense, Layer


def mse(model, original):
    return tf.reduce_mean(tf.square(tf.subtract(model(original), original)))


def train_autoencoder(loss, model, opt, original):
    with tf.GradientTape() as tape:
        gradients = tape.gradient(
            loss(model, original), model.trainable_variables)
        gradient_variables = zip(gradients, model.trainable_variables)
        opt.apply_gradients(gradient_variables)


def log_results(model, X, max_outputs, epoch, prefix):
    loss_values = mse(model, X)

    sample_img = X[sample(range(X.shape[0]), max_outputs), :]
    original = tf.reshape(sample_img, (max_outputs, 28, 28, 1))
    encoded = tf.reshape(
        model.encode(sample_img), (sample_img.shape[0], …

我有一个如下的docker文件。launch.sh是此docker映像中的入口点。

FROM ubuntu:16.04
USER root

RUN apt-get update && apt-get install -y \
        curl \
        vim \
        net-tools \
        git \
        iputils-ping \
        wget

RUN apt-get install -y python
RUN apt-get update && apt-get install -y gcc g++ make libgflags-dev libsnappy-dev zlib1g-dev libbz2-dev liblz4-dev libzstd-dev

RUN curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.11/install.sh | bash

ENV NVM_DIR /root/.nvm
RUN . $NVM_DIR/nvm.sh && \
  nvm install 7.9.0 && npm install -g npm@5.6.0

ADD ./Docker/launch.sh /workspace/

CMD ["/bin/sh", "/workspace/launch.sh"]

的内容launch.sh是：

#!/bin/bash

cd …

这可能更像是一个 Tensorflow 梯度问题。我一直在尝试将 Intersection over Union (IoU) 作为损失来实现，并且遇到了一些问题。就这一点而言，这是我计算 IoU 的代码片段：

def get_iou(masks, predictions):
    ious = []
    for i in range(batch_size):
        mask = masks[i]
        pred = predictions[i]
        masks_sum = tf.reduce_sum(mask)
        predictions_sum = tf.reduce_mean(pred)
        intersection = tf.reduce_sum(tf.multiply(mask, pred))
        union = masks_sum + predictions_sum - intersection
        iou = intersection / union
        ious.append(iou)
    return ious

iou = get_iou(masks, predictions)
mean_iou_loss = -tf.log(tf.reduce_sum(iou))
train_op = tf.train.AdamOptimizer(0.001).minimize(mean_iou_loss)

它按预期工作。但是，我遇到的问题是损失并没有减少。该模型确实进行了训练，但结果并不理想，所以我想知道我是否正确实施了它。我必须自己计算梯度吗？我可以计算出梯度由衍生该借条丢失本文使用tf.gradients()，虽然我不知道如何将随tf.train.AdamOptimizer()。阅读文档，我觉得compute_gradients和apply_gradients是我需要使用的命令，但我找不到有关如何使用它们的任何示例。我的理解是，Tensorflow 图应该能够通过链式法则得出梯度本身。那么在这个问题中甚至需要自定义渐变吗？如果自定义梯度不是必需的，那么我可能只是有一个不适定的问题，需要调整一些超参数。

注意：我已经尝试过 Tensorflow 的 IoU 实现tf.metrics.mean_iou() …

是否有一种 pythonic 方法可以将 sklearn 的 StandardScaler 实例链接在一起以独立地按组缩放数据？即，如果我想找到独立缩放 iris 数据集的特征；我可以使用以下代码：

from sklearn.datasets import load_iris
data = load_iris()
df = pd.DataFrame(data['data'], columns=data['feature_names'])
df['class'] = data['target']

means = df.groupby('class').mean()
stds = df.groupby('class').std()

df_rescaled = (
    (df.drop(['class'], 1) - means.reindex(df['class']).values) / 
     stds.reindex(df['class']).values)

在这里，我分别减去均值并除以每个组的标准差。但是它有点难以实现这些手段和标准差，并且基本上复制了StandardScaler当我有一个我想要控制的分类变量时的行为。

有没有更pythonic/sklearn友好的方式来实现这种类型的缩放？

我正在学习 pytorch，要对这里以这种方式创建的数据进行基本的线性回归：

from sklearn.datasets import make_regression

x, y = make_regression(n_samples=100, n_features=1, noise=15, random_state=42)
y = y.reshape(-1, 1)
print(x.shape, y.shape)

plt.scatter(x, y)

我知道使用 tensorflow 这段代码可以解决：

model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Dense(units=1, activation='linear', input_shape=(x.shape[1], )))

model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.05), loss='mse')

hist = model.fit(x, y, epochs=15, verbose=0)

但我需要知道 pytorch 等价物会是什么样子，我试图做的是：

# Model Class
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.linear = nn.Linear(1,1)
        
    def forward(self, x):
        x = self.linear(x)
        return x
    
    def predict(self, x):
        return self.forward(x)
    
model = Net()

loss_fn = F.mse_loss
opt = torch.optim.SGD(modelo.parameters(), lr=0.05)

# Funcao para …

我在 Pytorch C++ 前端使用 TorchScript 模型。

Python 中的模型返回一个outputdict 作为 Dict[str, List[torch.Tensor]].

当我在 C++ 中使用它时，它返回一个c10::Dict<c10::IValue, c10::IValue>. 这段 Python 代码的等价物是什么：

value_a = output['key_a']
value_b = output['key_b']

在 C++ 中从中获取值c10::Dict？

我已经尝试过了，但它不起作用。

torch::IValue key_a("key_a");
torch::IValue key_b("key_b");
c10::IValue value_a = output[key_a];
c10::IValue value_b = output[key_b];
std::cout << value_a << std::endl;
std::cout << value_b << std::endl;

和错误：

error: type 'c10::Dict<c10::IValue, c10::IValue>' does not provide a subscript operator

我正在关注本教程：https : //huggingface.co/transformers/torchscript.html 来创建我的自定义 BERT 模型的跟踪，但是在运行完全相同的模型时，dummy_input我收到一个错误：

TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. 
We cant record the data flow of Python values, so this value will be treated as a constant in the future. 

在我的模型和标记器中加载后，创建跟踪的代码如下：

text = "[CLS] Who was Jim Henson ? [SEP] Jim Henson was a puppeteer [SEP]"
tokenized_text = tokenizer.tokenize(text)

# Masking one of the input tokens
masked_index = 8
tokenized_text[masked_index] = '[MASK]'
indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text) …

在我的单元测试中，我在测试中有 2 个提示。我正在尝试使用 2 @patch("builtins.input")，但它似乎只采用返回值中的 1 个。

@patch("builtins.input")
@patch("builtins.input")
def test_setProfileName_modify_init_prompt_empty(self, paramName1, paramName2):
    paramName1.return_value = self.profileName_prod
    paramName2.return_value = self.profileName_dev


    a = c.ALMConfig(self.configType)
    self.assertTrue(a.setProfileName())
    self.assertEqual(a.getProfileName(), self.profileName_dev)
    self.assertEqual(a.profileName, self.profileName_dev)


    self.assertTrue(a.setProfileName())
    self.assertEqual(a.getProfileName(), self.profileName_prod)
    self.assertEqual(a.profileName, self.profileName_prod)

该调用a.setProfileName()将input()在我的函数中使用call提示输入 1 个。在这个测试中，它会调用a.setProfileName()两次。

• 我第一次打电话时a.setProfileName()，我会输入 的值self.profileName_prod。
• 我第二次调用它时，我会输入self.profileName_dev.

但是在第二个a.setProfileName()案例之后测试失败（在第二assertEqual次a.setProfileName()调用之后的倒数第二个）。

    self.assertEqual(a.getProfileName(), self.profileName_prod)

失败的原因是因为a.getProfileName正在返回值 forself.profileName_dev而不是self.profileName_prod。

我已经在 python cli 中测试了我的代码以确保行为是正确的。

任何反馈表示赞赏。

谢谢你们！

我正在使用 PyTorch 的 C++ API 开发机器学习系统 ( libtorch)。

我最近一直在做的一件事是研究libtorch. 通过我的研究，我了解到 Torch 在 CPU 上使用两种并行化方式：

• inter-op并行化
• intra-op并行化

我的主要问题是：

• 这两者之间的区别
• 我如何利用inter-op并行性

我知道我可以使用该函数指定用于并行性的线程数intra-op（根据我的理解，这是使用openmp后端执行的）torch::set_num_threads()，当我监视模型的性能时，我可以清楚地看到它使用了我指定的线程数使用这个函数，我可以通过改变intra-op线程数看到明显的性能差异。

还有另一个函数torch::set_num_interop_threads()，但似乎无论我指定多少个互操作线程，我都看不到性能有任何差异。

现在我已经阅读了这篇 PyTorch 文档文章，但我仍然不清楚如何利用互操作线程池。

文档说：

PyTorch 使用单个线程池来实现操作间并行性，该线程池由应用程序进程中分叉的所有推理任务共享。

我对这部分有两个问题：

• 我是否需要自己创建新线程来利用这些interop线程，或者 torch 是否在内部以某种方式为我完成它？
• 如果我需要自己创建新线程，我该如何在C++中执行此操作，以便从线程池中创建一个新线程interop？

在python示例中，他们使用模块fork中的函数torch.jit，但我在 C++ API 中找不到类似的东西。