path: root/backend/microservice/mlservice.py

import pandas as pd
import tensorflow as tf
import keras
import numpy as np
import matplotlib.pyplot as plt   

### 1)Ucitavanje vrednosti

#print(1)
data1=pd.read_csv('titanic.csv')
data=data1.copy()
#print(data.head())

### U promenjivoj kolone nalaze se nazivi svih kolona seta podataka
kolone=data.columns
#print(kolone[1])
#print(data[kolone[1]].isnull().sum())
#print(data[kolone[1]].head(10))


### 2)Proveravanje svih kolona za null vrednosti i popunjavanje medijanom ili srednjom vrednosti ili birisanje

#####Part2 #####
brisanje=input("DA LI ZELITE DA IZBRSETE SVE KOLONE SA NULL VREDNOSTIMA? ")
if(brisanje=='da'):
    data=data.dropna(axis=1)
elif(brisanje=='ne'):
    brisanjer=input("DA LI ZELITE DA IZBRISETE SVE REDOVE SA NULL VREDNOSTINA ")
    if(brisanjer=='da'):
        data=data.dropna()
    elif(brisanjer=='ne'):

        for i in range(len(kolone)):
            if(isinstance(data[kolone[i]].dtype, pd.CategoricalDtype)):
                print('cat')

            if(data[kolone[i]].isnull().any()):
                tippodataka=data[kolone[i]].dtype
                kolona=data[kolone[i]].copy()
        
                if(tippodataka==np.float64 or tippodataka==np.int64):
                    popunjavanje=input("UNETI NACIN POPUNJAVANJA PROMENJIVIH SA NULL VREDNOSTIMA ")
                    if(popunjavanje=='medijana'):
                        medijana=kolona.mean()
                        data[kolone[i]]=data[kolone[i]].fillna(medijana)
                    if(popunjavanje=='srednjavrednost'):
                        sv=data[kolone[i]].sum()/data[kolone[i]].count()
                        data[kolone[i]]=sv
                    if(popunjavanje=='brisanjekolone'):
                        data=data.dropna(axis=1)

                elif(tippodataka==np.object_):
                    najcescavrednost=kolona.value_counts().index[0]
                    data[kolone[i]]=data[kolone[i]].fillna(najcescavrednost)

### 3)Izbacivanje kolona koje ne uticu na rezultat PART2
nredova=data.shape[0]
for i in range(len(kolone)):
    if((data[kolone[i]].nunique()>(nredova/2)) and( data[kolone[i]].dtype==np.object_)):
        data.pop(kolone[i])

print(data.head(10))

### 4)izbor tipa enkodiranja
kolone=data.columns ### Azuriranje postojecih kolona nakon moguceg brisanja

enc=input("UNETI TIP ENKODIRANJA ")
onehot=0

### 5)Enkodiranje svih kategorijskih promenjivih label-encode metodom

if(enc=='label'):
    from sklearn.preprocessing import LabelEncoder
    encoder=LabelEncoder()
    for k in range(len(kolone)):
        if(data[kolone[k]].dtype==np.object_):
           data[kolone[k]]=encoder.fit_transform(data[kolone[k]])
    print(data.head(20))

### 6)Enkodiranje svih kategorijskih promenjivih onehot metodom

elif(enc=='onehot'):
    ### PART2###
    onehot==1
    kategorijskekolone=[]
    for k in range(len(kolone)):
        if(data[kolone[k]].dtype==np.object_):
            
            kategorijskekolone.append(kolone[k]) ###U kategorijske kolone smestaju se nazivi svih kolona sa kategorijskim podacima
    
    print(kategorijskekolone)

    ### Enkodiranje 
    data=pd.get_dummies(data,columns=kategorijskekolone,prefix=kategorijskekolone)
    print(data.head(10))

kolone=data.columns ### Azuriranje kolona nakon moguceg dodavanja

### 7)Podela skupa na skup za trening i skup za testiranje

predvidetikol=input("UNETI NAZIV KOLONE ČIJU VREDNOST TREBA PREDVIDETI ")

xkolone=[]
for k in range(len(kolone)):
        if(kolone[k]!=predvidetikol):
            
            xkolone.append(kolone[k])###U xkolone se smestaju nazivi kolona cije vrednosti nije potrebno predvideti !!!Prefiks one-hot!!!

### 7.1)Podela na x i y
###Dodavanje vrednosti u x
x=data[xkolone].values
###Dodavanje vrednosti u y, samo za label enkodiranje, bez prefiksa
y=data[predvidetikol].values

print(data[xkolone].head(10))
print(data[predvidetikol].head(10))

### 7.2)Unos velicina za trening i test skup
trening=int(input('UNETI VELIČINU TRENING SKUPA '))
#test=int(input("UNETI VELICINU TESTNOG SKUPA"))

###Provera unetih velicina
if(trening<=0 or trening>=100):
    print("POGREŠAN UNOS VELIČINE SKUPA ZA TRENING")
if(trening>1):
    trening=trening/100

### 7.3)Da li korisnik zeli nasumicno rasporedjivanje podataka?
nasumicno=input("DA LI ŽELITE NASUMIČNO RASPOREDJIVANJE PODATAKA U TRENING I TEST SKUP? ")
###!!!Dugme za nasumici izbor
if(nasumicno=='da'):
    random=50
else:
    random=0

### 7.4)Podela podataka
from sklearn.model_selection import train_test_split
x_train,x_test,y_train,y_test=train_test_split(x,y,train_size=trening,random_state=random)

### 8)Skaliranje podataka
from sklearn.preprocessing import StandardScaler
scaler=StandardScaler()
scaler.fit(x_train)
x_test=scaler.transform(x_test)
x_train=scaler.transform(x_train)

#####ZAVRSENA PRIPREMA PODATAKA#####

#####OBUCAVANJE MODELA#####

### 9)Inicijalizacija vestacke neuronske mreze

classifier=tf.keras.Sequential()

### 10)Dodavanje prvog,ulaznog sloja
aktivacijau=input("UNETI ŽELJENU AKTIVACIONU FUNKCIJU ULAZNOG SLOJA ")
brojnu=int(input("UNETI BROJ NEURONA ULAZNOG SLOJA "))

classifier.add(tf.keras.layers.Dense(units=brojnu,activation=aktivacijau,input_dim=x_train.shape[1]))

### 11)Dodavanje drugog, skrivenog sloja
aktivacijas=input("UNETI ŽELJENU AKTIVACIONU FUNKCIJU SKRIVENOG SLOJA ")
brojns=int(input("UNETI BROJ NEURONA SKRIVENOG SLOJA "))

classifier.add(tf.keras.layers.Dense(units=brojns,activation=aktivacijas))

### 12) Dodavanje treceg, izlaznog sloja
aktivacijai=input("UNETI ŽELJENU AKTIVACIONU FUNKCIJU IZLAZNOG SLOJA ")

classifier.add(tf.keras.layers.Dense(units=1,activation=aktivacijai))


### 13) Kompajliranje neuronske mreze
#gubici=input("UNETI FUNKCIJU OBRADE GUBITAKA ")
optimizator=input("UNETI ŽELJENI OPTIMIZATOR ")

### 13.1)Izbor metrike za kompajler PART2
metrike=[]
while(1):
    m=input("UNETI ZELJENE METRIKE ")
    
    if(m=='KRAJ'):
        break   
    metrike.append(m)
classifier.compile(optimizer=optimizator, loss='binary_crossentropy',metrics = metrike)

### 14) 
uzorci=int(input("UNETI KOLIKO UZORAKA ĆE BITI UNETO U ISTO VREME "))

history=classifier.fit(x_train,y_train,batch_size=uzorci,epochs=10)

### 14.1)Parametri grafika iz history PART2
metrikedf=pd.DataFrame() ###DataFrame u kom se nalaze podaci o rezultatima metrika za iscrtavanje na grafiku. Svaka kolona sadrzi vrednost metrike po epohama
for i in range(len(metrike)):
    metrikedf[metrike[i]]=history.history[metrike[i]]
    #print(history.history[metrike[i]])
    plt.plot(history.history[metrike[i]])
plt.show()

#print(metrikedf)

#metrikedf.to_csv("metrike.csv")


### 15) Predvidjanje
y_pred=classifier.predict(x_test)

print(y_pred)

### 15.1) Formatiranje podataka za metrike PART2
y_pred=(y_pred>=0.5).astype('int')
y_pred=y_pred.flatten()

#print(y_pred)

#print(y_test)
### 15.2) Kreiranje DataFrame-a u kom se nalaze kolone koje predstavljaju stvarne i predvidjene vrednosti, potrebne za iscrtavanje grafika i metrike PART2
rezultat=pd.DataFrame({"Stvarna vrednost ":y_test,"Predvidjena vrednost":y_pred})
print(rezultat.head(20))

#####METRIKE##### PART2

import  sklearn.metrics as sm
          

### 16)Tacnost
tacnost=sm.accuracy_score(y_test,y_pred)
print('tacnost ',tacnost)

### 17)Preciznost
preciznost=sm.precision_score(y_test,y_pred)
print('preciznost ',preciznost)

### 18)Recall
recall=sm.recall_score(y_test,y_pred)
print('recall ',recall)

### 19)Specificity
tn, fp, fn, tp = sm.confusion_matrix(y_test,y_pred).ravel()
spec = tn / (tn+fp)
print('spec ',spec)

### 20)F1
f1=sm.f1_score(y_test,y_pred)
print('f1 ',f1)

### 21)Classification report
classificationreport=sm.classification_report(y_test,y_pred)
print('classification ',classificationreport)

### 22)Mean squared error (mse)
mse=sm.mean_squared_error(y_test,y_pred)
print('mse ',mse)

### 23)Mean absolute error (mae)
mae=sm.mean_absolute_error(y_test,y_pred)
print('mae ',mae)

### 24)Mean absolute percentage error (mape)
mape=sm.mean_absolute_percentage_error(y_test,y_pred)
print('mape ',mape)

### 25)Root mean square error (rmse) *** da bi se iskoristila u history, salje se u metrics preko funkcije
import numpy as np
rmse=np.sqrt(sm.mean_squared_error(y_test,y_pred))
print("rmse ",rmse)

### 26)Confusion matrix
cmatrix=sm.confusion_matrix(y_test,y_pred)
print('cmatrix ',cmatrix)

### 27)ROC
fpr, tpr, _ = sm.roc_curve(y_test,y_pred)
plt.plot(fpr, tpr, color='blue')
plt.title('ROC')
plt.xlim([0.0, 1.0])
plt.xlabel('False Positive Rate')
plt.ylim([0.0, 1.0])
plt.ylabel('True Positive Rate')
plt.show()