如何在Python中绘制给定函数的热图

我有一个名为

func（mu，gamma）

的函数。对于

mu

和

gamma

的每个组合，函数将返回一个值，我们称之为

return\u value

现在我已经为

mu

和

gamma

设置了范围：

mu = np.linspace(0,1,100)
gamma = np.linspace(0,1,100)

现在我们有1e4个组合，每个组合对应一个

返回值

。我想为

返回值

绘制热图

我曾尝试在Python中使用

pcolor

。但是，根据文档中的示例：

import matplotlib.pyplot as plt
import numpy as np

# make these smaller to increase the resolution
dx, dy = 0.15, 0.05

# generate 2 2d grids for the x & y bounds
y, x = np.mgrid[slice(-3, 3 + dy, dy),
                slice(-3, 3 + dx, dx)]
z = (1 - x / 2. + x ** 5 + y ** 3) * np.exp(-x ** 2 - y ** 2)
# x and y are bounds, so z should be the value *inside* those bounds.
# Therefore, remove the last value from the z array.
z = z[:-1, :-1]
z_min, z_max = -np.abs(z).max(), np.abs(z).max()

因为我的脚本中定义的函数

fun

无法将数组作为输入，所以它不起作用，如果我按照下面的示例操作，我会收到以下消息：

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

下面是我的

func

代码：

def fun(mu, gamma2):
    Isolation_Ratio = []
    kappa1 = gamma2
    kappa2 = gamma2                         
    gamma1 = gamma2
    g0 = gamma2 + kappa2 + gamma1 + kappa1
    gammag = kappa1/2. + gamma1/2.
    gamma = gamma2/2. + kappa2/2.
    for ii in range(len(rangedeltaw)):

        deltaw = rangedeltaw[ii]

        Forward_delta = forward_delta(mu, deltaw)
        Backward_delta = backward_delta(mu, deltaw)

        forward_root1, forward_root2, forward_root3 = forward_root(mu, deltaw)
        test_D, backward_root1, backward_root2, backward_root3 = backward_root(mu, deltaw)

        Root1.append(backward_root1)
        Root2.append(backward_root2)
        Root3.append(backward_root3)

        root1.append(forward_root1)
        root2.append(forward_root2)
        root3.append(forward_root3)
        if Forward_delta >= 0 and Backward_delta >= 0:
            a2sq = [max([forward_root1.real, forward_root2.real, forward_root3.real])]
            b1sq = [max([backward_root1.real, backward_root2.real, backward_root3.real])]
            A2sq.append(max([forward_root1.real, forward_root2.real, forward_root3.real]))
            B1sq.append(max([backward_root1.real, backward_root2.real, backward_root3.real]))
            for ii in range(len(a2sq)):
                for jj in range(len(b1sq)):

                    Isolation_Ratio.append(kappa2*a2sq[ii]/(kappa1*b1sq[jj]))
        elif Forward_delta >= 0 and Backward_delta < 0:
            a2sq = [max([forward_root1.real, forward_root2.real, forward_root3.real])]
            b1sq = [backward_root1.real]
            A2sq.append(max([forward_root1.real, forward_root2.real, forward_root3.real]))
            B1sq.append(backward_root1.real)
            for ii in range(len(a2sq)):
                for jj in range(len(b1sq)):
                    Isolation_Ratio.append(kappa2*a2sq[ii]/(kappa1*b1sq[jj]))

        elif Forward_delta < 0 and Backward_delta >= 0:
            a2sq = [forward_root1.real]
            b1sq = [max([backward_root1.real, backward_root2.real, backward_root3.real])]
            A2sq.append(forward_root1.real)
            B1sq.append(max([backward_root1.real, backward_root2.real, backward_root3.real]))
            for ii in range(len(a2sq)):
                for jj in range(len(b1sq)):
                    Isolation_Ratio.append(kappa2*a2sq[ii]/(kappa1*b1sq[jj]))

        else:   
            A2sq.append(forward_root1.real)
            B1sq.append(backward_root1.real)
            Isolation_Ratio.append(kappa2*forward_root1.real/(kappa1*backward_root1.real))   



    x = Isolation_RangeDeltaw
    y = Isolation_Ratio


    return max(y)

def-fun（mu，gamma2）：
隔离率=[]
kappa1=gamma2
kappa2=gamma2
gamma1=gamma2
g0=gamma2+kappa2+gamma1+kappa1
gammag=kappa1/2+伽玛1/2。
伽马=伽马2/2+kappa2/2。
对于范围内的ii（len（rangedeltaw））：
deltaw=范围deltaw[ii]
前向三角洲=前向三角洲（mu，deltaw）
后向三角洲=后向三角洲（μ，三角洲）
前向根1，前向根2，前向根3=前向根（mu，deltaw）
测试D，向后根1，向后根2，向后根3=向后根（mu，deltaw）
Root1.append（向后\u Root1）
Root2.append（向后_Root2）
Root3.append（向后\u Root3）
root1.追加（前向\u root1）
root2.追加（前向\u root2）
root3.追加（前向\u root3）
如果前向_增量>=0和后向_增量>=0：
a2sq=[max（[forward\u root1.real，forward\u root2.real，forward\u root3.real]）]
b1sq=[max（[backward\u root1.real，backward\u root2.real，backward\u root3.real]）]
A2sq.append（最大值（[forward\u root1.real，forward\u root2.real，forward\u root3.real]））
B1sq.append（最大值（[backward\u root1.real，backward\u root2.real，backward\u root3.real]））
对于范围内的ii（透镜（a2sq））：
对于范围内的jj（len（b1sq））：
隔离比附加（kappa2*a2sq[ii]/（kappa1*b1sq[jj]））
elif前向增量>=0和后向增量<0：
a2sq=[max（[forward\u root1.real，forward\u root2.real，forward\u root3.real]）]
b1sq=[backward_root1.real]
A2sq.append（最大值（[forward\u root1.real，forward\u root2.real，forward\u root3.real]））
B1sq.append（向后_root1.real）
对于范围内的ii（透镜（a2sq））：
对于范围内的jj（len（b1sq））：
隔离比附加（kappa2*a2sq[ii]/（kappa1*b1sq[jj]））
elif前向增量<0和后向增量>=0：
a2sq=[forward_root1.real]
b1sq=[max（[backward\u root1.real，backward\u root2.real，backward\u root3.real]）]
A2sq.append（前向\根1.real）
B1sq.append（最大值（[backward\u root1.real，backward\u root2.real，backward\u root3.real]））
对于范围内的ii（透镜（a2sq））：
对于范围内的jj（len（b1sq））：
隔离比附加（kappa2*a2sq[ii]/（kappa1*b1sq[jj]））
其他：
A2sq.append（前向\根1.real）
B1sq.append（向后_root1.real）
隔离率.append（kappa2*向前根1.real/（kappa1*向后根1.real））
x=隔离度
y=隔离比
返回最大值（y）

首先，如何获取热图

fun（）

仍然不是自包含的（

forward\u delta（）

等未定义），因此我无法执行它，并且您没有指定错误发生在哪一行，但我可以猜到违规者是

if Forward_delta >= 0 and Backward_delta >= 0:

这意味着

forward_delta（）

etc函数与数组一起工作。从外观上看，完全矢量化函数是可能的，但这是一项非常重要的任务，也是一个问题（如果你问过它，请确保做一个）。一个简单但效率较低的解决方案是按值填充热图值：

import matplotlib.pyplot as plt
import numpy

def fun(mu, gamma):
    # your function

mu = numpy.linspace(0,1,100)
gamma = numpy.linspace(0,1,100)

# filling the heatmap, value by value
fun_map = numpy.empty((mu.size, gamma.size))
for i in range(mu.size):
    for j in range(gamma.size):
        fun_map[i,j] = fun(mu[i], gamma[j])

现在您已经有了数组，问题的第二部分是如何绘制它。用于显示离散阵列；更适合你的目的：

fig = plt.figure()
s = fig.add_subplot(1, 1, 1, xlabel='$\\gamma$', ylabel='$\\mu$')
im = s.imshow(
    fun_map,
    extent=(gamma[0], gamma[-1], mu[0], mu[-1]),
    origin='lower')
fig.colorbar(im)
fig.savefig('t.png')

请注意，在数组中，X维度是最后一个（对应于

gamma

），但

imshow

将X维度放在第一位

一个简单函数的结果

def fun(mu, gamma):
    return numpy.sin(mu) + numpy.cos(gamma)

看起来像

---

因此，首先，如何获得热图

fun（）

仍然不是自包含的（

forward\u delta（）

等未定义），因此我无法执行它，并且您没有指定错误发生在哪一行，但我可以猜到违规者是

if Forward_delta >= 0 and Backward_delta >= 0:

这意味着

forward_delta（）

etc函数与数组一起工作。从外观上看，完全矢量化函数是可能的，但这是一项非常重要的任务，也是一个问题（如果你问过它，请确保做一个）。一个简单但效率较低的解决方案是按值填充热图值：

import matplotlib.pyplot as plt
import numpy

def fun(mu, gamma):
    # your function

mu = numpy.linspace(0,1,100)
gamma = numpy.linspace(0,1,100)

# filling the heatmap, value by value
fun_map = numpy.empty((mu.size, gamma.size))
for i in range(mu.size):
    for j in range(gamma.size):
        fun_map[i,j] = fun(mu[i], gamma[j])

现在您已经有了数组，问题的第二部分是如何绘制它。用于显示离散阵列；更适合你的目的：

fig = plt.figure()
s = fig.add_subplot(1, 1, 1, xlabel='$\\gamma$', ylabel='$\\mu$')
im = s.imshow(
    fun_map,
    extent=(gamma[0], gamma[-1], mu[0], mu[-1]),
    origin='lower')
fig.colorbar(im)
fig.savefig('t.png')

请注意，在数组中，X维度是最后一个（对应于

gamma

），但

imshow

将X维度放在第一位

一个简单函数的结果

def fun(mu, gamma):
    return numpy.sin(mu) + numpy.cos(gamma)

看起来像

---

给定函数，您想知道如何绘制热图，还是如何获取热图？在后一种情况下，如果不实际查看其代码，就不可能知道如何向量化

fun（）

。我对plot和get之间的区别有点困惑。我想实现的是，例如，我们得到以下形式的数据：[1,2,3]，[2,3,4]…前两个用作坐标，第三个是该坐标的值。如果我想在2D中绘制坐标，我想我只能用颜色来表示与该坐标相关的值。获取意味着获取