Wczytujemy przykładowe zbiory danych

import numpy as np
from sklearn import datasets
iris = datasets.load_iris()
digits = datasets.load_digits()

print(iris.data.shape)
print(iris.target)
print(iris.target_names)

Podziel dane na zbiór uczący i testujący:

np.random.seed(0) # aby wyniki były powtarzalne
indices = np.random.permutation(len(iris.data))
print(indices)
train_X = iris.data[indices[:-10]]
train_Y = iris.target[indices[:-10]]
test_X = iris.data[indices[-10:]]
test_Y = iris.target[indices[-10:]]
print(len(train_X), len(test_X))

Uczymy klasyfikator:

# tworzymy klasyfikator
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier()
# uczymy na naszych danych
knn.fit(train_X, train_Y)

Używamy nauczony klasyfikator do predykcji na nowych danych

print('klasyfikacja:', knn.predict(test_X))
print('powinno byc :', test_Y)

Dane z cyframi:

# każemy rysować obrazki bezpośrednio w notebooku
%matplotlib inline
import matplotlib.pyplot as plt
plt.imshow(digits.images[0], cmap='gray', interpolation='nearest')

Tworzymy klasyfikator SVM:

from sklearn import svm
s = svm.SVC(gamma=0.001, C=100.)
s.fit(digits.data[:-20], digits.target[:-20])

print('klasyfikacja:', s.predict(digits.data[-20:]))
print('powinno byc :', digits.target[-20:])

Zadanie 1

Jak automatycznie policzyć liczbę pomyłek klasyfikatora? Napisz kod.

def liczba_pomylek(jest, powinno_byc):
    return # TODO

Zadanie 2

Sprawdź przy jakim rozmiarze zbioru uczącego (ilu początkowych rekordów z danych "digits") zaczną pojawiać się błędy na pozostałych danych ze zbioru. Napisz kod który automatycznie to sprawdzi.

Zadanie 3

Spróbuj nauczyć klasyfikator kNN na części z dostępnych atrybutów zbioru iris. Podziel losowo (jak wyżej) dane iris na zbiór uczący i testujący o tym samym rozmiarze. Następnie sprawdź dla której pary atrybutów uzyskasz najlepszy wynik klasyfikacji zbioru testowego. Sprawdź czy wniosek jest taki sam dla różnych podziałów na zbiory uczące i testujące (sprawdź np.random.seed(s) dla s = 0..9). Napisz kod który automatycznie to sprawdzi.

# wizualizacja danych - atrybut 0 na osi X, atrybut 1 na osi Y, kolor w zależności od klasy
plt.scatter(iris.data[:,0], iris.data[:,1], c=iris.target)

Zadanie 4

Zaimplementuj własny klasyfikator 1NN (kNN dla k=1) używający odległości euclidesowej. Sprawdź czy Twoja implementacja klasyfikatora daje takie same wyniki jak sklearn.neighbors.NearestNeighbors

def nn(data, x):
    """Zwraca indeks wektora w data który jest najbliższy (odległość euklidesowa) wektorowi x.
    data - 2D tablica numpy o n wierszach, w każdym wierszu wektor o długości m
    x - wektor (1D tablica numpy) o długości m"""
    
    # TODO
    

def check(data, x):
    def referencyjna():
        neigh = NearestNeighbors(1, algorithm='brute', metric='euclidean')
        neigh.fit(data)
        return neigh.kneighbors([x], 1, return_distance=False)[0,0]
    #print(referencyjna, x)   
    assert nn(data, x) == referencyjna()

data = np.array([[0, 0, 2], [1, 0, 0], [0, 0, 1]])
x = np.array([0, 0, 1.3])
check(data, x)