Как ведут себя параметры «c» и «cmap» на диаграмме рассеяния matplotlib?

Question

Для функции pyplot.scatter (x, y, s, c ....),

Документация matplotlib гласит:

c: цвет, последовательность или последовательность цветов, необязательно, по умолчанию: 'b' цвет маркера. Возможные значения:

Одна строка формата цвета. Последовательность цветовых характеристик длина п. Последовательность из n чисел для сопоставления с цветами с использованием cmap и норма. 2-D массив, в котором строки RGB или RGBA. Обратите внимание, что с не должно быть одной числовой последовательности RGB или RGBA, потому что это неотличим от массива значений, которые будут отображаться цветом. если ты хотите указать одинаковое значение RGB или RGBA для всех точек, используйте 2-D массив с одной строкой.

Однако я не понимаю, как я могу изменить цвета точек данных по своему желанию .

У меня есть этот кусок кода:

import matplotlib.pyplot as plt
import numpy as np
import sklearn
import sklearn.datasets
import sklearn.linear_model
import matplotlib


%matplotlib inline
matplotlib.rcParams['figure.figsize'] = (13.0, 9.0)

# Generate a dataset and plot it
np.random.seed(0)
X, y = sklearn.datasets.make_moons(200, noise=0.55)
print(y)
plt.scatter(X[:,0], X[:,1], c=y)#, cmap=plt.cm.Spectral)

выходной участок

Как я могу изменить цвета, чтобы предположить черные и зеленые точки данных, если я хочу? или что-то другое ? Также, пожалуйста, объясните, что делает cmap.

Почему мои графики пурпурно-синего цвета каждый раз, когда я использую plt.cm.Spectral?

Answer 1

Существуют два варианта раскраски точек рассеяния.

1. Внешнее картографирование

Вы можете внешне отобразить значения на цвет и предоставить список / массив этих цветов для аргумента scatter c.

z = np.array([1,0,1,0,1])
colors = np.array(["black", "green"])
plt.scatter(x,y, c=colors[z])

2. Внутреннее отображение

Помимо явных цветов, можно также предоставить список / массив значений, которые должны быть сопоставлены с цветами в соответствии с нормализацией и картой цветов.

• A colormap - это вызываемый объект, который принимает значения с плавающей запятой между 0. и 1. в качестве входных данных и возвращает цвет RGB.
• Нормализация - это вызываемый объект, который принимает любое число в качестве входного и выводит другое число, основываясь на некоторых ранее установленных пределах. Обычный случай Normalize обеспечил бы линейное отображение значений между vmin и vmax в диапазон между 0. и 1..

Естественный способ получить цвет по некоторым данным состоит в том, чтобы связать два,

cmap = plt.cm.Spectral
norm = plt.Normalize(vmin=4, vmax=5)
z = np.array([4,4,5,4,5])
plt.scatter(x,y, c = cmap(norm(z)))

Здесь значение 4 будет отображено на 0 путем нормализации, а значение 5 будет отображено на 1, так что карта цветов обеспечивает два крайних цвета.

Этот процесс происходит внутри scatter, если массиву числовых значений предоставляется c.

A scatter создает PathCollection, который подклассы ScalarMappable. ScalarMappable состоит из карты цветов, нормализации и массива значений. Следовательно, вышесказанное усваивается через

plt.scatter(x,y, c=z, norm=norm, cmap=cmap)

Если минимальные и максимальные данные должны использоваться в качестве пределов для нормализации, вы можете не указывать этот аргумент.

plt.scatter(x,y, c=z, cmap=cmap)

Это причина того, что выходные данные в вопросе всегда будут фиолетовыми и желтыми точками, независимо от значений, предоставленных для c.

Возвращаясь к требованию сопоставления массива 0 и 1 с черным и зеленым цветом, вы можете теперь взглянуть на цветовые карты, предоставляемые matplotlib и искать цветовую карту, которая содержит черный и зеленый. Например. nipy_spectral карта цветов

Здесь черный цвет находится в начале цветовой карты, а зеленый где-то посередине, скажем, в 0.5. Следовательно, необходимо установить vmin в 0 и vmax, так что vmax*0.5 = 1 (с 1 значением, которое будет отображено на зеленый), т.е. vmax = 1./0.5 == 2.

import matplotlib.pyplot as plt
import numpy as np
x,y = np.random.rand(2,6)
z = np.array([0,0,1,1,0,1])

plt.scatter(x,y, c = z, 
            norm = plt.Normalize(vmin=0, vmax=2),
            cmap = "nipy_spectral")

plt.show()

Поскольку не всегда может быть цветовая карта с доступными желаемыми цветами и поскольку может быть непросто получить положения цветов из существующих цветовых карт, альтернативой является создание новых цветовых карт специально для желаемой цели.

Здесь мы могли бы просто создать цветовую карту из двух цветов: черного и зеленого.

matplotlib.colors.ListedColormap(["black", "green"])

Здесь нам не нужна никакая нормализация, потому что у нас есть только два значения и, следовательно, мы можем полагаться на автоматическую нормализацию.

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
x,y = np.random.rand(2,6)
z = np.array([0,0,1,1,0,1])

plt.scatter(x,y, c = z, cmap = mcolors.ListedColormap(["black", "green"]))

plt.show()

Answer 2

Сначала, чтобы установить цвета в соответствии со значениями в y, вы можете сделать это:

color = ['red' if i==0  else 'green' for i in y]
plt.scatter(X[:,0], X[:,1], c=color)

Теперь говорим о scatter() и cmap.

ColorMaps используются для предоставления цветов из значений с плавающей точкой. См. эту документацию для справки по цветным картам .

Для значений от 0 до 1 цвет выбирается из этих цветовых карт.

Например:

plt.cm.Spectral(0.0)
# (0.6196078431372549, 0.00392156862745098, 0.25882352941176473, 1.0) #<== magenta

plt.cm.Spectral(1.0)
# (0.3686274509803922, 0.30980392156862746, 0.6352941176470588, 1.0) #<== blue

plt.cm.Spectral(1)
# (0.6280661284121491, 0.013302575932333718, 0.26082276047673975, 1.0)

Обратите внимание, что результаты 1.0 и 1 отличаются в приведенном выше коде, поскольку int и float обрабатываются по-разному, как указано в документации __call__() здесь :

Для значений с плавающей запятой X должен быть в интервале [0.0, 1.0], чтобы вернуть Значения RGBA X*100 процентов по линии Colormap.

Для целых чисел X должен быть в интервале [0, Colormap.N) до вернуть значения RGBA , индексированные из Colormap с индексом X.

Пожалуйста, посмотрите на этот ответ для более подробного объяснения цветовых карт: -

• https://stackoverflow.com/a/25408562/3374996

В вашем y у вас есть 0 и 1, поэтому используются значения RGBA, показанные в приведенном выше коде (которые представляют два конца цветовой карты Spectral).

Теперь вот как c и cmap параметры в plt.scatter() взаимодействуют друг с другом.

 _______________________________________________________________________
|No | type of x, y |  c type  | values in c |       result              |
|___|______________|__________|_____________|___________________________|
|1  |   single     |  scalar  |   numbers   | cmap(0.0), no matter      |
|   |    point     |          |             |  what the value in c      |
|___|______________|__________|_____________|___________________________|
|2  |   array of   |  array   |   numbers   | normalize the values in c,|                
|   |    points    |          |             | cmap(normalized val in c) |
|___|______________|__________|_____________|___________________________|
|3  | scalar or    | scalar or| RGBA Values,|  no use of cmap,          |
|   |  array       |  array   |Color Strings|  use colors from c        |
|___|______________|__________|_____________|___________________________|

Теперь, как только фактические цвета будут определены, циклически перебирайте цвета для каждой точки в x, y. Если размер x, y равен или меньше размера цветов в c, тогда вы получите идеальное отображение, иначе цвета более старых используются снова.

Вот пример, иллюстрирующий это:

# Case 1 from above table

# All three points get the same color = plt.cm.Spectral(0)
plt.scatter(x=0.0, y=0.2, c=0, cmap=plt.cm.Spectral)
plt.scatter(x=0.0, y=0.3, c=1, cmap=plt.cm.Spectral)
plt.scatter(x=0.0, y=0.4, c=1.0, cmap=plt.cm.Spectral)

# Case 2 from above table

# The values in c are normalized 
# highest value in c gets plt.cm.Spectral(1.0)
# lowest value in c gets plt.cm.Spectral(0.0)
# Others in between as per normalizing
# Size of arrays in x, y, and c must match here, else error is thrown
plt.scatter([0.1, 0.1, 0.1, 0.1, 0.1], [0.2, 0.3, 0.4, 0.5, 0.6], 
            c=[1, 2, 3, 4, 5], cmap=plt.cm.Spectral)


# Case 3 from above table => No use of cmap here,
#  blue is assigned to the point
plt.scatter(x=0.2, y=0.3, c='b')

# You can also provide rgba tuple
plt.scatter(x=0.2, y=0.4, c=plt.cm.Spectral(0.0))

# Since a single point is present, the first color (green) is given
plt.scatter(x=0.2, y=0.5, c=['g', 'r'])

# Same color 'cyan' is assigned to all values
plt.scatter([0.3, 0.3, 0.3, 0.3, 0.3], [0.2, 0.3, 0.4, 0.5, 0.6], 
            c='c')

# Colors are cycled through points
# 4th point will get again first color
plt.scatter([0.4, 0.4, 0.4, 0.4, 0.4], [0.2, 0.3, 0.4, 0.5, 0.6], 
            c=['m', 'y', 'k'])

# Same way for rgba values
# Third point will get first color again
plt.scatter([0.5, 0.5, 0.5, 0.5, 0.5], [0.2, 0.3, 0.4, 0.5, 0.6], 
            c=[plt.cm.Spectral(0.0), plt.cm.Spectral(1.0)])

Выход:

Просмотрите комментарии в коде и расположении точек вместе с цветами, чтобы понять полностью.

Вы также можете заменить параметр c на color в коде варианта 3, и результаты останутся такими же.