Iti0210lab15

Lineaarsed mudelid

Sissejuhatus

Kasutame lihtsat lineaarset mudelit, et sensorite andmete pealt tuvastada, kas ruumis viibib inimene või mitte [1]. Ülesandes tuleb kirjutada lihtne programm, mis suudab treeningandmed lineaarse mudeliga sobitada ja siis testandmetega kontrollida, kui täpne leitud mudel on. Eesmärgiks saada aru, kuidas töötab:

• lineaarse mudeli treenimine gradient descent meetodiga
• klassifitseerimine (logistiline regressioon)

Ettevalmistus

Andmed treenimiseks ja testimiseks:

• Media:Iti0210lab15.zip

Sisendandmete kirjeldus (veergude kaupa):

Temperature, in Celsius 
Relative Humidity, % 
Light, in Lux 
CO2, in ppm 
Humidity Ratio, Derived quantity from temperature and relative humidity, in kgwater-vapor/kg-air 
Occupancy, 0 or 1, 0 for not occupied, 1 for occupied status

Selles harjutuses võiks kasutada NumPy paketti.

Andmete laadimine:

import numpy as np

train = np.loadtxt("train.csv", delimiter=",")
test = np.loadtxt("test.csv", delimiter=",")

Skaleerime kohe andmed (kui ei kasuta NumPy-t, siis idee on väärtused läbi jagada sama veeru maksimumiga, tekivad numbrid vahemikus [0, 1]).

Numpy 2-mõõtmelise massiivi indeksid on A[i,j], kusjuures võib kasutada ka : - kõik väärtused ja tavalises Pythoni stiilis from:to, mis valib mingi lõigu.

def normalize(X):
    return X / np.max(np.abs(X), axis=0)

X = normalize(train[:,:5])  # columns 0..4
y = normalize(train[:,5])   # column 5  (classification, 0 or 1)

Treenimine ja testimine

Kasutame stohhastilist (tähendab, juhuslikkusel põhinevat) gradientmeetodit (SGD).

def fit_sgd(X, y, niter=100, alpha=0.01):
    # initialize weights vector w

    # loop niter times
        # select random sample from X
        #    (and corresponding value in y)
        # let's say X[n], y[n]

        # calculate the estimate yhat from X[n] and weights

        # calculate error y[n]-yhat

        # update w_0
        # for each weight w_i in w_1, ...
            # update w_i

    return w    # weights vector

Õppimise kiiruse alpha võib valida vahemikus 0.001...0.5 ja vaadata, mis juhtub.

Kuidas me teame, et treenimine on lõppenud?

Üks variant oleks lihtsalt katsetada, kui hea meie meetod on:

def test_model(W, X, y, threshold=0.5):
    yhat = W[0] + (W[1:] * X).sum(axis=1)      # value from linear model
    ypred = (yhat > threshold).astype(int)     # prediction (is it > 0.5?)
    ytrue = (ypred == y).astype(int)           # true and false predictions
    return ytrue.sum() / y.shape[0]            # true count / total count

X_test = normalize(test[:,:5])
y_test = normalize(test[:,5])
print(test_model(W, X_test, y_test)

Kasvata iteratsioonide arvu, kuni ennustustäpsus enam ei parane.

Kavalam viis oleks jälgida, kuidas täpsuse kadu (SSE loss) kahaneb treenimise ajal. Kui see enam ei kahane, pole mõtet treenida. Antud funktsiooni on mõtet kasutada mingi arvu tsüklite järel, mitte igas treeningtsüklis:

def sse_loss(W, X, y):
    yhat = W[0] + (W[1:] * X).sum(axis=1)
    err = y - yhat
    return np.square(err).sum()