小编Nic*_*ais的帖子

在pytorch中，如果我定义一个单元素张量如下：

>>> import torch
>>> target1 = torch.tensor([5])

我可以像这样提取一个元素的值：

>>> target1.item()
5

我想知道的是，当我的张量定义为：

target2 = torch.tensor([[5], [5], [5], [5]])

是否有某种方法（类似于或不类似于上面的.item()）将其所有条目提取到一个列表中，例如：

>>> target2.(something)
[5, 5, 5, 5]

我似乎无法在支持此类操作的文档中找到任何功能。

Pytorch 的 dropout 层会更改未设置为零的值。使用 Pytorch 的文档示例：（来源）：

import torch
import torch.nn  as nn

m = nn.Dropout(p=0.5)
input = torch.ones(5, 5)

print(input)
tensor([[1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.]])

然后我通过一个dropout层：

output = m(input)
print(output)
tensor([[0., 0., 2., 2., 0.],
        [2., 0., 2., 0., 0.],
        [0., 0., 0., 0., 2.],
        [2., 2., 2., 2., 2.],
        [2., 0., 0., 0., 2.]])

未设置为零的值现在是 …

我很好奇如何sklearn处理连续变量sklearn.tree.DecisionTreeClassifier？我尝试使用一些连续变量而不使用 进行预处理DecisionTreeClassifier，但它获得了可接受的精度。

下面是一种将连续变量转换为分类变量的方法，但它不能获得相同的精度。

def preprocess(data, min_d, max_d, bin_size=3):

    norm_data = np.clip((data - min_d) / (max_d - min_d), 0, 1)
    categorical_data = np.floor(bin_size*norm_data).astype(int)
    return categorical_data


X = preprocess(X, X.min(), X.max(), 3)

此时间戳用于记录错误。

import os.path
import datetime

timestamp = datetime.datetime.now().strftime('%Y-%m-%d')

试图搜索，但无法找到与此相关的任何内容。我想知道你什么时候使用双日期时间方法？

我用 Iris 数据集制作了一个可重复性最低的示例。我制作了一个完整的神经网络来预测虹膜特征的最后一列。我还想输出目标（类别）。因此，网络必须最小化两种不同的损失函数（连续损失函数和分类损失函数）。全部设置为下一个示例中的连续目标。但是，如何将其转化为多输出问题呢？

import tensorflow as tf
from tensorflow.keras.layers import Dense
from tensorflow.keras import Model
from sklearn.datasets import load_iris
tf.keras.backend.set_floatx('float64')
iris, target = load_iris(return_X_y=True)

X = iris[:, :3]
y = iris[:, 3]
z = target

ds = tf.data.Dataset.from_tensor_slices((X, y, z)).batch(8)

class MyModel(Model):
    def __init__(self):
        super(MyModel, self).__init__()
        self.d0 = Dense(16, activation='relu')
        self.d1 = Dense(32, activation='relu')
        self.d2 = Dense(1)

    def call(self, x):
        x = self.d0(x)
        x = self.d1(x)
        x = self.d2(x)
        return x

model = MyModel()

loss_object = tf.keras.losses.MeanAbsoluteError()
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-4) …

我有一个pd.DataFrame完整的图片名称。通常，图像名称会重复。但是，他们总是紧挨着对方。这是它的样子：

import pandas as pd
from numpy.random import randint

df = pd.DataFrame(sorted(['image_{}'.format(randint(4)) for i in range(10)]),
     columns=['Image Name'])

print(df)

Out[6]: 
  Image Name
0    image_0
1    image_0
2    image_0
3    image_1
4    image_1
5    image_2
6    image_2
7    image_2
8    image_3
9    image_3

因为我将根据此名称保存图像，所以我想将这些字符串附加到累积计数中，如下所示：

Out[7]: 
  Image Name
0    image_0_1
1    image_0_2
2    image_0_3
3    image_1_1
4    image_1_2
5    image_2_1
6    image_2_2
7    image_2_3
8    image_3_1
9    image_3_1

我该如何继续？我猜是groupby和 的某种组合cumcount？

我有一个熊猫数据框，它有列A&B

我只想绘制列A&之间差异百分比的分布图B

        A                B
  1 1.051990e+10    1.051990e+04
  2 1.051990e+10    1.051990e+04
  5 4.841800e+10    1.200000e+10
  8 2.327700e+10    2.716000e+10
  9 1.204900e+10    2.100000e+08

分布图就像，有多少条记录有 10% 的差异，有多少条记录有 20% 的差异

我试过如下

df percCal(x,y):
  return (x-y)*100/x

df['perc'] = df.apply(lambda x: percCal(df['A'], df['B']), axis=1)

这不起作用，因为我是新手，请帮忙

我想将所有数组填充到某个恒定的形状。

所有数组的大小均为 (X, 13)，但我希望它们为 (99, 13)。X 小于或等于 99。有些数组小于 99。我正在寻找一种方法将它们填充到默认大小var。

我已经看到并尝试过动态检查填充的示例，但我找不到正确的代码。

for item in data:
    if len(item) < len(var):
        np.pad(len(var) - len(item)

我正在使用某人的代码，c++其中由python. 我无法进入源代码并对其进行修改。当用 调用时python，它会打印一些东西，我想将此输出分配给一个变量。我怎样才能做到这一点？

def print_something(string):
    print(string)

x = print_something('foo')

print(type(x))

Out[5]: NoneType

理想情况下，此代码将分配'foo'给x作为字符串。

Fashion MNIST 数据集在 Pytorch 中的实现非常奇怪。我想做类似的事情：

X, y = FashionMNIST

但实际上，情况要复杂一些。这就是我所拥有的：

from torchvision.datasets import FashionMNIST
train = FashionMNIST(root='.', download=True, train=True)
print(train)

输出：

Dataset FashionMNIST
    Number of datapoints: 60000
    Root location: c:/users/nicolas/documents/data/fashionmnist
    Split: Train

什么一个观察的样子：

print(train[0])

(<PIL.Image.Image image mode=L size=28x28 at 0x20868074780>, 9)

我只能做一次观察。

X, y = train[0]

那么如何分离输入和目标呢？