如何在Python（多处理包）中并行化Ising模型？

我有一个Python脚本，可以对二维晶格的伊辛模型进行蒙特卡罗模拟。MC模拟是令人尴尬的并行，每个温度的采样可以分配到不同的线程。我想为此使用多处理模块，但这是一个新的软件包。我该怎么做

from __future__ import division
import numpy as np
from numpy.random import rand
import matplotlib.pyplot as plt
import multiprocessing as mp

nt    = 5
N     = 16

Energy = np.zeros(nt)
Magnetization = np.zeros(nt)

T  = np.linspace(1, 5, nt) 

## monte carlo moves
def mcmove(config, beta):
    for i in range(N):
        for j in range(N):
                a = np.random.randint(0, N)
                b = np.random.randint(0, N)
                s =  config[a, b]
                nb = config[(a+1)%N,b] + config[a,(b+1)%N] + config[(a-1)%N,b] + config[a,(b-1)%N]
                cost = 2*s*nb
                if cost < 0:
                    s *= -1
                elif rand() < np.exp(-cost*beta):
                    s *= -1
                config[a, b] = s
    return config

# calculate thermodynamic variables
def calcEnergy(config):
    energy = 0
    for i in range(len(config)):
        for j in range(len(config)):
            S = config[i,j]
            nb = config[(i+1)%N, j] + config[i,(j+1)%N] + config[(i-1)%N, j] + config[i,(j-1)%N]
            energy += -nb*S
    return energy/4.

def calcMag(config):
    mag = np.sum(config)
    return mag

def simulate():
# -->: parallelize T  
    for m in range(len(T)):
        E1 = M1 = 0
        def initialstate(N):  
            state = 2*np.random.randint(2, size=(N,N))-1
            return state

        eqSteps = 2000
        config = initialstate(N)
        for i in range(eqSteps):
            mcmove(config, 1.0/T[m])

        mcSteps = 2000
        for i in range(mcSteps):
            mcmove(config, 1.0/T[m])   
            Ene = calcEnergy(config)        
            Mag = calcMag(config)           

            E1 = E1 + Ene
            M1 = M1 + Mag

            Energy[m]         = E1/(mcSteps*N*N)
            Magnetization[m]  = M1/(mcSteps*N*N)

    return Magnetization, Energy

Magnetization, Energy = simulate() 
print Magnetization, Energy

来自未来进口部的

将numpy作为np导入
从numpy.random导入rand
将matplotlib.pyplot作为plt导入
将多处理作为mp导入
nt=5
N=16
能量=np.零（nt）
磁化强度=np.零（nt）
T=np.linspace（1,5,nt）
##蒙特卡罗移动
def mcmove（配置，测试版）：
对于范围（N）中的i：
对于范围（N）内的j：
a=np.random.randint（0，N）
b=np.random.randint（0，N）
s=配置[a，b]
nb=配置[（a+1）%N，b]+配置[a，（b+1）%N]+配置[（a-1）%N，b]+配置[a，（b-1）%N]
成本=2*s*nb
如果成本<0：
s*=-1
elif rand（）：并行化T
对于范围内的m（len（T））：
E1=M1=0
def初始状态（N）：
state=2*np.random.randint（2，size=（N，N））-1
返回状态
方程步骤=2000
配置=初始状态（N）
对于范围内的i（eqSteps）：
mcmove（配置，1.0/T[m]）
mcSteps=2000
对于范围内的i（mcSteps）：
mcmove（配置，1.0/T[m]）
Ene=calcEnergy（配置）
Mag=calcMag（配置）
E1=E1+Ene
M1=M1+Mag
能量[m]=E1/（微秒级*N*N）
磁化强度[m]=M1/（mcSteps*N*N）
回磁
磁化，能量=模拟（）
打印磁化、能量

给你：

from __future__ import division
import numpy as np
from numpy.random import rand
import matplotlib.pyplot as plt
import multiprocessing as mp

nt    = 5
N     = 16

Energy = np.zeros(nt)
Magnetization = np.zeros(nt)

T  = np.linspace(1, 5, nt) 

## monte carlo moves
def mcmove(config, beta):
    for i in range(N):
        for j in range(N):
                a = np.random.randint(0, N)
                b = np.random.randint(0, N)
                s =  config[a, b]
                nb = config[(a+1)%N,b] + config[a,(b+1)%N] + config[(a-1)%N,b] + config[a,(b-1)%N]
                cost = 2*s*nb
                if cost < 0:
                    s *= -1
                elif rand() < np.exp(-cost*beta):
                    s *= -1
                config[a, b] = s
    return config

# calculate thermodynamic variables
def calcEnergy(config):
    energy = 0
    for i in range(len(config)):
        for j in range(len(config)):
            S = config[i,j]
            nb = config[(i+1)%N, j] + config[i,(j+1)%N] + config[(i-1)%N, j] + config[i,(j-1)%N]
            energy += -nb*S
    return energy/4.

def calcMag(config):
    mag = np.sum(config)
    return mag


def run_one(m):
    E1 = M1 = _Energy = _Magnetization = 0

    def initialstate(N):
        state = 2 * np.random.randint(2, size=(N, N)) - 1
        return state

    eqSteps = 2000
    config = initialstate(N)
    for i in range(eqSteps):
        mcmove(config, 1.0 / m)

    mcSteps = 2000
    for i in range(mcSteps):
        mcmove(config, 1.0 / m)
        Ene = calcEnergy(config)
        Mag = calcMag(config)

        E1 = E1 + Ene
        M1 = M1 + Mag

        _Energy= E1 / (mcSteps * N * N)
        _Magnetization = M1 / (mcSteps * N * N)

    return _Energy, _Magnetization


def parallel_sim():
    p = mp.Pool()
    results = p.map(run_one, T)
    p.close()
    p.join()
    _e = []
    _m = []
    for _r in results:
        _e.append(_r[0])
        _m.append(_r[1])
    return _e, _m

print parallel_sim()

来自未来进口部的

将numpy作为np导入
从numpy.random导入rand
将matplotlib.pyplot作为plt导入
将多处理作为mp导入
nt=5
N=16
能量=np.零（nt）
磁化强度=np.零（nt）
T=np.linspace（1,5,nt）
##蒙特卡罗移动
def mcmove（配置，测试版）：
对于范围（N）中的i：
对于范围（N）内的j：
a=np.random.randint（0，N）
b=np.random.randint（0，N）
s=配置[a，b]
nb=配置[（a+1）%N，b]+配置[a，（b+1）%N]+配置[（a-1）%N，b]+配置[a，（b-1）%N]
成本=2*s*nb
如果成本<0：
s*=-1
elif rand（）

---

我对算法一无所知，请确认我没有弄坏它。现在它将T的每个元素映射到并行进程

如果答案能回答你的问题，你可以接受。