
# importere pakker og funksjoner vi trenger i oppgave 1

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from scipy import stats
import statsmodels.formula.api as smf
import statsmodels.api as sm

# for å fjerne unødvendige feilmeldinger om at noen pakker i fremtiden vil se annerledes ut
import warnings
warnings.filterwarnings("ignore")


# laste inn dataene (vi kaller den 'df', for 'data frame')
df = pd.read_csv('https://www.math.ntnu.no/emner/IST100x/ISTx1003/h2022/sporing_data.csv', sep = ",")
# printe første og siste radene
df


# ser litt ekstra på asfalt-dataene
df['asfalt'].value_counts()


figure, axis = plt.subplots(3, 2, figsize = (12, 12))

axis[0, 0].scatter(df['posisjon'], df['sporing'], s = 2)
axis[0, 0].set_xlabel("Posisjon"); axis[0, 0].set_ylabel("Sporing")

axis[0, 1].scatter(df['posisjon'], df['sporing_trafikk'], s = 2)
axis[0, 1].set_xlabel("Posisjon"); axis[0, 1].set_ylabel("Sporing/AADT")

axis[1, 0].scatter(df['posisjon'], df['spordybde'], s = 2)
axis[1, 0].set_xlabel("Posisjon"); axis[1, 0].set_ylabel("Spordybde")
  
axis[1, 1].scatter(df['posisjon'], df['veibredde'], s = 2)
axis[1, 1].set_xlabel("Posisjon"); axis[1, 1].set_ylabel("Veibredde")

axis[2, 0].scatter(df['posisjon'], df['asfalt'], s = 2)
axis[2, 0].set_xlabel("Posisjon"); axis[2, 0].set_ylabel("Asfalt")

axis[-1, -1].axis('off')

plt.show()


plt.hist(df[df['spordybde'] > 25]['sporing'], bins = 15);


plt.scatter(df['spordybde'], df['sporing_trafikk'], s = 2)
plt.ylabel("Sporing/AADT")
plt.xlabel("Spordybde")
plt.show()


# Steg 2: spesifiser matematisk modell
formel = 'sporing_trafikk ~ spordybde'

# Steg 3: Initaliser og tilpass en enkel lineær regresjonsmodell
# først initialisere
modell = smf.ols(formel, data = df)
# deretter tilpasse
resultat = modell.fit()

# Steg 4: Presenter resultater fra den tilpassede regresjonsmodellen
resultat.summary()


# Steg 5: Evaluere om modellen passer til dataene
# Plotte predikert verdi mot residual
figure, axis = plt.subplots(1, 2, figsize = (15, 5))
sns.scatterplot(resultat.fittedvalues, resultat.resid, ax = axis[0])
axis[0].set_ylabel("Residual")
axis[0].set_xlabel("Predikert verdi")

# Lage kvantil-kvantil-plott for residualene
sm.qqplot(resultat.resid, line = '45', fit = True, ax = axis[1])
axis[1].set_ylabel("Kvantiler i residualene")
axis[1].set_xlabel("Kvantiler i normalfordelingen")
plt.show()


# Kryssplott av spordybde mot sporing_trafikk, veibredde mot sporing_trafikk, og spordybde mot veibredde.
# På diagonalen er glattede histogrammer (tetthetsplott) av sporing_trafikk, spordybde og veibredde
sns.pairplot(df, vars = ['sporing_trafikk', 'spordybde', 'veibredde'],
             diag_kind = 'kde',
             plot_kws = dict(alpha = 0.4))
plt.show()

# Boksplott av sporing_trafikk mot asfalt
ax = sns.boxplot(x = "asfalt", y = "sporing_trafikk", data = df)
plt.show()

# Kryssplott av spordybde mot sporing_trafikk, nå med farger for asfalttype
sns.pairplot(df, vars = ['sporing_trafikk', 'spordybde', 'veibredde'],
             hue = 'asfalt', 
             diag_kind = 'kde',
             plot_kws = dict(alpha = 0.4))
plt.show()


formel = 'sporing_trafikk ~ spordybde + veibredde + asfalt'


# her kan du lime inn koden for å tilpasse den nye modellen


# her kan du lime inn koden for å tilpasse den nye modellen


# importere pakker og funksjoner vi trenger i oppgave 2
import numpy as np
import pandas as pd

# plotting
import matplotlib.pyplot as plt
import seaborn as sns

# fordelinger, modeller for regresjon, qq-plott 
from scipy import stats
import statsmodels.formula.api as smf
import statsmodels.api as sm

# trening og testsett, evaluering av klassifikasjonsmetoder 
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier


# Lese inn datasettene ved funksjon fra pandas (df=data frame - vanlig navn å gi et datasett)
df0 = pd.read_csv("https://www.math.ntnu.no/emner/IST100x/ISTx1003/h2022/E0.csv", sep = ',') # Premier League
df1 = pd.read_csv("https://www.math.ntnu.no/emner/IST100x/ISTx1003/h2022/E1.csv", sep = ',') # Championship
df2 = pd.read_csv("https://www.math.ntnu.no/emner/IST100x/ISTx1003/h2022/E2.csv", sep = ',') # League 1
df3 = pd.read_csv("https://www.math.ntnu.no/emner/IST100x/ISTx1003/h2022/E3.csv", sep = ',') # League 2

# Sett sammen datasettene til 1 data-frame
df_in=pd.concat([df0,
                 df1,
                 df2,
                 df3], ignore_index = True)
df=pd.concat([pd.Series(np.where(df_in['FTR'] == 'H', 1, 0)),
              df_in['HST']-df_in['AST'], 
              df_in['HC']-df_in['AC'],
              df_in['HF']-df_in['AF']], axis = 1)

# Henter ut de dataene vi er interessert i
df.columns=['y', 'skudd_paa_maal_diff', 'corner_diff', 'forseelse_diff']
print(df.describe())


df_trenval, df_test = train_test_split(df, test_size = 0.2, random_state = 1000, stratify = df['y'])
df_tren, df_val = train_test_split(df_trenval, test_size = 0.25, random_state = 1, stratify = df_trenval['y'])
print("tren: ", df_tren.shape)
print(df_tren.describe())
print("val: ", df_val.shape)
print(df_val.describe())
print("test: ", df_test.shape)
print(df_test.describe())
print(df_tren["y"].value_counts())
print(df_val["y"].value_counts())
print(df_test["y"].value_counts())


sns.pairplot(df_tren, vars = ['skudd_paa_maal_diff','corner_diff','forseelse_diff'],
             hue = 'y', 
             diag_kind = 'kde',
             plot_kws = dict(alpha = 0.4))
plt.show()

corr = df_tren.corr()
display(corr.style.background_gradient(cmap = 'coolwarm', axis = None, vmin = -1, vmax = 1))
plt.show()


# Steg 2: Modellformel
formel = "y ~ skudd_paa_maal_diff + corner_diff + forseelse_diff"

# Steg 3: Initialiser modellen 
modell = smf.logit(formel, data = df_tren)

# Tilpass modellen
resultat = modell.fit()

# Steg 4: Presenter resultater fra den tilpassede modellen 
print(resultat.summary())

# Tolkning av estimerte regresjonsparametere er på exp-skala (odds)
print("FLERE utregninger:")
print("exp(beta): \n", np.exp(resultat.params), sep = "")

# Spesifiser verdi for cutoff
cutoff = 0.5

# Prediker verdi for valideringssettet
val_pred = resultat.predict(exog = df_val)

# Klassifiser som seier for hjemmelaget hvis sannsynligheten for at hjemmelaget vant er over 0.5
y_valpred = np.where(val_pred > cutoff, 1, 0)
y_valobs = df_val['y']

# Finn andel ukorrekte klassifikasjoner
print("Feilrate:", 1 - accuracy_score(y_true = y_valobs, y_pred = y_valpred))


# Steg 2: Modellformel
formel2 = "y ~ skudd_paa_maal_diff + corner_diff"


# her kan du lime inn Steg 3-4 fra koden over


knaboer = np.arange(1, 49, step = 2)
val_feilrate = np.empty(len(knaboer))

X_tren = df_tren[['skudd_paa_maal_diff', 'corner_diff']] # bruker bare disse to forklaringsvariablene
X_val = df_val[['skudd_paa_maal_diff', 'corner_diff']] 

for i,k in enumerate(knaboer):
    
#Initialiser kNN med  k neighbors
    knn = KNeighborsClassifier(n_neighbors = k, p = 2) # p = 2 gir euklidsk avstand

# Tilpass modellen med treningssettet
    knn.fit(X_tren, df_tren['y'])
    
# Beregn feilrate på valideringssett
# score er accuracy= "andel korrekt"
    val_feilrate[i] = 1 - knn.score(X_val, df_val['y'])
    
# Lage plott
plt.title('k-NN for ulike verdier av antall naboer k')
plt.plot(knaboer, val_feilrate, label = 'Feilrate på valideringssettet')
plt.legend()
plt.xlabel('Antall naboer k')
plt.ylabel('Feilrate')
plt.show()

valres=np.vstack((knaboer, val_feilrate))
print("Valideringsfeilrate:")
print(valres.T)

mink_valfeilrate = knaboer[np.where(val_feilrate == val_feilrate.min())]
print(mink_valfeilrate[0])


# beste resultat for logistisk regresjon
bestelogist = 0 # hva er navnet på resultatobjektet fra den logistiske regresjon du valgte? var det den med eller uten forseelse_diff?
test_pred = bestelogist.predict(exog = df_test)
y_testpred = np.where(test_pred > cutoff, 1, 0)
y_testobs = df_test['y']
print("Feilrate logistisk regresjon:", 1 - accuracy_score(y_true = y_testobs, y_pred = y_testpred))

# beste resultat for kNN
bestek = 0 # hva er din beste k?
knn = KNeighborsClassifier(n_neighbors = bestek, p = 2)
knn.fit(X_tren, df_tren['y'])
X_test=df_test[['skudd_paa_maal_diff', 'corner_diff']]
print("Feilrate kNN:", 1 - knn.score(X_test, df_test['y']))


# BONUS - plotting av klassegrensene for de beste modellene!

X = X_tren
n = 50  # steglengde
# lage et grid for å plotte
x_min, x_max = X['skudd_paa_maal_diff'].min() - 0.5, X['skudd_paa_maal_diff'].max() + 0.5
y_min, y_max = X['corner_diff'].min() - 0.5, X['corner_diff'].max() + 0.5
xx, yy = np.meshgrid(np.linspace(x_min, x_max, n),
                     np.linspace(y_min, y_max, n))
# Plotter nå klassegrensen, ved å predikere klassen til hver observasjon i griddet vi laget.
Z = knn.predict(np.c_[xx.ravel(), yy.ravel()])
 
# Put the result into a color plot
Z = Z.reshape(xx.shape)
fig, ax = plt.subplots(figsize = (10,10))
ax.contour(xx, yy, Z, cmap = plt.cm.Paired)
ax.scatter(xx, yy, c = Z, marker = ".",cmap = plt.cm.coolwarm)
ax.set_xlabel('skudd_paa_maal_diff', fontsize = 18)
ax.set_ylabel('corner_diff', fontsize = 18)
#fig.show()

# legger til klassegrensen for logistisk regresjon - dette blir bare riktig hvis du 
# har valgt modellen med skudd_paa_maal_diff og corner_diff som den beste modellen

beta0 = resultat.params[0]
beta1 = resultat.params['skudd_paa_maal_diff']
beta2 = resultat.params['corner_diff']
x = np.linspace(-1.5, 4.5, n)
y = -beta0/beta2 - x*beta1/beta2
plt.plot(x, y, '-r', label = 'logistisk klassegrense')
plt.scatter(X_tren['skudd_paa_maal_diff'], X_tren['corner_diff'], c = df_tren['y'])


# importere pakker og funksjoner vi trenger i oppgave 3
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans  # k-gjennomsnitt klyngeanalyse
from scipy.cluster.hierarchy import dendrogram, linkage
from matplotlib.offsetbox import OffsetImage, AnnotationBbox


# Leser inn datasettet og ser på de første 5 radene (tallene)

images = pd.read_csv('https://www.math.ntnu.no/emner/IST100x/ISTx1003/h2022/mnist2022.csv', sep = ",", index_col = 0)

images.head()


## standardisering av dataene
images = images/255


print("Bildet har type", type(images))
print("Størrelsen til tabellen er", images.shape)
# gjennomsnittfargen i bilde 50 (MERK: vi ber om bildet på plass 49, siden det første bildet er på plass 0)
print("Gjennomsnittsfarge i bilde 50 er", images.iloc[49].mean())
print('Dataformatet til en piksel er', type(images.iloc[1,1]))


features = np.array(images)
features = features.reshape(features.shape[0], 28,28)

fig = plt.figure(figsize=(10,10))

for i in range(10):
    fig.add_subplot(1, 10, i+1)
    plt.imshow(features[i], cmap = 'gray')
    plt.xticks([])
    plt.yticks([])
    plt.tight_layout()


# her kan du lime inn og redigere kode for å plotte bildet


# Steg 1: Antall klynger
antall_klynger = 3

# Steg 2: Initaliser k-means algoritmen
kmeans = KMeans(n_clusters = antall_klynger, random_state = 1)

# Steg 3: Tilpass modellen
kmeans.fit(images)

# sentroidene
sentroider = kmeans.cluster_centers_


# her kan du skrive koden for å plotte


# her kan du kjøre analysen med K = 2 og K = 4 (kopier relevant kode og gjør endringer)


n_image = 30

sample = images.sample(n = n_image, random_state = 2)

sampleimg = np.array(sample).reshape(sample.shape[0], 28,28)


plt.figure(figsize=(15,10))
ax = plt.subplot()

# Bruk gjennomsnittskobling (method='average')
link = linkage(y = sample, method = 'average', metric = 'euclidean')

dendro = dendrogram(link)

dcoord = np.array(dendro["dcoord"])
icoord = np.array(dendro["icoord"])
leaves = np.array(dendro["leaves"])

idx = np.argsort(dcoord[:, 2])

dcoord = dcoord[idx, :]
icoord = icoord[idx, :]

idx = np.argsort(link[:, :2].ravel())
label_pos = icoord[:, 1:3].ravel()[idx][:n_image]

for i in range(n_image):
    imagebox = OffsetImage(sampleimg[i], cmap = 'gray', interpolation = "bilinear")
    ab = AnnotationBbox(imagebox, (label_pos[i], 0),  box_alignment=(0.5, -0.1), 
                        bboxprops={"edgecolor" : "none"})
    ax.add_artist(ab)

plt.title('Dendrogram for håndskrevne tall')
plt.xlabel('Siffer')
plt.ylabel('Avstand')
plt.xticks([])
plt.show()


# her kan du lage et nytt dendrogram med ny 'method' (kopier koden over)

Tellende prosjekt i ISTx1003 - høst 2022 ¶

Innholdsfortegnelse¶

Oppgave 1 - Lineær regresjon (50%)¶

Innholdsfortegnelse¶

Introduksjon ¶

Rådata ¶

Oppgave 1a) Dataoppsett og klargjøring av data ¶

Oppgave 1b) Enkel lineær regresjon ¶

Oppgave 1c) Multippel lineær regresjon ¶

Oppgave 2 - Klassifikasjon (30%)¶

Innholdsfortegnelse¶

Ble det hjemmeseier?¶

Oppgave 2a) Lese inn og preprosessere data ¶

Oppgave 2b) Logistisk regresjon ¶

Oppgave 2c) $k$-nærmeste-nabo-klassifikasjon ¶

Oppgave 2d) Evaluere beste modeller ¶

Oppgave 3: Klyngeanalyse (20%)¶

Innholdsfortegnelse¶

Finn klynger (struktur) i bildene av håndskrevne tall ¶

Oppgave 3a) Les inn datasettet og bli kjent med det ¶

Oppgave 3b) Klyngeanalyse med $K$-gjennomsnitt ¶

Oppgave 3c) Hierarkisk klyngeanalyse ¶

Oppgave 3d) Prediksjon ¶

Tellende prosjekt i ISTx1003 - høst 2022¶

Innholdsfortegnelse¶

Oppgave 1 - Lineær regresjon (50%)¶

Innholdsfortegnelse¶

Introduksjon¶

Rådata¶

Oppgave 1a) Dataoppsett og klargjøring av data¶

Oppgave 1b) Enkel lineær regresjon¶

Oppgave 1c) Multippel lineær regresjon¶

Oppgave 2 - Klassifikasjon (30%)¶

Innholdsfortegnelse¶

Ble det hjemmeseier?¶

Oppgave 2a) Lese inn og preprosessere data¶

Oppgave 2b) Logistisk regresjon¶

Oppgave 2c) $k$-nærmeste-nabo-klassifikasjon¶

Oppgave 2d) Evaluere beste modeller¶

Oppgave 3: Klyngeanalyse (20%)¶

Innholdsfortegnelse¶

Finn klynger (struktur) i bildene av håndskrevne tall¶

Oppgave 3a) Les inn datasettet og bli kjent med det¶

Oppgave 3b) Klyngeanalyse med $K$-gjennomsnitt¶

Oppgave 3c) Hierarkisk klyngeanalyse¶

Oppgave 3d) Prediksjon¶

Tellende prosjekt i ISTx1003 - høst 2022 ¶

Introduksjon ¶

Rådata ¶

Oppgave 1a) Dataoppsett og klargjøring av data ¶

Oppgave 1b) Enkel lineær regresjon ¶

Oppgave 1c) Multippel lineær regresjon ¶

Oppgave 2a) Lese inn og preprosessere data ¶

Oppgave 2b) Logistisk regresjon ¶

Oppgave 2c) $k$-nærmeste-nabo-klassifikasjon ¶

Oppgave 2d) Evaluere beste modeller ¶

Finn klynger (struktur) i bildene av håndskrevne tall ¶

Oppgave 3a) Les inn datasettet og bli kjent med det ¶

Oppgave 3b) Klyngeanalyse med $K$-gjennomsnitt ¶

Oppgave 3c) Hierarkisk klyngeanalyse ¶

Oppgave 3d) Prediksjon ¶