In [ ]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from random import randint
import seaborn

%pylab inline

Чтобы обучать алгоритмы, нужно иметь данные. Посмотрим, как можно считать данные. Допустим, данные хранятся в формате csv. Тогда считать их можно следующим образом:

In [2]:
X_train = pd.read_csv("X_train.csv", header=0)

Параметр header указывает, какую из стро считать, как имена столбцов. Если имён нет, то header=None

Можно просмотреть маленькую часть таблицы:

In [3]:
X_train.head()
Out[3]:
x y
0 -13 -13
1 -571 -571
2 922 922
3 314 314
4 685 685

Его тип:

In [4]:
print type(X_train)

<class 'pandas.core.frame.DataFrame'>
In [5]:
y_train = pd.read_csv("y_train.csv", header=0)
In [6]:
y_train.head()
Out[6]:
ans
0 -1
1 -1
2 1
3 1
4 1

Заметим, что данные X_train --- это двумерный список (двумерный массив, матрица). Для удобной работы с матрицами есть модуль numpy. Вот так данные переводятся в формат numpy.array:

In [7]:
X_train = np.array(X_train)
print type(X_train)
print X_train.shape # узнать форму объекта

<type 'numpy.ndarray'>
(1000, 2)
In [8]:
y_train = np.array(y_train)
print y_train.shape

(1000, 1)

Немного о numpy, а именно, что можно делать с типом np.array:

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

In [9]:
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b)
print(a - b)
print(a * b)
print(a / b) # целочисленное деление
print(a * 1.0 / b) # вещественное деление
print(a ** b)

[5 7 9]
[-3 -3 -3]
[ 4 10 18]
[0 0 0]
[ 0.25  0.4   0.5 ]
[  1  32 729]

Точно так же это работает и с двумерными и вообще любыми np.array любой формы (главное, чтобы форма была одинаковой):

In [10]:
a = np.array([[1, 2, 3], [0, 1, 0]])
b = np.array([[4, 5, 6], [3, 1, 2]])
print a
print b
print a + b
print a - b
print a * b
print a / b # целочисленное деление
print a * 1.0 / b # вещественное деление
print a ** b

[[1 2 3]
 [0 1 0]]
[[4 5 6]
 [3 1 2]]
[[5 7 9]
 [3 2 2]]
[[-3 -3 -3]
 [-3  0 -2]]
[[ 4 10 18]
 [ 0  1  0]]
[[0 0 0]
 [0 1 0]]
[[ 0.25  0.4   0.5 ]
 [ 0.    1.    0.  ]]
[[  1  32 729]
 [  0   1   0]]
In [11]:
a = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(a)

[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]

Можно также менять форму. Главное, чтобы произведение измерений было одинаково (иными словами, кол-во элементов постоянно):

In [12]:
a = np.array([[1, 2, 4], [5, 6, 7]])
print a.shape 
print a 
a = a.reshape((3, 2)) # 3 строки, 2 столбца
print a.shape
print a

(2, 3)
[[1 2 4]
 [5 6 7]]
(3, 2)
[[1 2]
 [4 5]
 [6 7]]

Выпрямить можно двумя способами:

In [13]:
a = np.array([[1, 2, 4], [5, 6, 7]])
print a.reshape((1, -1)) # означает, сделать одну строчку, а столбцов столько, сколкьо осталось
print a.reshape((-1,)) # все развернуть в одну строку
print a.ravel()
print a.ravel().shape

[[1 2 4 5 6 7]]
[1 2 4 5 6 7]
[1 2 4 5 6 7]
(6,)

Можно индексироваться, причем не совсем привычным способом:

In [14]:
a = np.array([3, 4, 5, 6]) # для одномерных массивов все привычным способом
print a.shape
print a[0]
print a[1:4]
print a[2:]

(4,)
3
[4 5 6]
[5 6]
In [15]:
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print a.shape
print a[0] # вывести нулевую строчку
print a[0][0] # вывести элемент [0][0]
# но правильнее писать так:
print a[0, 0] # сколько измерений - 1 = столько запятых
print a[:, :] # вывести все
print a[:, 0] # вывести нулевой столбец. иными словами, взять все строчки и пересечь с нулевым столбцом
print a[:2, :2] # вывести верхний угол размера 2 на 2
print a[0, :] # = print a[0]

(3, 3)
[1 2 3]
1
1
[[1 2 3]
 [4 5 6]
 [7 8 9]]
[1 4 7]
[[1 2]
 [4 5]]
[1 2 3]

Теперь перейдем к рисованию графиков:

In [16]:
plt.figure() # cоздает поле. можно задачть размер в параметрах: figsize=(3, 4)
plt.plot([0, 1, 2, 3, 4, 5, 6, 3], [0, 8, 1, 5, 3, 7, 2, 3])
plt.show()

plot дорисовывает линии графика сам

Можно также задавать свои параметры (более подробную информацию можно найти с помощью help(plt.plot)):

In [17]:
plt.figure(figsize=(30, 10))
Lx = [2, 3, 4, 5, 6, 7, 8, 9, 10]
Ly = [0, 2, 4, 6, 8, 6, 4, 2, 0]
Kx = [14, 14, 14, 15, 16, 17, 18, 17, 16, 15, 14, 15, 16, 17, 18, 17, 16, 15, 14, 14, 14]
Ky = [0, 2, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 6, 8]
Shx = [22] * 9 + [23, 24, 25] + [26] * 9 + [27, 28, 29] + [30] * 9
Shy = [0, 2, 4, 6, 8, 6, 4, 2, 0] + [0] * 3 + [0, 2, 4, 6, 8, 6, 4, 2, 0] + [0] * 3 + [0, 2, 4, 6, 8, 6, 4, 2, 0]
plt.plot(Lx, Ly, color="r", linestyle="--", linewidth=2, 
         marker="*", markerfacecolor="b", markersize=12, label="graph 1")
plt.plot(Kx, Ky, color="r", linestyle="--", linewidth=2, 
         marker="*", markerfacecolor="b", markersize=12, label="graph 2")
plt.plot(Shx, Shy, color="r", linestyle="--", linewidth=2, 
         marker="*", markerfacecolor="b", markersize=12, label="graph 3")
plt.xlim(0, 50)
plt.ylim(-2, 10)
plt.legend()
plt.show()

scatter рисует наборы точек, умеет их раскрашивать в разные цвета, менять размеры:

In [18]:
x = np.array([1, 7, 3, 9, 3, 9, 2, 5, 2, 7, 3, 9, 3])
y = np.array([5, 8, 2, 9, 2, 0, 1, 7, 2, 8, 2, 8, 3])
plt.figure()
plt.scatter(x, y)
plt.show()
In [19]:
x = np.array([1, 7, 3, 9, 3, 9, 2, 5, 2, 7, 3, 9, 3])
y = np.array([5, 8, 2, 9, 2, 0, 1, 7, 2, 8, 2, 8, 3])
plt.figure()
plt.scatter(x, y, s=100, c="r", marker="^", alpha=0.7)
plt.show()
In [20]:
x = np.array([randint(0, 100) for i in xrange(200)])
y = np.array([randint(0, 100) for i in xrange(200)])
sizes = x ** 2 + y ** 2
cm = plt.get_cmap('jet')
colors = map(lambda c: cm(1.0 * c / max(sizes)), sizes)
plt.figure(figsize=(10, 10))
plt.scatter(x, y, s=sizes, c=colors, marker="o", alpha=0.7)

sizes = np.sqrt(sizes)
cm = plt.get_cmap('cubehelix')
colors = map(lambda c: cm(1 - 1.0 * c / max(sizes)), sizes)
plt.scatter(x, y, s=sizes, c=colors, marker="o", alpha=0.7)
Out[20]:
<matplotlib.collections.PathCollection at 0x7f1c1df73910>
In [21]:
x = np.array([randint(0, 100) for i in xrange(200)])
y = np.array([randint(0, 100) for i in xrange(200)])
sizes = x ** 2 + y ** 2
cm = plt.get_cmap('gist_earth')
colors = map(lambda c: cm(1.0 * c / max(sizes)), sizes)
plt.figure(figsize=(10, 10))
plt.scatter(x, y, s=sizes, c=colors, marker="*", alpha=0.7)

sizes = 3 * np.sqrt(sizes)
cm = plt.get_cmap('cubehelix')
colors = map(lambda c: cm(1 - 1.0 * c / max(sizes)), sizes)
plt.scatter(x, y, s=sizes, c=colors, marker="*", alpha=0.7)
Out[21]:
<matplotlib.collections.PathCollection at 0x7f1c1dd9de90>

Так можно строить bar plot:

In [22]:
x = [1, 2, 3, 4, 5]
y = [5, 1, 7, 4, 2]
plt.figure(figsize=(12, 5))
plt.bar(x, y, width=0.5, color=["r", "g", "b", "y", "m"], alpha=0.6, 
        tick_label=["red", "green", "blue", "yellow", "magenta"], align="center")
plt.xlim(0, 7) # задать пределы по координате x
plt.ylim(0, 10) # задать пределы по координате y
Out[22]:
(0, 10)

Теперь изобразим, как же выглядят те данные, которые мы считали в начале. У них две фичи, поэтому их можно изобразить на плоскости:

In [23]:
plt.figure(figsize=(10, 10))
plt.scatter(X_train[:, 0], X_train[:, 1])
Out[23]:
<matplotlib.collections.PathCollection at 0x7f1c1de312d0>

Посмотрим, сколько классов в y_train:

In [24]:
np.unique(y_train, return_counts=True)
Out[24]:
(array([-1,  1]), array([458, 542]))

Теперь раскрасим данные в соответвии с классами:

In [25]:
colors = ["r" if y == -1 else "g" for y in y_train]
plt.figure(figsize=(10, 10))
plt.scatter(X_train[:, 0], X_train[:, 1], color=colors)
Out[25]:
<matplotlib.collections.PathCollection at 0x7f1c1dcf6150>
In [26]:
X_test = pd.read_csv("X_test.csv", header=0)
X_test = np.array(X_test)

Теперь визуализируем тестовые данные:

In [27]:
plt.figure(figsize=(10, 10))
plt.scatter(X_test[:, 0], X_test[:, 1])
Out[27]:
<matplotlib.collections.PathCollection at 0x7f1c1db63790>

Предскажем цвет:

In [28]:
colors = ["r" if x[0] < 0 else "g" for x in X_test]
In [29]:
plt.figure(figsize=(10, 10))
plt.scatter(X_test[:, 0], X_test[:, 1], color=colors)
Out[29]:
<matplotlib.collections.PathCollection at 0x7f1c1c609a90>
In [ ]:
In [ ]:
In [ ]:
In [ ]: