import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.metrics import classification_report
from sklearn.svm import  SVC
import numpy as np

df = pd.read_csv("iris_pandas.csv")

featurs = df.columns[:4].tolist()
x=df[featurs]
y=df["Species"]


# Podela podataka na trening i test skup
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)

# Parametri za unakrsnu validacuju
parameters = [{'C': [pow(2,x) for x in range(-6,10,2)],
               'kernel' : ['linear']
               },

              {'C': [pow(2,x) for x in range(-6,10,2)],
               'kernel': ['poly'],
               'degree': [2, 3, 4, 5],
               'gamma': np.arange(0.1, 1.1, 0.1),
               'coef0': np.arange(0, 2, 0.5)
               },

                {'C': [pow(2,x) for x in range(-6,10,2)],
               'kernel' : ['rbf'],
               'gamma': np.arange(0.1, 1.1, 0.1),
               },

               {'C': [pow(2,x) for x in range(-6,10,2)],
               'kernel' : ['sigmoid'],
               'gamma': np.arange(0.1, 1.1, 0.1),
               'coef0': np.arange(0, 2, 0.5)
               }]


scores = ['precision', 'f1']

for score in scores:
    print("Mera ", score)
    print()

    """

SVM
C : default=1.0
parametar za regularizaciju

kernel : default=’rbf’
         ‘linear’  ( <x, x'>),

         ‘poly’ : ( gamma*<x, x'> + coef0)^degree
                    vezani parametri:
                     degree (stepen): default=3,
                     gamma (koeficijent) : default= 1/n_features
                     coef0 (nezavisni term) default=0.0

         ‘rbf’,  exp(-gamma*|x-x'|^2)
                     vezani parametri:
                     gamma (koeficijent) : default= 1/n_features
                                           gamma>0

         ‘sigmoid’, (tanh(gamma*<x, x'> + coef0)
                     vezani parametri:
                     gamma (koeficijent) : default= 1/n_features
                     coef0 (nezavisni term) default=0.0


probability : default=False
da li proceniti verovatnocu

class_weight : {dict, ‘balanced’}
tezina klasa. Ako nije zadat parametar, sve klase imaju tezinu 1.
Sa opcijom “balanced” tezine su inverzno proporcionalne frekvenciji klase u y

decision_function_shape : ‘ovo’, ‘ovr’ or None, default=None
oblik funkcije za odlucivanje klase:
              ‘ovr’ - one-vs-rest (n_samples, n_classes)
              ‘ovo’ - one-vs-one  (n_samples, n_classes * (n_classes - 1) / 2)

atributi:
support_  -indeksi podrzavajucih vektora
support_vectors_ : podrzavajuci vektori
n_support_ : broj podrzavajucih vektora za svaku klasu
dual_coef_ : niz oblika [n_class-1, n_SV]
koeficijenti podrzavajucih vektora.
Ukoliko postoji vise klasa, postoje koeficijenti za sve 1-vs-1 klasifikatore.
coef_ : tezine dodeljene aributima ( samo za linearni kernel)
intercept_ : konstane u funckiji odlucivanja
    """

    clf = GridSearchCV(SVC(), parameters, cv=5, scoring='%s_macro' % score)
    clf.fit(x_train, y_train)

    print()
    print("Ocena uspeha po klasifikatorima:")
    means = clf.cv_results_['mean_test_score']
    stds = clf.cv_results_['std_test_score']
    for mean, std, params in zip(means, stds, clf.cv_results_['params']):
        print("%0.3f (+/-%0.03f) za %s" % (mean, std * 2, params))
    print()


    print("Najbolji parametri:")
    print(clf.best_params_)

    print("Izvestaj za test skup:")
    y_true, y_pred = y_test, clf.predict(x_test)
    print(classification_report(y_true, y_pred))
    print()