pythoncolormap(pythoncolormap雷达)

python colormap 怎么用

主要的就是x轴和y轴的处理，我按照对数算了一下你提供的数据，好像和这个图效果不一样。

Python实现彩色散点图绘制（利用色带对散点图进行颜色渲染）

接受自己的普通，然后全力以赴的出众，告诉自己要努力，但不要着急....

当然， 这个结果并不是我真正想要的，Pass, 太丑了！

好吧，安排，我们先看下实现后的效果！

这个效果自然就比之前的好多了！

实现python散点图绘制需要用到matplotlib库， matplotlib库是专门用于可视化绘图的工具库；学习一个新的库当然看官方文档了：

实现思路：

matplotlib.pyplot.scatter() 函数是专门绘制散点图的函数：

matplotlib.pyplot.scatter ( x, y , s=None , c=None , marker=None , cmap=None , norm=None , vmin=None , vmax=None , alpha=None , linewidths=None , verts=None , edgecolors=None , ***, data=None , ** kwargs ) **

plt.scatter(observation, estimate, c=Z1, cmap=colormap, marker=".", s=marker_size, norm=colors.LogNorm(vmin=Z1.min(), vmax=0.5 * Z1.max()))

其中：

1、c参数为计算的散点密度；

2、cmap为色带（matplotlib里面自带了很多色带可供选择）,参见：

3、由于计算的散点密度数值大小分散，因此利用norm参数对散点密度Z1进行归一化处理(归一化方式很多，参见colors类)，并给归一化方式设置色带刻度的最大最小值vmin和vmax(一般这两个参数就是指定散点密度的最小值和最大值)，这样就建立起了密度与色带的映射关系。

（这里的结果与前面展示的相比改变了计算散点密度的半径：radius = 3以及绘制散点图的散点大小marksize）

作者能力水平有限，欢迎各位批评指正！

利用Python实现卷积神经网络的可视化

在本文中，将探讨如何可视化卷积神经网络（CNN），该网络在计算机视觉中使用最为广泛。首先了解CNN模型可视化的重要性，其次介绍可视化的几种方法，同时以一个用例帮助读者更好地理解模型可视化这一概念。

正如上文中介绍的癌症肿瘤诊断案例所看到的，研究人员需要对所设计模型的工作原理及其功能掌握清楚，这点至关重要。一般而言，一名深度学习研究者应该记住以下几点：

1.1 理解模型是如何工作的

1.2 调整模型的参数

1.3 找出模型失败的原因

1.4 向消费者/终端用户或业务主管解释模型做出的决定

2.可视化CNN模型的方法

根据其内部的工作原理，大体上可以将CNN可视化方法分为以下三类：

初步方法：一种显示训练模型整体结构的简单方法

基于激活的方法：对单个或一组神经元的激活状态进行破译以了解其工作过程

基于梯度的方法：在训练过程中操作前向传播和后向传播形成的梯度

下面将具体介绍以上三种方法，所举例子是使用Keras深度学习库实现，另外本文使用的数据集是由“识别数字”竞赛提供。因此，读者想复现文中案例时，请确保安装好Kears以及执行了这些步骤。

研究者能做的最简单的事情就是绘制出模型结构图，此外还可以标注神经网络中每层的形状及参数。在keras中，可以使用如下命令完成模型结构图的绘制：

model.summary()_________________________________________________________________Layer (type) ? ? ? ? ? ? ? ? Output Shape ? ? ? ? ? ? ?Param # ?

=================================================================conv2d_1 (Conv2D) ? ? ? ? ? ?(None, 26, 26, 32) ? ? ? ?320_________________________________________________________________conv2d_2 (Conv2D) ? ? ? ? ? ?(None, 24, 24, 64) ? ? ? ?18496_________________________________________________________________max_pooling2d_1 (MaxPooling2 (None, 12, 12, 64) ? ? ? ?0_________________________________________________________________dropout_1 (Dropout) ? ? ? ? ?(None, 12, 12, 64) ? ? ? ?0_________________________________________________________________flatten_1 (Flatten) ? ? ? ? ?(None, 9216) ? ? ? ? ? ? ?0_________________________________________________________________dense_1 (Dense) ? ? ? ? ? ? ?(None, 128) ? ? ? ? ? ? ? 1179776_________________________________________________________________dropout_2 (Dropout) ? ? ? ? ?(None, 128) ? ? ? ? ? ? ? 0_________________________________________________________________preds (Dense) ? ? ? ? ? ? ? ?(None, 10) ? ? ? ? ? ? ? ?1290 ? ? ?

=================================================================Total params: 1,199,882Trainable params: 1,199,882Non-trainable params: 0

还可以用一个更富有创造力和表现力的方式呈现模型结构框图，可以使用keras.utils.vis_utils函数完成模型体系结构图的绘制。

另一种方法是绘制训练模型的过滤器，这样就可以了解这些过滤器的表现形式。例如，第一层的第一个过滤器看起来像：

top_layer = model.layers[0]plt.imshow(top_layer.get_weights()[0][:, :, :, 0].squeeze(), cmap='gray')

一般来说，神经网络的底层主要是作为边缘检测器，当层数变深时，过滤器能够捕捉更加抽象的概念，比如人脸等。

为了理解神经网络的工作过程，可以在输入图像上应用过滤器，然后绘制其卷积后的输出，这使得我们能够理解一个过滤器其特定的激活模式是什么。比如，下图是一个人脸过滤器，当输入图像是人脸图像时候，它就会被激活。

from vis.visualization import visualize_activation

from vis.utils import utils

from keras import activations

from matplotlib import pyplot as plt

%matplotlib inline

plt.rcParams['figure.figsize'] = (18, 6)

# Utility to search for layer index by name.

# Alternatively we can specify this as -1 since it corresponds to the last layer.

layer_idx = utils.find_layer_idx(model, 'preds')

# Swap softmax with linear

model.layers[layer_idx].activation = activations.linear

model = utils.apply_modifications(model)

# This is the output node we want to maximize.filter_idx = 0

img = visualize_activation(model, layer_idx, filter_indices=filter_idx)

plt.imshow(img[..., 0])

同理，可以将这个想法应用于所有的类别，并检查它们的模式会是什么样子。

for output_idx in np.arange(10):

? # Lets turn off verbose output this time to avoid clutter and just see the output.

? img = visualize_activation(model, layer_idx, filter_indices=output_idx, input_range=(0., 1.))

? plt.figure()

? plt.title('Networks perception of {}'.format(output_idx))

? plt.imshow(img[..., 0])

在图像分类问题中，可能会遇到目标物体被遮挡，有时候只有物体的一小部分可见的情况。基于图像遮挡的方法是通过一个灰色正方形系统地输入图像的不同部分并监视分类器的输出。这些例子清楚地表明模型在场景中定位对象时，若对象被遮挡，其分类正确的概率显著降低。

为了理解这一概念，可以从数据集中随机抽取图像，并尝试绘制该图的热图（heatmap）。这使得我们直观地了解图像的哪些部分对于该模型而言的重要性，以便对实际类别进行明确的区分。

def iter_occlusion(image, size=8):

? ? # taken from

? occlusion = np.full((size * 5, size * 5, 1), [0.5], np.float32)

? occlusion_center = np.full((size, size, 1), [0.5], np.float32)

? occlusion_padding = size * 2

? # print('padding...')

? image_padded = np.pad(image, ( \? (occlusion_padding, occlusion_padding), (occlusion_padding, occlusion_padding), (0, 0) \? ), 'constant', constant_values = 0.0)

? for y in range(occlusion_padding, image.shape[0] + occlusion_padding, size):

? ? ? for x in range(occlusion_padding, image.shape[1] + occlusion_padding, size):

? ? ? ? ? tmp = image_padded.copy()

? ? ? ? ? tmp[y - occlusion_padding:y + occlusion_center.shape[0] + occlusion_padding, \

? ? ? ? ? ? x - occlusion_padding:x + occlusion_center.shape[1] + occlusion_padding] \? ? ? ? ? ? = occlusion

? ? ? ? ? tmp[y:y + occlusion_center.shape[0], x:x + occlusion_center.shape[1]] = occlusion_center? ? ? ? ? yield x - occlusion_padding, y - occlusion_padding, \

? ? ? ? ? ? tmp[occlusion_padding:tmp.shape[0] - occlusion_padding, occlusion_padding:tmp.shape[1] - occlusion_padding]i = 23 # for exampledata = val_x[i]correct_class = np.argmax(val_y[i])

# input tensor for model.predictinp = data.reshape(1, 28, 28, 1)# image data for matplotlib's imshowimg = data.reshape(28, 28)

# occlusionimg_size = img.shape[0]

occlusion_size = 4print('occluding...')heatmap = np.zeros((img_size, img_size), np.float32)class_pixels = np.zeros((img_size, img_size), np.int16)

from collections import defaultdict

counters = defaultdict(int)for n, (x, y, img_float) in enumerate(iter_occlusion(data, size=occlusion_size)):

? ? X = img_float.reshape(1, 28, 28, 1)

? ? out = model.predict(X)

? ? #print('#{}: {} @ {} (correct class: {})'.format(n, np.argmax(out), np.amax(out), out[0][correct_class]))

? ? #print('x {} - {} | y {} - {}'.format(x, x + occlusion_size, y, y + occlusion_size))

? ? heatmap[y:y + occlusion_size, x:x + occlusion_size] = out[0][correct_class]

? ? class_pixels[y:y + occlusion_size, x:x + occlusion_size] = np.argmax(out)

? ? counters[np.argmax(out)] += 1

正如之前的坦克案例中看到的那样，怎么才能知道模型侧重于哪部分的预测呢？为此，可以使用显著图解决这个问题。显著图首先在这篇文章中被介绍。

使用显著图的概念相当直接——计算输出类别相对于输入图像的梯度。这应该告诉我们输出类别值对于输入图像像素中的微小变化是怎样变化的。梯度中的所有正值告诉我们，像素的一个小变化会增加输出值。因此，将这些梯度可视化可以提供一些直观的信息，这种方法突出了对输出贡献最大的显著图像区域。

class_idx = 0indices = np.where(val_y[:, class_idx] == 1.)[0]

# pick some random input from here.idx = indices[0]

# Lets sanity check the picked image.from matplotlib import pyplot as plt%matplotlib inline

plt.rcParams['figure.figsize'] = (18, 6)plt.imshow(val_x[idx][..., 0])

from vis.visualization import visualize_saliency

from vis.utils import utilsfrom keras import activations# Utility to search for layer index by name.

# Alternatively we can specify this as -1 since it corresponds to the last layer.

layer_idx = utils.find_layer_idx(model, 'preds')

# Swap softmax with linearmodel.layers[layer_idx].activation = activations.linear

model = utils.apply_modifications(model)grads = visualize_saliency(model, layer_idx, filter_indices=class_idx, seed_input=val_x[idx])

# Plot with 'jet' colormap to visualize as a heatmap.plt.imshow(grads, cmap='jet')

# This corresponds to the Dense linear layer.for class_idx in np.arange(10):

? ? indices = np.where(val_y[:, class_idx] == 1.)[0]

? ? idx = indices[0]

? ? f, ax = plt.subplots(1, 4)

? ? ax[0].imshow(val_x[idx][..., 0])

? ? for i, modifier in enumerate([None, 'guided', 'relu']):

? ? ? ? grads = visualize_saliency(model, layer_idx, filter_indices=class_idx,

? ? ? ? seed_input=val_x[idx], backprop_modifier=modifier)

? ? ? ? if modifier is None:

? ? ? ? ? ? modifier = 'vanilla'

? ? ? ? ax[i+1].set_title(modifier)

? ? ? ? ax[i+1].imshow(grads, cmap='jet')

类别激活映射（CAM）或grad-CAM是另外一种可视化模型的方法，这种方法使用的不是梯度的输出值，而是使用倒数第二个卷积层的输出，这样做是为了利用存储在倒数第二层的空间信息。

from vis.visualization import visualize_cam

# This corresponds to the Dense linear layer.for class_idx in np.arange(10):

indices = np.where(val_y[:, class_idx] == 1.)[0]

idx = indices[0]f, ax = plt.subplots(1, 4)

ax[0].imshow(val_x[idx][..., 0])

for i, modifier in enumerate([None, 'guided', 'relu']):

? ? grads = visualize_cam(model, layer_idx, filter_indices=class_idx,

? ? seed_input=val_x[idx], backprop_modifier=modifier)

? ? if modifier is None:

? ? ? ? modifier = 'vanilla'

? ? ax[i+1].set_title(modifier)

? ? ax[i+1].imshow(grads, cmap='jet')

本文简单说明了CNN模型可视化的重要性，以及介绍了一些可视化CNN网络模型的方法，希望对读者有所帮助，使其能够在后续深度学习应用中构建更好的模型。 免费视频教程：

关于python 画图的问题，我有一串码完全看不懂，麻烦大家帮我看一下。

首先，确定三角形的位置需要三个点。代码里给出的myPoints = [[-100,-50],[0,100],[100,-50]]就是这三个点的位置，你可以在坐标轴里画一个x，y轴，找一下就知道了。如果只是想让三角形倒过来，就重新给它三个点[[-100,100],[100,100],[0,-50]]。

其次，三角形的边长，就是两个点之间的直线距离。从代码里可以看到，（-100，-50），（100，-50）这两个点是在同一条横向的线上，它们的距离是200.所以想把三角形的尺寸扩大两倍，就需要把边长扩大，给出新的点[[-200,200],[200,200],[0,-100]]

综上，修改main函数中的myPoints，即可达到你的需求：倒置三角形，尺寸扩大两倍

def main():

myTurtle = turtle.Turtle()

myWin = turtle.Screen()

myPoints = [[-200,200],[200,200],[0,-100]]

sierpinski(myPoints,3,myTurtle)

myWin.exitonclick()

再解释几个问题：

myTurtle.up() 和myTurtle.down()

可以把myTurtle看做是画笔，myTurtle.up()就表示把画笔从画布上抬起，也就是不跟画布接触。myTurtle.down()也就可以看成是画笔跟画布接触。

sierpinski是定义的一个递归画三角形的方法，degree可以理解成递归的深度，也就是说在一个三角形内可以再画几个小三角形（不包括中间的三角形）。代码里degree 是3，你可以运行一下代码，看看效果。

希望能帮到你，有疑问请追问！

用python画一个国庆词云图？

讲课的时候做过一个例子发给你吧。

效果是这样的：

import jieba

import wordcloud

import numpy as np

from PIL import Image

# pip install jieba -i

# pip install pillow -i

# pip install wordcloud -i

TXT = "一百年前，中国共产党的先驱们创建了中国共产党，形成了坚持真理、坚守理想，践行初心、担当使命，不怕牺牲、英勇斗争，对党忠诚、不负人民的伟大建党精神，这是中国共产党的精神之源。一百年来，中国共产党弘扬伟大建党精神，在长期奋斗中构建起中国共产党人的精神谱系，锤炼出鲜明的政治品格。历史川流不息，精神代代相传。我们要继续弘扬光荣传统、赓续红色血脉，永远把伟大建党精神继承下去、发扬光大"

mk = np.array(Image.open("love.png"))

w = wordcloud.WordCloud(font_path="msyh.ttc", colormap="Reds", mask=mk, mode="RGBA")

w.generate(" ".join(jieba.lcut(TXT)))

w.to_file("pywcloud.png")

素材图片你可以更换。

python如何画标签为0,1的原点

简单介绍python中的绘图

绘制简单的折线图

散点图

设置每个坐标轴的取值范围

将主点颜色改成白，边缘颜色为红

自动保存图表

随机漫步

随机漫步渐变色

小知识点

绘制起点和终点

画布尺寸

隐藏坐标轴

pygal

roll one dice

绘制简单的折线图

首先下载matplotlib安装程序

import matplotlib.pyplot as plt

x_values = [1, 2, 3, 4, 5, 6] # 代表x轴的值

y_values = [1, 2, 4, 8, 16, 32] # 代表与x相对应的y轴的值

# plt.plot(y_values, linewidth=3)

plt.plot(x_values, y_values, linewidth=3)

# 设置图表标题，并改变横纵坐标的名称

plt.title("figure test", fontsize=24)

plt.xlabel("xValue", fontsize=14)

plt.ylabel("yValue", fontsize=14)

# 更改刻度标记的大小

plt.tick_params(axis='both', labelsize=12)

plt.show() # 打开matplotlib查看器，显示绘制的图形

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

?

散点图

import matplotlib.pyplot as plt

# 绘制单个x = 2, y = 4坐标轴上的点

# plt.scatter(2, 4, s=100) # s用来更改单个点的大小

# 绘制一群点

x_values = [1, 2, 3, 4, 5]

y_values = [1, 2, 4, 8, 16]

plt.scatter(x_values, y_values, s=100)

# 设置图表标题，并改变横纵坐标的名称

plt.title("figure test", fontsize=24)

plt.xlabel("xValue", fontsize=14)

plt.ylabel("yValue", fontsize=14)

# 更改刻度标记的大小

plt.tick_params(axis='both', which = 'major', labelsize=12)

plt.show()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

?

另一种方法绘制此图：（自动生成数据）

import matplotlib.pyplot as plt

# 绘制单个x = 2, y = 4坐标轴上的点

# plt.scatter(2, 4, s=100) # s用来更改单个点的大小

# 绘制一群点

i = 1

x_values = list(range(1, 6))

y_values = [2**(i-1) for i in x_values]

plt.scatter(x_values, y_values, s=100)

# 设置图表标题，并改变横纵坐标的名称

plt.title("figure test", fontsize=24)

plt.xlabel("xValue", fontsize=14)

plt.ylabel("yValue", fontsize=14)

# 更改刻度标记的大小

plt.tick_params(axis='both', which='major', labelsize=12)

plt.show()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

设置每个坐标轴的取值范围

plt.axis([0, 100, 0, 1000])

1

1

前面对应x, 后面对应y

?

将主点颜色改成白，边缘颜色为红

plt.scatter(x_values, y_values, c='white', edgecolor='red', s=20)

plt.scatter(x_values, y_values, c=(1, 1, 1), edgecolor='red', s=20)

1

2

1

2

c for color; 含三个0~1之间的小数值

颜色映射（colormap）

plt.scatter(x_values, y_values, c=y_values, cmap=plt.cm.Reds,

edgecolor='none', s=40)

1

2

1

2

要了解pyplot中所有的颜色映射:

自动保存图表

plt.savefig(‘Figure1.png’, bbox_inches=‘tight’)

第一个参数表示名字, 将其以Figure1.png存储在example.py同一个文件夹里

第二个参数表示将图表多余的空白区域裁剪掉

随机漫步

随机游走（random walk）也称随机漫步，随机行走等是指基于过去的表现，无法预测将来的发展步骤和方向。核心概念是指任何无规则行走者所带的守恒量都各自对应着一个扩散运输定律 ，接近于布朗运动，是布朗运动理想的数学状态，现阶段主要应用于互联网链接分析及金融股票市场中。(来自百度百科)

import matplotlib.pyplot as plt

from random import choice

class RandomWalk:

def __init__(self, num_points=5000):

self.num_points = num_points

# 从(0, 0)开始出发

self.x_values = [0]

self.y_values = [0]

def start_walk(self):

while len(self.x_values) self.num_points:

x_direction = choice([-1, 1])

x_distance = choice([0, 1, 2])

x_walk = x_direction * x_distance

y_direction = choice([1, -1])

y_distance = choice([0, 10, 20])

y_walk = y_direction * y_distance

# 拒绝原地不动

if x_walk == 0 and y_walk == 0:

continue

# 计算下一个点的x和y值

next_x = self.x_values[-1] + x_walk # 从x_values的倒数第一个开始加上x方向走的距离

next_y = self.y_values[-1] + y_walk # 从y_values的倒数第一个开始加上y方向走的距离

self.x_values.append(next_x)

self.y_values.append(next_y)

randomwalk = RandomWalk()

randomwalk.start_walk()

plt.scatter(randomwalk.x_values, randomwalk.y_values, s=5)

plt.show()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

?

随机漫步渐变色

randomwalk = RandomWalk()

randomwalk.start_walk()

point_numbers = list(range(randomwalk.num_points))

plt.scatter(randomwalk.x_values, randomwalk.y_values, c=point_numbers, cmap=plt.cm.Reds, edgecolor='none', s=5)

plt.show()

1

2

3

4

5

6

7

1

2

3

4

5

6

7

?

小知识点

绘制起点和终点

randomwalk = RandomWalk()

randomwalk.start_walk()

point_numbers = list(range(randomwalk.num_points))

plt.scatter(randomwalk.x_values, randomwalk.y_values, c=point_numbers, cmap=plt.cm.Reds, edgecolor='none', s=5)

# 绘制起点和终点

plt.scatter(0, 0, c='green', edgecolors='none', s=100)

plt.scatter(randomwalk.x_values[-1], randomwalk.y_values[-1], c='red', edgecolors='none', s=100)

plt.show()

1

2

3

4

5

6

7

8

9

10

11

1

2

3

4

5

6

7

8

9

10

11

?

画布尺寸

plt.figure(dpi=128, figsize=(10, 6))

单位为英寸；函数figure()用于指定图表的宽度、高度、分辨率和背景色。

dpi: 传递分辨率

隐藏坐标轴

plt.axes().get_xaxis().set_visible(False)

plt.axes().get_yaxis().set_visible(False)

pygal

roll one dice

from random import randint

import pygal

class Die:

def __init__(self, num_sides=6):

self.num_sides = num_sides

def roll(self):

return randint(1, self.num_sides)

die = Die()

results = []

# 掷100次骰子

for roll_num in range(100):

result = die.roll()

results.append(result)

frequencies = []

for value in range(1, die.num_sides + 1):

frequency = results.count(value)

frequencies.append(frequency)

horizontal_bar_chart = pygal.Bar()

horizontal_bar_chart.title = "randomly roll a 6-side die"

horizontal_bar_chart.x_labels = ['1', '2', '3', '4', '5', '6']

horizontal_bar_chart.x_title = "Result"

horizontal_bar_chart.y_title = "Frequency"

horizontal_bar_chart.add('6side', frequencies)

horizontal_bar_chart.render_to_file('die_visual.svg')

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35