小编roc*_*ves的帖子

所以，我知道标题中两种方法的区别，但不知道实际含义。

据我了解：如果您使用的 NUM_WORKERS 数量多于实际可用的核心数量，您将面临性能大幅下降，因为您的操作系统不断地来回切换，试图保持并行。不知道这有多真实，但我在某处从比我聪明的人那里读到了它。

在它的文档中os.cpu_count()说：

返回系统中 CPU 的数量。如果未确定则返回 None。该数字不等于当前进程可以使用的 CPU 数量。可用CPU的数量可以通过len(os.sched_getaffinity(0))获得

因此，我试图弄清楚“系统”指的是一个进程可使用的 CPU 数量是否多于“系统”中的 CPU 数量。

我只是想安全有效地实现multiprocessing.pool功能。所以这是我的问题总结：

以下内容有何实际意义：

NUM_WORKERS = os.cpu_count() - 1
# vs.
NUM_WORKERS = len(os.sched_getaffinity(0)) - 1

这-1是因为我发现，如果我尝试在处理数据时工作，我的系统的延迟会少很多。

域名注册地址：

自编码器欠拟合时间序列重建，仅预测平均值。

问题设置：

这是我对序列到序列自动编码器的尝试的总结。该图片取自本文：https : //arxiv.org/pdf/1607.00148.pdf

编码器：标准 LSTM 层。输入序列在最终隐藏状态中编码。

解码器： LSTM Cell（我想！）。从最后一个元素开始，一次一个元素地重建序列x[N]。

对于长度为 的序列，解码器算法如下N：

1. 获取解码器初始隐藏状态hs[N]：只需使用编码器最终隐藏状态。
2. 重建序列中的最后一个元素：x[N]= w.dot(hs[N]) + b。
3. 其他元素的相同模式： x[i]= w.dot(hs[i]) + b
4. 使用x[i]和hs[i]作为输入LSTMCell来获取x[i-1]和hs[i-1]

最小工作示例：

这是我的实现，从编码器开始：

class SeqEncoderLSTM(nn.Module):
    def __init__(self, n_features, latent_size):
        super(SeqEncoderLSTM, self).__init__()
        
        self.lstm = nn.LSTM(
            n_features, 
            latent_size, 
            batch_first=True)
        
    def forward(self, x):
        _, hs = self.lstm(x)
        return hs

解码器类：

class SeqDecoderLSTM(nn.Module):
    def __init__(self, emb_size, n_features):
        super(SeqDecoderLSTM, self).__init__()
        
        self.cell = …

所以，我已经阅读了大约一半的原始 ResNet 论文，并且正在尝试找出如何为表格数据制作我的版本。

我读过一些关于 PyTorch 如何工作的博客文章，并且我看到大量使用nn.Identity(). 现在，论文还经常使用恒等映射这个术语。然而，它只是指以元素方式将一堆层的输入添加到同一堆栈的输出。如果输入和输出维度不同，那么本文讨论了用零填充输入或使用矩阵W_s将输入投影到不同的维度。

这是我在博客文章中找到的残差块的抽象：

class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, activation='relu'):
        super().__init__()
        self.in_channels, self.out_channels, self.activation = in_channels, out_channels, activation
        self.blocks = nn.Identity()
        self.shortcut = nn.Identity()   
    
    def forward(self, x):
        residual = x
        if self.should_apply_shortcut: residual = self.shortcut(x)
        x = self.blocks(x)
        x += residual
        return x
    
    @property
    def should_apply_shortcut(self):
        return self.in_channels != self.out_channels
    
block1 = ResidualBlock(4, 4)

以及我自己对虚拟张量的应用：

x = tensor([1, 1, 2, 2])
block1 = ResidualBlock(4, 4)
block2 = ResidualBlock(4, 6) …

我正在为 NLP 相关任务创建自定义数据集。

在 PyTorch自定义 datast 教程中，我们看到该__getitem__()方法在返回样本之前为转换留出了空间：

def __getitem__(self, idx):
        if torch.is_tensor(idx):
            idx = idx.tolist()

        img_name = os.path.join(self.root_dir,
                                self.landmarks_frame.iloc[idx, 0])
        image = io.imread(img_name)
       
        ### SOME DATA MANIPULATION HERE ###

        sample = {'image': image, 'landmarks': landmarks}
        if self.transform:
            sample = self.transform(sample)

        return sample

然而，这里的代码：

        if torch.is_tensor(idx):
            idx = idx.tolist()

意味着应该能够一次检索多个项目，这让我想知道：

1. 这种转换如何作用于多个项目？以教程中的自定义转换为例。它们看起来无法在一次调用中应用于一批样本。

2. 相关的是，如果转换只能应用于单个样本，DataLoader 如何并行检索一批多个样本并应用所述转换？

我正在阅读Prometheus 的“入门”教程。我对 YAML 配置文件非常着迷：

scrape_configs:
  - job_name:       'node'

    # Override the global default and scrape targets from this job every 5 seconds.
    scrape_interval: 5s

    static_configs:
      - targets: ['localhost:8080', 'localhost:8081']
        labels:
          group: 'production'

      - targets: ['localhost:8082']
        labels:
          group: 'canary'

因此，显然连字符应该指示两件事之一：新列表中的第一项，或键值对。

• 所以看起来job_name: 'node'是一个键值对。那么为什么它后面的所有内容都是缩进的呢？

• targets看起来也像一个键值对。但也是如此labels，而且没有连字符。此外，group是从 缩进一个空格labels。

我很难说清楚这里发生了什么。我需要知道是否要自定义此文件（我已经尝试过这样做，并在启动 Prometheus 时收到错误）。

这个文件的逻辑结构是怎样的？

在设置绘图美观的教程中，有几种不同的方法：

1. set_style
2. set_context
3. axes_style

其中每一个都接受一个rc关键字参数字典。在上述三个功能的每个单独的 API 页面中，都显示：

rcdict，可选：用于 覆盖预设seaborn样式字典中的值的参数映射。这仅更新被视为样式定义一部分的参数。

回到教程页面，下面axes_style详细说明了如何查看rc该函数的字典可使用哪些参数：

如果您想查看包含哪些参数，可以只调用不带参数的函数，这将返回当前设置：

但是，在其他函数上使用它总是返回None。因此，例如，我使用以下 matplotlib 和 seaborn 的组合来设置参数：

mpl.rcParams['figure.figsize'] = [16,10]
viz_dict = {
    'axes.titlesize':18,
    'axes.labelsize':16,
} 
sns.set_context("notebook", rc=viz_dict)
sns.set_style("whitegrid")

我还注意到，将我的字典放入set_style方法中不会执行任何操作，而至少对于这些参数，它仅适用于set_context. 这意味着它们各自具有可以编辑的互斥特征。然而，文档中的任何地方都没有概述这一点。

我想知道这三个函数中的哪一个将接受 的参数figsize。我也很想知道他们还接受哪些可以帮助我微调事情的内容。我的目标是尽可能频繁地专门使用seaborn 界面。我不需要对 matplotlib 提供的东西进行微调控制，而且常常觉得它很尴尬。

我有一个脚本，在具有 8 个 CPU 的 GCP VM 实例上运行大约需要 8 小时左右。我对云计算有点陌生，对设置 ssh、运行我的 python 文件然后走开感到有点紧张。

如果我 ssh 进入 GCP VM 实例，启动 python 脚本并离开，即使我的计算机进入睡眠状态，它也会继续运行吗？我的直觉是否定的，因为这似乎是云计算的全部意义，但我想确定一下。谢谢。

我有一个 Python 中的 PyCharm“项目”，也就是说我有一个文件夹，它是各种实验性 Python 文件、便利方法/类和 Jupyter 笔记本的集合，这些文件来自跟随在线课程。

我实际上只是写了一些我引以为豪的东西，并想重新使用。我发现很难导入。我已经查看并尝试实施以下问题的答案但无济于事：

1. 无法在 Python 中导入我自己的模块
2. 如何在python 3.6中导入我自己的模块？
3. 如何以优雅的方式导入我自己的模块？

项目结构：

learning_project
|
????.idea
?   ????dictionaries
?   ????inspectionProfiles
|
????decision_trees
????linear_algebra
????neural_networks
|   ????based_sequential.py <---------------------------- # Module location #
?   ????cross-entropy-gradient-descent
?   ????learning pytorch 
|       ???? class_notebook.ipynb <---------------------- # Want to import for use here #
|       ????Cat_Dog_data  
|
????venv
    ????Include
    ????Lib
    ?   ????site-packages
    ????Scripts

我尝试了以下方法：

import based_sequential
from based_sequential import ClassName
import based_sequential.ClassName
import neural_networks
from neural_networks import based_sequential
import neural_networks.based_sequential
from neural_networks.based_sequential import …

我有一个二维数组，其中每个元素都是傅里叶变换。我想“对数”地分割变换。例如，让我们取其中一个数组并将其命名为a：

a = np.arange(0, 512)

# I want to split a into 'bins' defined by b, below:
b = np.array([0] + [10 * 2**i for i in range(6)]) # [0, 10, 20, 40, 80, 160, 320, 640]

我想做的是类似于 using 的东西np.split，除了我想根据数组将值拆分为“容器”，b这样a[0, 10) 之间的所有值都在一个容器中，[10, 20) 之间的所有值都在一个容器中在另一个等等

我可以用某种复杂的 for 循环来做到这一点：

split_arr = []
for i in range(1, len(b)):
    fbin = []
    for amp in a:
        if (amp >= b[i-1]) and (amp < b[i]):
            fbin.append(amp)
    split_arr.append(fbin) …

我一直在阅读有关时间序列分解的内容，并且非常清楚它如何在简单的示例中工作，但在扩展这些概念时遇到了困难。

例如，我正在使用一些简单的合成数据：

因此，没有与该数据相关的实际时间。可以每秒或每年采样一次。无论采样频率如何，周期大约为 160 个时间步长，使用它作为period参数会产生预期结果：

# seasonal=13 based on example in the statsmodels user guide
decomp = STL(synth.value, period=160, seasonal=13).fit()

fig, ax = plt.subplots(3,1, figsize=(12,6))
decomp.trend.plot(title='Trend', ax=ax[0])
decomp.seasonal.plot(title='Seasonal', ax=ax[1])
decomp.resid.plot(title='Residual', ax=ax[2])
plt.tight_layout()
plt.show()

但看看其他数据集，要看到季节性周期并不是那么容易，所以这让我想到了几个问题：

如何在现实世界的混乱数据中找到正确的论点，尤其是period论点，还有其他论点？这只是您执行的参数搜索，直到分解看起来很正常吗？

参数

endog : array_like 要分解的数据。必须可压缩至 1-d。

period：序列的周期性。如果 None 且 endog 是 pandas Series 或 DataFrame，则尝试从 endog 进行确定。如果 endog 是 ndarray，则必须提供句点。

季节性：季节性的长度更平滑。必须是奇数，通常应 >= 7（默认）。

趋势：趋势的长度更平滑。必须是奇数。如果未提供，则使用大于 1.5 * period / (1 - 1.5 / season) 的最小奇整数，遵循原始实现中的建议。