Въведение в Machine Learning

Целите днес:

  • Да си подкараме jupyter, scikit-learn и всичко останало
  • Вид на входните данни
  • Видове machine learning: (supervised и unsupervised)
  • Няколко алгоритъма отгоре-отгоре

Нужните технологии

Трябват ви jupyter, scikit-learn и няколко други технологии. Имате два начина да ги подкарате:

Ние предпочитаме първия подход, понеже сме относително уверени в Python и ни е по-прозрачно така. Бихме ви предложили да направите същото. Разбира се, може да пробвате и Anaconda. Няма голямо значение кое от двете ще изберете, стига да ви е комфортно.

pip install

За да начало са ви нужни следните неща:

pip install numpy scipy matplotlib ipython scikit-learn pandas pillow mglearn jupyter

Конкретно:

  • numpy, scipy – библиотеки за "работа с числа"
  • matplotlib, pillow – чертане на графики
  • scikit-learn – machine learning, тук се случва магията
  • ipython – по-шантава интерактивна конзола
  • jupyter – система за notebooks за Python (и други)
  • pandas – библиотека за анализ на данни
  • mglearn – библиотеката на Machine Learning with Python, има полезни функции за чертане

Веднъж като сте качили всичко това, просто изпълнете в терминала:

jupyter notebook

Това ще ви отвори браузър, където може да започнете работа.

Anaconda

Идете на сайта и си го изтеглете. Нататък сте вие самите.

https://anaconda.org/

Jupyter

За начало, нека разгледаме Jupyter.

  • Интерактивна среда в notebook формат
  • Позволява ви да изпълнявате код и да чертаете диаграми на едно място
  • Експериментално ще го ползваме за слайдове и материали (като тази лекция, например)

Demo!

Jupyter е интерактивна среда, която ви позволява да изпълявате код и да чертаете диаграми в notebook формат. Тя е много подходяща за експериментиране с модели. Допълнително, може да споделите изследванията с някой като му пратите готов notebook. Например, тази лекция е един голям jupyter notebook, който ползваме едновремено за примери и слайдове. Части от нея (като този параграф) няма да бъдат достъпни в слайдовете, но ще може да разгледате впоследствие.

Python

Python е относително прост език за програмиране. Ще ви го разкажем в по-късна лекция – засега примерите ще бъдат частично разбираеми, частично черна магия. Не се притеснявайте ако нещо не ви е ясно. Избрали сме го, защото той има най-добрите библиотеки за machine learning. Авторите на тези библиотеки пък са го избрали, защото е много лесен за научаване.

Стефан го мрази със страст. Може да го разпитате в някое междучасие. Нека това да не ви обезсърчава – обективно погледнато е добър език, особено за този тип проблеми.

Долното парче код ще ви е нужно в повечето jupyter notebooks

In [1]:
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import mglearn
from IPython.display import display

%matplotlib notebook

Machine Learning

Проблемите, подходящи за "машинно самообучение", имат следните качества:

  • Големи масиви от данни
  • "Нагаждаме" различни алгоритми към проблема, докато постигнем резултат
  • Тренираме модел, който ни позволява да отговорим на въпроси за нови данни
  • Rule of thumb: ако човек може да реши проблема за около 2 секунди, вероятно може да направим ML решение

Някои интересности:

  • Повече данни могат да ни помогнат да постигнем по-добър резлутат (до един момент)
  • При коренно различни данни може да се наложи да ползваме друг алгоритъм
  • Всичко е проба и грешка – трябва да пробваме различни алгоритми и да разбираме какво се случва
  • Има много пинизи и дребни детайли

Математика

Каква математика ще ви е нужна? Кратката версия:

$$ y = ax + b $$

(където $y$ и $b$ са вектори, а $a$ и $x$ са матрици)

Дългата версия е по-сложна.

Малко по-детайлно:

Задължително ще ви трябва да разбирате от поне малко линейна алгебра. Като начало, трябва да разбирате от умножение на матрици и да ви е относително комфортно да го правите. Това е едно добро начало.

В подробности – всеки алгоритъм си има особеностите и математиката, свързана с него. Линейната регресия е напълно разбираема с познания от първи семестър, първи курс. Други алгоритмни като Support Vector Machines или Principal Component Analysis са по-сложни и искат повече познания. На практика, може да стигнете доста далеч с повърхностно разбиране на тези алгоритми. На теория, колкото повече математика знаете, толкова по-добре ще се оправите.

За целите на курса ще се нуждаем единствено от уравнението по-горе.

Входни данни

Обикновено работим с таблица от входни данни:

  • Всеки ред е определена инстанция (например различен човек)
  • Всяка колона е характерискита на този човек (възраст, брой деца, т.н.)
  • Характеристиките още се наричат (на чист български) feature-и
  • Опционално към всеки ред може да има отговор на въпроса, за който правим модел (още се нарича label)
  • Засега нека приемем, че клетки съдържат числа (текста може да се сведе до много feature-и)
  • Обикновено разглеждаме данните като матрица $X$, а етикетите (label-ите) като вектор $y$
Възраст Коли Къща Деца Женен? Куче? Купува лодка?
66 1 да 2 вдовец не да
52 2 не 3 женен не да
22 0 не 0 женен да не
25 1 не 1 неженен не не
44 0 не 2 разведен не не
39 1 да 2 женен да не
26 1 не 2 неженен не не
40 3 да 1 женен да не
53 2 да 2 разведен не да
64 2 да 3 разведен не да
58 2 да 2 женен да да
33 1 не 1 неженен не не

На първите 6 колони от предната таблица може да гледате като матрицата $X$, докато на последната колона като вектора $y$.

Булевите данни могат да се кодират като числата 0 и 1, а енумерациите (женен?) като серия от числа. Различни репрезентации може да са подходящи за различни алгоритми.

Конвенцията $X$ и $y$ ще се ползва постоянно, така че е добре да свикнете с нея. Когато се опитваме да отговаряме на въпроси (тези хора биха ли си купили лодка?), ще подаваме хората като матрица $X$ и ще очакваме да получим вектор $y$, където всеки елемент от вектора ще съдържа отговор дали този човек би си купил лодка.

Работата с текст обикновено се свежда до извличане на скаларни feature-и от данните (например колоните могат да съответстват на уникални думи в документа, докато клетките – на брой срещания). Това е по-дълбока вода, която ще покрием по-натам.

Примерни набори от данни

scikit-learn предлага няколко набора от примерни данни с които може да работите.

  • boston
  • iris
  • diabetes
  • digits
  • linnerud
  • wine
  • breast_cancer

Всички те могат да се ползват за прости експерименти и илюстрация на моделите. Дори ще ползваме някои.

Ако искате да ползвате определен dataset:

In [2]:
from sklearn.datasets import load_boston
boston = load_boston()
print(boston.data.shape)
(506, 13)

boston demo

Ето описание на boston dataset-а:

In [3]:
print(boston.DESCR)
Boston House Prices dataset
===========================

Notes
------
Data Set Characteristics:  

    :Number of Instances: 506 

    :Number of Attributes: 13 numeric/categorical predictive
    
    :Median Value (attribute 14) is usually the target

    :Attribute Information (in order):
        - CRIM     per capita crime rate by town
        - ZN       proportion of residential land zoned for lots over 25,000 sq.ft.
        - INDUS    proportion of non-retail business acres per town
        - CHAS     Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)
        - NOX      nitric oxides concentration (parts per 10 million)
        - RM       average number of rooms per dwelling
        - AGE      proportion of owner-occupied units built prior to 1940
        - DIS      weighted distances to five Boston employment centres
        - RAD      index of accessibility to radial highways
        - TAX      full-value property-tax rate per $10,000
        - PTRATIO  pupil-teacher ratio by town
        - B        1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town
        - LSTAT    % lower status of the population
        - MEDV     Median value of owner-occupied homes in $1000's

    :Missing Attribute Values: None

    :Creator: Harrison, D. and Rubinfeld, D.L.

This is a copy of UCI ML housing dataset.
http://archive.ics.uci.edu/ml/datasets/Housing


This dataset was taken from the StatLib library which is maintained at Carnegie Mellon University.

The Boston house-price data of Harrison, D. and Rubinfeld, D.L. 'Hedonic
prices and the demand for clean air', J. Environ. Economics & Management,
vol.5, 81-102, 1978.   Used in Belsley, Kuh & Welsch, 'Regression diagnostics
...', Wiley, 1980.   N.B. Various transformations are used in the table on
pages 244-261 of the latter.

The Boston house-price data has been used in many machine learning papers that address regression
problems.   
     
**References**

   - Belsley, Kuh & Welsch, 'Regression diagnostics: Identifying Influential Data and Sources of Collinearity', Wiley, 1980. 244-261.
   - Quinlan,R. (1993). Combining Instance-Based and Model-Based Learning. In Proceedings on the Tenth International Conference of Machine Learning, 236-243, University of Massachusetts, Amherst. Morgan Kaufmann.
   - many more! (see http://archive.ics.uci.edu/ml/datasets/Housing)

Данните са в boston.data, имената на feature-ите са в boston.feature_names (съответстват не тези кратки съкращения по-горе), а очакваната цел е в boston.target.

In [4]:
boston.data
Out[4]:
array([[  6.32000000e-03,   1.80000000e+01,   2.31000000e+00, ...,
          1.53000000e+01,   3.96900000e+02,   4.98000000e+00],
       [  2.73100000e-02,   0.00000000e+00,   7.07000000e+00, ...,
          1.78000000e+01,   3.96900000e+02,   9.14000000e+00],
       [  2.72900000e-02,   0.00000000e+00,   7.07000000e+00, ...,
          1.78000000e+01,   3.92830000e+02,   4.03000000e+00],
       ..., 
       [  6.07600000e-02,   0.00000000e+00,   1.19300000e+01, ...,
          2.10000000e+01,   3.96900000e+02,   5.64000000e+00],
       [  1.09590000e-01,   0.00000000e+00,   1.19300000e+01, ...,
          2.10000000e+01,   3.93450000e+02,   6.48000000e+00],
       [  4.74100000e-02,   0.00000000e+00,   1.19300000e+01, ...,
          2.10000000e+01,   3.96900000e+02,   7.88000000e+00]])
In [5]:
boston.feature_names
Out[5]:
array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD',
       'TAX', 'PTRATIO', 'B', 'LSTAT'], 
      dtype='<U7')
In [6]:
boston.target
Out[6]:
array([ 24. ,  21.6,  34.7,  33.4,  36.2,  28.7,  22.9,  27.1,  16.5,
        18.9,  15. ,  18.9,  21.7,  20.4,  18.2,  19.9,  23.1,  17.5,
        20.2,  18.2,  13.6,  19.6,  15.2,  14.5,  15.6,  13.9,  16.6,
        14.8,  18.4,  21. ,  12.7,  14.5,  13.2,  13.1,  13.5,  18.9,
        20. ,  21. ,  24.7,  30.8,  34.9,  26.6,  25.3,  24.7,  21.2,
        19.3,  20. ,  16.6,  14.4,  19.4,  19.7,  20.5,  25. ,  23.4,
        18.9,  35.4,  24.7,  31.6,  23.3,  19.6,  18.7,  16. ,  22.2,
        25. ,  33. ,  23.5,  19.4,  22. ,  17.4,  20.9,  24.2,  21.7,
        22.8,  23.4,  24.1,  21.4,  20. ,  20.8,  21.2,  20.3,  28. ,
        23.9,  24.8,  22.9,  23.9,  26.6,  22.5,  22.2,  23.6,  28.7,
        22.6,  22. ,  22.9,  25. ,  20.6,  28.4,  21.4,  38.7,  43.8,
        33.2,  27.5,  26.5,  18.6,  19.3,  20.1,  19.5,  19.5,  20.4,
        19.8,  19.4,  21.7,  22.8,  18.8,  18.7,  18.5,  18.3,  21.2,
        19.2,  20.4,  19.3,  22. ,  20.3,  20.5,  17.3,  18.8,  21.4,
        15.7,  16.2,  18. ,  14.3,  19.2,  19.6,  23. ,  18.4,  15.6,
        18.1,  17.4,  17.1,  13.3,  17.8,  14. ,  14.4,  13.4,  15.6,
        11.8,  13.8,  15.6,  14.6,  17.8,  15.4,  21.5,  19.6,  15.3,
        19.4,  17. ,  15.6,  13.1,  41.3,  24.3,  23.3,  27. ,  50. ,
        50. ,  50. ,  22.7,  25. ,  50. ,  23.8,  23.8,  22.3,  17.4,
        19.1,  23.1,  23.6,  22.6,  29.4,  23.2,  24.6,  29.9,  37.2,
        39.8,  36.2,  37.9,  32.5,  26.4,  29.6,  50. ,  32. ,  29.8,
        34.9,  37. ,  30.5,  36.4,  31.1,  29.1,  50. ,  33.3,  30.3,
        34.6,  34.9,  32.9,  24.1,  42.3,  48.5,  50. ,  22.6,  24.4,
        22.5,  24.4,  20. ,  21.7,  19.3,  22.4,  28.1,  23.7,  25. ,
        23.3,  28.7,  21.5,  23. ,  26.7,  21.7,  27.5,  30.1,  44.8,
        50. ,  37.6,  31.6,  46.7,  31.5,  24.3,  31.7,  41.7,  48.3,
        29. ,  24. ,  25.1,  31.5,  23.7,  23.3,  22. ,  20.1,  22.2,
        23.7,  17.6,  18.5,  24.3,  20.5,  24.5,  26.2,  24.4,  24.8,
        29.6,  42.8,  21.9,  20.9,  44. ,  50. ,  36. ,  30.1,  33.8,
        43.1,  48.8,  31. ,  36.5,  22.8,  30.7,  50. ,  43.5,  20.7,
        21.1,  25.2,  24.4,  35.2,  32.4,  32. ,  33.2,  33.1,  29.1,
        35.1,  45.4,  35.4,  46. ,  50. ,  32.2,  22. ,  20.1,  23.2,
        22.3,  24.8,  28.5,  37.3,  27.9,  23.9,  21.7,  28.6,  27.1,
        20.3,  22.5,  29. ,  24.8,  22. ,  26.4,  33.1,  36.1,  28.4,
        33.4,  28.2,  22.8,  20.3,  16.1,  22.1,  19.4,  21.6,  23.8,
        16.2,  17.8,  19.8,  23.1,  21. ,  23.8,  23.1,  20.4,  18.5,
        25. ,  24.6,  23. ,  22.2,  19.3,  22.6,  19.8,  17.1,  19.4,
        22.2,  20.7,  21.1,  19.5,  18.5,  20.6,  19. ,  18.7,  32.7,
        16.5,  23.9,  31.2,  17.5,  17.2,  23.1,  24.5,  26.6,  22.9,
        24.1,  18.6,  30.1,  18.2,  20.6,  17.8,  21.7,  22.7,  22.6,
        25. ,  19.9,  20.8,  16.8,  21.9,  27.5,  21.9,  23.1,  50. ,
        50. ,  50. ,  50. ,  50. ,  13.8,  13.8,  15. ,  13.9,  13.3,
        13.1,  10.2,  10.4,  10.9,  11.3,  12.3,   8.8,   7.2,  10.5,
         7.4,  10.2,  11.5,  15.1,  23.2,   9.7,  13.8,  12.7,  13.1,
        12.5,   8.5,   5. ,   6.3,   5.6,   7.2,  12.1,   8.3,   8.5,
         5. ,  11.9,  27.9,  17.2,  27.5,  15. ,  17.2,  17.9,  16.3,
         7. ,   7.2,   7.5,  10.4,   8.8,   8.4,  16.7,  14.2,  20.8,
        13.4,  11.7,   8.3,  10.2,  10.9,  11. ,   9.5,  14.5,  14.1,
        16.1,  14.3,  11.7,  13.4,   9.6,   8.7,   8.4,  12.8,  10.5,
        17.1,  18.4,  15.4,  10.8,  11.8,  14.9,  12.6,  14.1,  13. ,
        13.4,  15.2,  16.1,  17.8,  14.9,  14.1,  12.7,  13.5,  14.9,
        20. ,  16.4,  17.7,  19.5,  20.2,  21.4,  19.9,  19. ,  19.1,
        19.1,  20.1,  19.9,  19.6,  23.2,  29.8,  13.8,  13.3,  16.7,
        12. ,  14.6,  21.4,  23. ,  23.7,  25. ,  21.8,  20.6,  21.2,
        19.1,  20.6,  15.2,   7. ,   8.1,  13.6,  20.1,  21.8,  24.5,
        23.1,  19.7,  18.3,  21.2,  17.5,  16.8,  22.4,  20.6,  23.9,
        22. ,  11.9])

Обърнете внимание, че това не са Python масиви, ами NumPy вектори и матрици.

Синтетични набори от данни

scikit-learn предлага и някои синтетични набори от данни. Понякога и те са интересни.

Любопитен пример е make_moons, който прави два полумесеца.

In [7]:
from sklearn.datasets import make_moons

X, y = make_moons(n_samples=100, noise=0.25, random_state=3)

plt.close()
mglearn.discrete_scatter(X[:, 0], X[:, 1], y)

None

Този dataset е по-лесно разбираем.

In [8]:
X
Out[8]:
array([[ 1.87756309,  0.56839425],
       [ 0.36877983, -0.34894509],
       [ 0.96515318,  0.10921819],
       [ 0.48599685,  0.20291313],
       [ 1.72532644,  0.53367598],
       [ 1.47976586,  0.08726406],
       [ 2.11889248,  0.60498388],
       [-0.74017805,  0.49615542],
       [-0.38099245,  1.34740194],
       [ 0.22944941,  0.87981305],
       [ 1.31311917, -0.69665985],
       [ 0.87435391,  0.83750547],
       [ 0.77145295, -0.69709227],
       [ 1.26285558,  0.12916271],
       [-0.71988634,  0.69106791],
       [ 0.79205253, -0.40516241],
       [ 1.31886119, -0.41396289],
       [ 0.26579093,  0.78151982],
       [ 0.08686038,  0.49400243],
       [-0.74872343, -0.06972957],
       [ 0.88404174, -0.35425773],
       [ 1.02671711,  0.73292915],
       [ 0.73867317,  0.30808589],
       [ 1.12856036,  0.33191968],
       [ 1.15536561, -0.50593577],
       [ 1.56825139, -0.05911358],
       [ 0.29004812,  1.00820293],
       [ 0.64076308, -0.19860992],
       [-1.20034998,  0.46412528],
       [-0.16955317,  0.60660877],
       [-0.53369875,  0.50244086],
       [ 1.00549331,  0.38686701],
       [ 0.65294065,  0.80929512],
       [-0.56688607,  0.73004641],
       [ 1.71942343,  0.32909081],
       [ 0.96514959,  0.51823046],
       [ 0.2683596 , -0.11030872],
       [ 1.50917461, -0.06701048],
       [-0.59385445,  0.46769065],
       [-1.06471178,  0.5676387 ],
       [ 0.55039452,  1.16554689],
       [-0.33860634,  1.17004822],
       [-0.51699811,  0.74457804],
       [-0.46333991,  0.86330772],
       [ 1.68539175,  0.33403724],
       [ 1.53286262, -0.03063104],
       [ 1.22313197, -0.36876898],
       [ 0.91466466, -0.50411496],
       [ 0.56006165, -0.16514053],
       [-1.18053783,  0.20934501],
       [-0.04686928, -0.01567029],
       [ 1.38450053, -0.47647261],
       [ 0.97370054, -0.08631168],
       [-0.02909233, -0.0555109 ],
       [ 0.62049137,  0.75230462],
       [ 1.76359619, -0.12578512],
       [ 0.06669088, -0.33949903],
       [ 1.65838571,  0.21114881],
       [ 0.29244317,  0.40428146],
       [ 0.48329861,  0.35840485],
       [-0.35030318,  0.94421706],
       [-0.4993884 ,  0.13192906],
       [ 1.31702684, -0.2525239 ],
       [ 1.96337107, -0.23820389],
       [-1.1471254 , -0.38663896],
       [ 1.68640884, -0.13364054],
       [-0.60690411,  0.50000529],
       [-0.50082297,  0.3628348 ],
       [-0.54220197,  0.72334582],
       [-1.00731293,  0.4130496 ],
       [ 0.89631194,  0.55476594],
       [ 0.47389194,  0.14587816],
       [ 2.2868162 ,  0.47244271],
       [-0.18746498,  0.86188606],
       [ 0.50782987,  0.03923829],
       [-0.11290693,  0.93361423],
       [ 0.91068654,  0.12727649],
       [ 0.47093877, -0.09213003],
       [ 0.42598043, -0.3006242 ],
       [ 0.8729088 ,  0.08643291],
       [ 0.31917808,  0.05270298],
       [ 0.11767524,  1.41784908],
       [ 0.73350617, -0.40980742],
       [ 0.04446489,  0.9219238 ],
       [ 0.89715307,  0.94175457],
       [-0.87006365,  0.70686285],
       [-0.24608615,  0.378107  ],
       [ 0.35940317,  0.84867003],
       [-0.7280717 ,  0.3259131 ],
       [ 1.89948318,  0.79928869],
       [ 1.06821751,  0.75846569],
       [-0.59533829,  0.9611563 ],
       [ 1.11634545,  0.01823342],
       [ 0.61281464,  0.9800983 ],
       [ 0.65239007,  0.38512423],
       [ 0.85716276,  0.06644676],
       [ 0.61237738, -0.52619638],
       [-0.08661448, -0.03887081],
       [ 1.65954074,  0.3480271 ],
       [ 0.01856462,  1.32827802]])
In [9]:
y
Out[9]:
array([1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0,
       0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
       1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0,
       0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
       1, 0, 0, 0, 1, 1, 0, 0])

Впрочем, ето невронна мрежа, която разпознава граница между двата класа:

In [10]:
from sklearn.neural_network import MLPClassifier
plt.close()

mlp = MLPClassifier(solver='lbfgs', random_state=0).fit(X, y)
mglearn.plots.plot_2d_separator(mlp, X, fill=True, alpha=.3)
mglearn.discrete_scatter(X[:, 0], X[:, 1], y)
Out[10]:
[<matplotlib.lines.Line2D at 0x110dd5128>,
 <matplotlib.lines.Line2D at 0x110dd5f28>]

Горния код има няколко проблема, в които ще влезем по-натам. Засега просто искаме да ви покажем малко графики, не да разберем как работят невронните мрежи (което е дълъг и сложен въпрос).

Повече за sklearn.datasets

Повече информация за наборите от данни в scikit-learn може да намерите в документацията:

http://scikit-learn.org/stable/datasets/index.html

Supervised vs. unsupervised learning

Алгоритмите могат да се разделят на два видя:

  • Supervised learning – такива, които разполагат с labelled данни и генерализират (да отговарят на въпроси за нови данни)
  • Unsupervised learning – такива, които нямат label-и и трябва да открият статистически зависимости в данните

Supervised learning

Примери за supervised learning са:

  • При набор от данни с цени и параметри на апартаменти да определим колко би струвал друг апартамент с определени апартаменти.
  • При набор от данни за тумори да определим дали един е доброкачествен или злокачествен

Unsupervised learning

Тези алгоритми са по-разнородни и приложими в определени сфери. Например:

  • При набор от потребители и техните филмови рейтинги да създадем групи от видове предпочитания
  • При набор от многомерни данни данни да сведем броя измерения до по-малък такъв запазвайки повечето информация

Регресия vs. Класификация

Бихме могли да разделим supervised learning на два вида:

  • Регресия – опитваме се да сведем данните до непрекъсната стойност (цена на апартамент)
  • Класификация – опитваме се да определим данните дали попадат в една от две категории (доброкачествен или злокачествен тумор)

Стандартен подход за класификация с 3+ класа е one-vs-many – създаваме по един класификатор за всяка категория, прекарваме данните през тях и избираме най-вероятната.

Няколко алгоритъма

Сега ще разгледаме няколко алгоритъма отгоре-отгоре. Целта е да разберем как работят концептуално. Ще разгледаме всеки от тях в детайли в следващи лекции.

Disclaimer

Ще гледаме набори от данни с едно или две измерения. Те са доста лесни за визуализация, но рядко реалистични – обикновено работим със десетки, стотици или дори хиляди feature-а (т.е. измерения). Това е далеч по-трудно за визуализация, откъдето идва и голяма част от предизвикателството.

k-Nearest Neighbours (kNN)

Supervised, класификация

Възможно най-простия алгоритъм.

Запазва целия dataset. За да класифицира нов елемнт намира най-близкия (линейно, в евклидово пространство) до него и отговаря със същия клас:

In [11]:
mglearn.plots.plot_knn_classification(n_neighbors=1)

Предния пример гледаше 1 най-близък съсед. Може да се имплементира да гледа няколко:

In [12]:
mglearn.plots.plot_knn_classification(n_neighbors=3)

Броят съседи определя колко "гладка" е границата между двата класа. Ето един пример с различен брой съседи:

In [13]:
from sklearn.neighbors import KNeighborsClassifier

X, y = mglearn.datasets.make_forge()

fig, axes = plt.subplots(1, 3, figsize=(10, 3))

for n_neighbors, ax in zip([1, 3, 9], axes):
    clf = KNeighborsClassifier(n_neighbors=n_neighbors).fit(X, y)
    mglearn.plots.plot_2d_separator(clf, X, fill=True, eps=0.5, ax=ax, alpha=.4)
    mglearn.discrete_scatter(X[:, 0], X[:, 1], y, ax=ax)
    ax.set_title("{} neighbour(s)".format(n_neighbors))

Фонът в горната диаграма определя в кой от двата класа ще попадне дадена точка. Обърнете внимание, че при k=1 границата е начупена и хваща всеки елемент. При по-голямо k границата става по-плавна, макар и да класифицира някои елементи грешно. Това може да е предимство (ще игнорира аномалии в данните). Ще видим вариации на тази тема по-натам с нормализация в линейните модели.

Linear Regression

Supervised, регресия

Най-популярния модел. Опитва се да намери линейна функция, който приближава данните. С обработка на feature-ите може да намира и нелинейни функци, но това следващия път.

In [15]:
mglearn.plots.plot_linear_regression_wave()
w[0]: 0.393906  b: -0.031804