小编Gan*_*rei的帖子

运行 Numpy 1.19.2 版，与通过计算已经展平的数组的平均值相比，我在累积数组每个单独轴的平均值方面获得了更好的性能。

shape = (10000,32,32,3)
mat = np.random.random(shape)

# Call this Method A.
%%timeit
mat_means = mat.mean(axis=0).mean(axis=0).mean(axis=0)

14.6 ms ± 167 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

mat_reshaped = mat.reshape(-1,3)

# Call this Method B
%%timeit
mat_means = mat_reshaped.mean(axis=0)

135 ms ± 227 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

这很奇怪，因为多次执行平均值具有与重构阵列上的相同的错误访问模式（可能甚至更糟）。我们也以这种方式进行更多的操作。作为完整性检查，我将数组转换为 FORTRAN 顺序：

mat_reshaped_fortran = mat.reshape(-1,3, order='F')

%%timeit
mat_means = mat_reshaped_fortran.mean(axis=0)

12.2 ms ± 85.9 …

我也曾在定制模块中遇到过这种情况，但在本示例中，我专门使用了官方 PyTorch 示例之一和 MNIST 数据集。

我已经使用 Eager 模式在 Keras 和 TF2 中移植了确切的架构，如下所示：

model = keras.models.Sequential([ keras.layers.Conv2D(32, (3, 3) , input_shape=(28,28,1), activation='relu'),
                                 keras.layers.Conv2D(64, (3, 3)),
                                 keras.layers.MaxPool2D((2, 2)),
                                 keras.layers.Dropout(0.25),
                                 keras.layers.Flatten(),
                                 keras.layers.Dense(128, activation='relu'),
                                 keras.layers.Dropout(0.5),
                                 keras.layers.Dense(10, activation='softmax')]
                                )

model.summary()

model.compile(optimizer=keras.optimizers.Adadelta(), loss=keras.losses.sparse_categorical_crossentropy, metrics=['accuracy'])

model.fit(train_data,train_labels,batch_size=64,epochs=30,shuffle=True, max_queue_size=1)

PyTorch 中的训练循环是：

def train(args, model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()

和我一起为每个时代计时：

for epoch in range(1, …

我不明白在初始化时需要指定extern/static变量的类型.例如:

struct Test{
 static int i;
};
 Test::i = 2; //error
 int Test::i = 2; //ok

编译器不知道我是int类型吗？它只是编译器的特殊性,或者为什么类型的规范,int"需要？

我最近一直试图重新熟悉多线程,并发现了这篇论文.其中一个例子说使用这样的代码时要小心:

int my_counter = counter; // Read global
int (* my_func) (int);
if (my_counter > my_old_counter) {
  ... // Consume data
  my_func = ...;
  ... // Do some more consumer work
}
... // Do some other work
if (my_counter > my_old_counter) {
... my_func(...) ...
}

说明:

如果编译器决定它需要在两个测试之间溢出包含我的计数器的寄存器,它可能决定避免存储该值(毕竟它只是一个计数器的副本),而是简单地重新读取值计数器进行第二次比较涉及我的柜台[...]

这样做可以将代码转换为:

int my_counter = counter; // Read global
int (* my_func) (int);
if (my_counter > my_old_counter) {
  ... // Consume data
  my_func = ...;
  ... // Do some more …