小编skj*_*rns的帖子

众所周知,我们需要使用Python 来保护main()运行时代码.multiprocessingif __name__ == '__main__'

我理解在某些情况下这是必要的,以提供对main中定义的函数的访问,但我不明白为什么在这种情况下这是必要的:

file2.py

import numpy as np
from multiprocessing import Pool
class Something(object):
    def get_image(self):
        return np.random.rand(64,64)

    def mp(self):
        image = self.get_image()
        p = Pool(2)
        res1 = p.apply_async(np.sum, (image,))
        res2 = p.apply_async(np.mean, (image,))
        print(res1.get())
        print(res2.get())
        p.close()
        p.join()

main.py

from file2 import Something
s = Something()
s.mp()

Something工作所需的所有功能或进口都是其中的一部分file2.py.为什么子流程需要重新运行main.py？

我认为__name__解决方案不是很好,因为这阻止我分发代码,file2.py因为我不能确保他们保护他们的主要.Windows没有解决方法吗？如何解决这个问题(因为我从来没有遇到任何问题,没有用任何软件包来保护我的主程序 - 他们只是不使用多处理？)

编辑: 我知道这是因为fork()Windows中没有实现.我只是问是否有一个黑客让翻译开始,file2.py而不是main.py因为我可以肯定这file2.py是自给自足的

我使用该joblib.Memory模块来缓存多个模块中的一些函数。缓存在模块和类中分别初始化。

模块1：

memory = Memory(location='/cache/')
@memory.cache
def heavy_function(...)
    .....

模块2：

memory = Memory(location='/cache/')
@memory.cache
def heavy_function2(...)
    .....

模块3：

import Module1
import Module2

def heavy_function3(...)
    Module1.heavy_function1(...)
    Module1.heavy_function1(...)
    .....

现在我有一个单元测试脚本，我想在单元测试期间全局禁用缓存的使用，以确保所有内容都正确计算。这是否可以在不通过 Module1.memory.cachedir=None或不删除缓存目录的情况下为每个模块手动禁用它？

我当前的解决方案只是手动修补每个内存调用

单元测试1：

from joblib import Memory
import Module1
Module1.memory = Memory(location=None)
...
unittest.run()

单元测试3：

from joblib import Memory
import Module1 # need to import module 1 just to disable its memory
import Module2 # need to import module 2 just to disable its memory
import Modul3
Module1.memory = …

我有一个二元分类问题。我正在使用来自tensorflow.losses.log_loss.

为了检查，我使用sklearn.metrics.log_loss. 大多数情况下，这两个函数给出相同的结果（仅 dtype 不同）。在某些情况下，sklearn函数NaN在tf.losses.log_loss返回正确值的同时返回。

数据在这里：https : //pastebin.com/BvDgDnVT

代码：

import sklearn.metrics
import tensorflow as tf
y_true = [... see pastebin link]
y_pred = [... see pastebin link]
loss_sk = sklearn.metrics.log_loss(y_true, y_pred, labels=[0, 1]) # -> returns NaN
with tf.Session() as sess:
    loss_tf = tf.losses.log_loss(y_true, y_pred).eval(session=sess) # -> returns 0.0549

好像有些log(0)事情发生了，但是为什么tensorflow没有这个问题呢？