Aisd56

# ------------------- zadanie 1 -----------------------

import numpy as np
import matplotlib               # <<<<<<<
matplotlib.use('TkAgg')         # <<<<<<< te dwie linijki muszę zrobić na macu, bo sobie źle zainstalowałem rzeczy, Ty ich nie musisz używać
import matplotlib.pyplot as plt


def sigmoid(x): return 1/(1+np.power(np.e, -x))


x = np.linspace(start=-10, stop=10, num=20000)    # definicja osi X
y = sigmoid(x)                                    # liczenie osi Y


plt.figure()
plt.plot(x, y)
plt.grid()
plt.show()


# ------------------- zadanie 2 -----------------------

import pandas as pd

import numpy as np
import matplotlib               # <<<<<<<
matplotlib.use('TkAgg')         # <<<<<<< te dwie linijki muszę zrobić na macu, bo sobie źle zainstalowałem rzeczy, Ty ich nie musisz używać
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn import metrics
from sklearn.linear_model import LogisticRegression


data = pd.read_csv('./diabetes.csv')

features_columns = ['Pregnancies','Glucose','BloodPressure','SkinThickness','Insulin','BMI','DiabetesPedigreeFunction','Age']
labels_column = ['Outcome']

features = data[features_columns].to_numpy()
labels = data[labels_column].to_numpy().reshape(-1, )

X_train, X_test, y_train, y_test = train_test_split(features, labels, train_size=0.75, random_state=123)     # podział zbioru na testowy i testowy w stosunku 75%:25%, ziarno losowości ustawione na 123 (liczba bez znaczenia xD)

lr = LogisticRegression(solver='lbfgs')  # przygotowanie modelu
lr.fit(X_train, y_train)                 # trening modelu
y_pred = lr.predict(X_test)              # predykcja

cm = metrics.confusion_matrix(y_test, y_pred)    # liczenie macierzy pomyłek

# rysowanko macierzy pomyłek
classes = np.unique(labels)

fig, ax = plt.subplots()
im = ax.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
ax.figure.colorbar(im, ax=ax)
ax.set(xticks=np.arange(cm.shape[1]),
       yticks=np.arange(cm.shape[0]),
       xticklabels=classes, yticklabels=classes,
       ylabel='True label',
       xlabel='Predicted label')

# Tutaj tworzymy anotacje w pętli dla każdego kwadracika.
fmt = '.2f'     # ilość miejsc po przecinku
thresh = cm.max() / 2.  # próg dla koloru tekstu, żeby się nie zlewało
for i in range(cm.shape[0]):
    for j in range(cm.shape[1]):
        ax.text(j, i, format(cm[i, j], fmt),
                ha="center", va="center",
                color="white" if cm[i, j] > thresh else "black")
fig.tight_layout()


# ------------------- zadanie 3 -----------------------
# w tym wypadku będziemy sobie tworzyć wykres kawałek po kawałku

import matplotlib               # <<<<<<<
matplotlib.use('TkAgg')         # <<<<<<< te dwie linijki muszę zrobić na macu, bo sobie źle zainstalowałem rzeczy, Ty ich nie musisz używać
import matplotlib.pyplot as plt

from sklearn.datasets.samples_generator import make_blobs
from sklearn.svm import SVC


# nowa figure
plt.figure()


# tworzymy punkty
coordinates, classes = make_blobs(n_samples=50, centers=2, random_state=0, cluster_std=0.60)
# dzielimy współrzędne na iksy i igreki
x = coordinates[:, 0]   # współrzędne x to wszystkie elementy zerowej kolumny
y = coordinates[:, 1]   # współrzędne y to wszystkie elementy pierwszej kolumny


# do figury dodajemy punkty
plt.scatter(x=x, y=y, c=classes)


# tworzymy liniowy klasyfikator SVM i go uczymy
clf = SVC(kernel='linear')
clf.fit(coordinates, classes)

# klasyfikator SVM w najprostszej postaci to nic innego jak prosta oddzielająca dwa zbiory
w = clf.coef_[0]    # współrzędne linii podziału klasyfikatora
a = -w[0] / w[1]    # liczenie alfa

# liczenie lini podziału
xx = np.linspace(int(min(x)-1), int(max(x)+1))     # oś x do wizualizacji
yy = a * xx - (clf.intercept_[0]) / w[1]           # oś y do wizualizacji, intercept_ to stała w równaniu SVMa

# rysowanko lini ciągłej (główna oś podziału)
plt.plot(xx, yy, 'k-')

# tworzenie marginesów (wektorów nośnych)
margin = 1 / np.sqrt(np.sum(clf.coef_ ** 2))
yy_down = yy - np.sqrt(1 + a ** 2) * margin
yy_up = yy + np.sqrt(1 + a ** 2) * margin

# rysowanko wektorów nośnych
plt.plot(xx, yy_down, 'k--')
plt.plot(xx, yy_up, 'k--')


# ------------------- zadanie 4 -----------------------
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import classification_report

data = pd.read_csv('./iris.csv')

features = data[['sepal.length', 'sepal.width', 'petal.length', 'petal.width']].to_numpy()
labels = data[['variety']].to_numpy().reshape(-1, )
classes = np.unique(labels)

X_train, X_test, y_train, y_test = train_test_split(features, labels, train_size=0.75, random_state=123)


# wilomianowe jądro
clf1 = SVC(kernel='poly')
clf1.fit(X_train, y_train)
y_pred = clf1.predict(X_test)

print(classification_report(y_test, y_pred))

# gaussowskie jądro
clf2 = SVC(kernel='rbf')
clf2.fit(X_train, y_train)
y_pred = clf2.predict(X_test)

print(classification_report(y_test, y_pred))

# sigmoid jądro
clf3 = SVC(kernel='sigmoid')
clf3.fit(X_train, y_train)
y_pred = clf3.predict(X_test)

print(classification_report(y_test, y_pred))

"""
różne jądra rysują różna hiperpłaszczyzny rozdielające dane, przenosząc to do 2D, to możemy mieć podział albo linią prostą,
albo funkcją gaussa (wtedy część danych jest nad funkcją a reszta pod) https://scikit-learn.org/stable/auto_examples/svm/plot_svm_kernels.html#sphx-glr-auto-examples-svm-plot-svm-kernels-py

parametry w classification report:
Precission - positive predictive values - precyzja, mówi ile procent próbek zaklasyfikowanych jako pozytywne było rzeczywiście pozytywne (TP/(TP + FP))
Recall - sensitivity - true positive rate - czułość - mówi ile procent tych próbek, które miały być zaklasyfikowane jako pozytywne były rzeczywiście pozytywne (TP/(TP + FN))
f1-score - średnia harmoniczna (czyli taka, która bierze pod uwagę liczebność) precyzji i czułości

Support to ilość próbek w danym zbiorze xD

"""