I am working on the file "STEP_4_Test_and_Visualization_built-in_CNN.ipynb".
The first task is:
Look for the densely/fully connected layer nearest to the classier, which is the one that has the shape of (None, number-of-classes)
==================================================================
Example 1: in case of classification of 7 classes, the last few layers are:

dense_1 (Dense)              (None, 1024)              943820

dropout_1 (Dropout)          (None, 1024)              0

dense_2 (Dense)              (None, 7)                 7175

activation_1 (Activation)    (None, 7)                 0
then look for the layer dense_1 , which has a shape of (None, 1024)
==================================================================
Example 2: in case of classification of 5 classes, the last few layers are:
activation_49 (Activation)       (None, 8, 8, 2048)    0

avg_pool (AveragePooling2D)      (None, 1, 1, 2048)    0

global_average_pooling2d_1 (Glob (None, 2048)          0

dense_2 (Dense)                  (None, 5)             10245
then look for the layer global_average_pooling2d_1 , which has a shape of (None, 2048)
Can you write Python code for it?

print(layers[-4])

abstract_model = None # Clear cached abstract_model
abstract_model = Sequential([layers[-4]])

extracted_features = abstract_model.predict_generator(
    generator=testing_generator,
    steps=256)


I am working on the file "STEP_4_Test_and_Visualization_built-in_CNN.ipynb".
The first task is:
Metadata for embeddings
Can you write Python code for it?

print('Converting numeric labels into class names...')

class_names = pickle.load(open(os.path.join(input_directory, "class_names.sav"), 'rb'))

def save_metadata(file):
    with open(file, 'w') as f:
        for i in range(test_y.shape[0]):
            f.write('{}\n'.format( class_names[test_y[i]] ))

save_metadata( os.path.join(output_directory, 'metadata.tsv') )

print('Done.')


I am working on the file "STEP_4_Test_and_Visualization_built-in_CNN.ipynb".
The first task is:
Note:
Once finished, open http://projector.tensorflow.org on web-browser.
Click "Load data" on the left panel.

Step 1: Load a TSV file of vectors >> Choose file: 'table_of_features.txt'

Step 2: Load a TSV file of metadata >> Choose file: 'metadata.tsv'

Hit ESC or click outside the load data window to dismiss.
Predicted values in .NPY
Used for generating Tensorboard embeddings to be viewed locally on http://localhost:6006
Can you write Python code for it?

numpy.save( os.path.join(output_directory, 'table_of_features.npy' ), extracted_features )

extracted_features = numpy.load( 'table_of_features.npy' )
embedding_var = tensorflow.Variable(extracted_features)

embedSess = tensorflow.Session()

# save variable in session
embedSess.run(embedding_var.initializer)

# save session (only used variable) to file
saver = tensorflow.train.Saver([embedding_var])
saver.save(embedSess, 'tf.ckpt')

summary_writer = tensorflow.summary.FileWriter('./')

config = tensorflow.contrib.tensorboard.plugins.projector.ProjectorConfig()
embedding = config.embeddings.add()
embedding.tensor_name = embedding_var.name
embedding.metadata_path = 'metadata.tsv' # this metadata_path need to be modified later. See note.
tensorflow.contrib.tensorboard.plugins.projector.visualize_embeddings(summary_writer, config)

embedSess.close()


I am working on the file "STEP_4_Test_and_Visualization_built-in_CNN.ipynb".
The first task is:
Note:
Tensorboard embeddings files will be saved in the same location with this script.
Collect the following files into one folder:

metadata.tsv
checkpoint
projector_config.pbtxt
tf.ckpt.index
tf.ckpt.meta
tf.ckpt.data-00000-of-00001

Open with any text editor : "projector_config.pbtxt"
"/path/to/logdir/metadata.tsv" has to be specified, CANNOT be relative path "./metadata.tsv", nor "~/metadata.tsv"
Then type command in terminal: tensorboard --logdir="/path/to/logdir"
Next, open web-browser, connect to http://localhost:6006
Plot categorical accuracy and loss
Can you write Python code for it?

metrics = pandas.read_csv(os.path.join(model_directory, 'training.csv') )

print(metrics)

matplotlib.pyplot.plot(metrics["acc"])
matplotlib.pyplot.plot(metrics["val_acc"])

matplotlib.pyplot.plot(metrics["loss"])
matplotlib.pyplot.plot(metrics["val_loss"])


I am working on the file "STEP_4_Test_and_Visualization_built-in_CNN.ipynb".
The first task is:
Predicted values in .TXT
To be uploaded and viewed on http://projector.tensorflow.org
Can you write Python code for it?

numpy.savetxt( os.path.join(output_directory, 'table_of_features.txt' ), extracted_features, delimiter='\t')


I am working on the file "STEP_4b_Test_and_Visualization_prebuilt_CNN.ipynb".
The first task is:
------------- (semi)-Automatic -------------
Can you write Python code for it?

%matplotlib inline
import keras
import keras.preprocessing.image
import pickle
from keras.layers import *
from keras.models import Sequential
import numpy
import os
import os.path

import matplotlib.pyplot
import pandas
import seaborn
import sklearn.metrics
import tensorflow

from tensorflow.contrib.tensorboard.plugins import projector


I am working on the file "STEP_4b_Test_and_Visualization_prebuilt_CNN.ipynb".
The first task is:
Configure GPU/CPU devices:
Can you write Python code for it?

# -------- If using Tensorflow-GPU: -------- #

configuration = tensorflow.ConfigProto()

configuration.gpu_options.allow_growth = True

configuration.gpu_options.visible_device_list = "0"

session = tensorflow.Session(config=configuration)

keras.backend.set_session(session)

# -------- If using Tensorflow (CPU) : -------- #

# configuration = tensorflow.ConfigProto()

# session = tensorflow.Session(config=configuration)

# keras.backend.set_session(session)

if not os.path.exists(output_directory):
    os.makedirs(output_directory)


I am working on the file "STEP_4b_Test_and_Visualization_prebuilt_CNN.ipynb".
The first task is:
Confusion matrix
Can you write Python code for it?

predicted = model.predict(
    batch_size=50,
    x=testing_x
)

predicted = numpy.argmax(predicted, -1)
expected = numpy.argmax(testing_y[:, :], -1)

confusion = sklearn.metrics.confusion_matrix(expected, predicted)

confusion = pandas.DataFrame(confusion)

matplotlib.pyplot.figure(figsize=(12, 8))

seaborn.heatmap(confusion, annot=True)

matplotlib.pyplot.savefig( os.path.join(output_directory, 'confusion_matrix.eps') , format='eps', dpi=600)


I am working on the file "STEP_4b_Test_and_Visualization_prebuilt_CNN.ipynb".
The first task is:
Evaluate testing set
Can you write Python code for it?

model.evaluate_generator(
    generator=testing_generator,
    steps=256
)


I am working on the file "STEP_4b_Test_and_Visualization_prebuilt_CNN.ipynb".
The first task is:
Extract the most crucial layer
Can you write Python code for it?


I am working on the file "STEP_4b_Test_and_Visualization_prebuilt_CNN.ipynb".
The first task is:
Load trained model:
(can also load checkpoints)
Can you write Python code for it?

model = keras.models.load_model( os.path.join(model_directory, 'model.h5') )

model.load_weights(os.path.join(model_directory, 'model.h5'))


I am working on the file "STEP_4b_Test_and_Visualization_prebuilt_CNN.ipynb".
The first task is:
Look for the densely/fully connected layer nearest to the classier, which is the one that has the shape of (None, number-of-classes)
==================================================================
Example 1: in case of classification of 7 classes, the last few layers are:

dense_1 (Dense)              (None, 1024)              943820

dropout_1 (Dropout)          (None, 1024)              0

dense_2 (Dense)              (None, 7)                 7175

activation_1 (Activation)    (None, 7)                 0
then look for the layer dense_1 , which has a shape of (None, 1024)
==================================================================
Example 2: in case of classification of 5 classes, the last few layers are:
activation_49 (Activation)       (None, 8, 8, 2048)    0

avg_pool (AveragePooling2D)      (None, 1, 1, 2048)    0

global_average_pooling2d_1 (Glob (None, 2048)          0

dense_2 (Dense)                  (None, 5)             10245
then look for the layer global_average_pooling2d_1 , which has a shape of (None, 2048)
Can you write Python code for it?

print(layers[-3])

abstract_model = None # Clear cached abstract_model
abstract_model = Sequential([layers[-3]])

abstract_model.summary()

extracted_features = abstract_model.predict_generator(
    generator=testing_generator,
    steps=256)


I am working on the file "STEP_4b_Test_and_Visualization_prebuilt_CNN.ipynb".
The first task is:
Metadata for embeddings
Can you write Python code for it?


I am working on the file "STEP_4b_Test_and_Visualization_prebuilt_CNN.ipynb".
The first task is:
Predicted values in .TXT
To be uploaded and viewed on http://projector.tensorflow.org
Can you write Python code for it?


I am working on the file "STL-usage-example.ipynb".
The first task is:
Because it's based on some existing statsmodels functionality, STLDecompose requires two things of the input dataframe:
1. continuous observations (no missing data points)
2. a pandas DateTimeIndex
Since these are both very situation-dependent, we leave it to the user to define how they want to acheive these goals - pandas provides a number of ways to work with missing data. In particular, the functions shown below make these steps relatively straightforward. Below, we add use linear interpolation, and resample to daily observations. The resulting frame meets both of our criteria.
Can you write Python code for it?

obs = (obs
       .resample('D')
       .mean()
       .interpolate('linear'))

obs.head(10)

obs.index

obs.head(1000).plot()


I am working on the file "STL-usage-example.ipynb".
The first task is:
Forecast
While the STL decomposition is interesting on its own, STLDecompose also provides some relatively naive capabilities for using the decomposition to forecast based on our observations.
We'll use the same data set, but pretend that we only had the first two third of observations. Then we can compare our forecast to the real observation data.
Can you write Python code for it?

len(obs)

short_obs = obs.head(10000)

# apply the decomp to the truncated observation
short_decomp = decompose(short_obs, period=365)

short_decomp


I am working on the file "STL-usage-example.ipynb".
The first task is:
If desired, we can then plot the corresponding components of the observation and forecast to check and verify the results.
Can you write Python code for it?

plt.plot(obs, '--', label='truth')
plt.plot(short_obs, '--', label='obs')
plt.plot(short_decomp.trend, ':', label='decomp.trend')
plt.plot(fcast, '-', label=fcast.columns[0])

plt.xlim('1970','2004'); plt.ylim(330,380);
plt.legend();


I am working on the file "STL-usage-example.ipynb".
The first task is:
The forecast() method requires the following arguments:
- the previously fit DecomposeResult
- the number of steps forward for which we'd like the forecast
- the specific forecasting function to be applied to the decomposition
There are a handful of predefined functions that can be imported from the stldecompose.forecast_funcs module. These implementations are based on Hyndman's online textbook. The user can also define their own forecast function, following the patterns demonstrated in the predefined functions.
The return type of the forecast() method is a pandas.Dataframe with a column name that represents the forecast function and an appropriate DatetimeIndex.
Can you write Python code for it?

fcast = forecast(short_decomp, steps=8000, fc_func=drift)

fcast.head()


I am working on the file "STL-usage-example.ipynb".
The first task is:
To include the estimated seasonal component in the forecast, use the boolean seasonal keyword.
Can you write Python code for it?

fcast = forecast(short_decomp, steps=8000, fc_func=drift, seasonal=True)

plt.plot(obs, '--', label='truth')
plt.plot(short_obs, '--', label='obs')
plt.plot(short_decomp.trend, ':', label='decomp.trend')
plt.plot(fcast, '-', label=fcast.columns[0])

plt.xlim('1970','2004'); plt.ylim(330,380);
plt.legend();

fcast.head()


I am working on the file "STL-usage-example.ipynb".
The first task is:
We'll use some of the data that comes pre-packaged with statsmodels to demonstrate the library functionality. The data set below comprises incomplete, daily measurements of CO2 levels in Hawaii.
Note: at the time of this writing, the current release of statsmodels includes a utility method for loading these datasets as a pandas.DataFrame which appears to be broken. Below is a short hack inspired by the current master branch on the statsmodels GitHub page.
Can you write Python code for it?

def get_statsmodels_df():
    """Return packaged data in a pandas.DataFrame"""
    # some hijinks to get around outdated statsmodels code
    dataset = sm.datasets.co2.load()
    start = dataset.data['date'][0].decode('utf-8')
    index = pd.date_range(start=start, periods=len(dataset.data), freq='W-SAT')
    obs = pd.DataFrame(dataset.data['co2'], index=index, columns=['co2'])
    return obs

obs = get_statsmodels_df()
obs.head()


I am working on the file "STN with Python.ipynb".
The first task is:
And wen can again check the resulting schedules (remember events are counted from from_t):
Can you write Python code for it?


I am working on the file "STN with Python.ipynb".
The first task is:
Attained objective:
Can you write Python code for it?


I am working on the file "STN with Python.ipynb".
The first task is:
Plot the robust schedule
Can you write Python code for it?


I am working on the file "STN with Python.ipynb".
The first task is:
The module robust_STN.py provides two functions to generate appropriate uncertainty sets:
* robust_STN.build_uncertainty_set_for_time_delay(units=(0,), tasks=(0,), delay=1, from_t=0, to_t=T)
* robust_STN.build_uncertainty_set_for_unit_swap(from_unit=2, to_unit=1, tasks=(1,), from_t=0, to_t=T)
Below some examples of how they can be used. These are sufficient to reproduce the results in [1].
Delay Example #1: Heater Delay
We first produce a robust schedule that is immune to possible time delays of the heater (unit=0), when performing heating (task=0), of at most 1 time step (delay=1), which can happen anytime in the scheduling horizon (from_t and to_t assigned default values)
Can you write Python code for it?

rSTN.W = rSTN.build_uncertainty_set_for_time_delay(units=(0,), tasks=(0,), delay=1)
rSTN.solve()


I am working on the file "STN with Python.ipynb".
The first task is:
We can then simulate an uncertain event, and see how the schedule has to be adapted to accommodate it.
* The important feature to observe is that events are accommodated without disrupting the core of the schedule (assignments), but just by regulating processed quantities.
* Note also that no more heavy computations are required to calculate the adapted schedule.
Can you write Python code for it?

rSTN.simulate_uncertain_event(event=[0,0,0], column=1)
rSTN.simulate_uncertain_event(event=[0,0,5], column=1)


I am working on the file "STN with Python.ipynb".
The first task is:
We instantiate the nominal model and solve it using the default solver (Gurobi).
The data of the nominal model can be changed from within STN.__init__().
Can you write Python code for it?


I am working on the file "STN with Python.ipynb".
The first task is:
We see that the optimizer does not schedule any reaction 3 on reactor 2. In the above plots we can also inspect how the schedule has to be adjusted when the delay does occur.
Unit Swap Example: swap processing of Reaction 2, from Reactor 1 to Reactor 2, starting from t = 4h
Can you write Python code for it?

rSTN.W = rSTN.build_uncertainty_set_for_unit_swap(from_unit=1, to_unit=2, tasks=(2,), from_t=4)
rSTN.solve()


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(b)
Glavna prednost L1-regularizirane regresije (ili LASSO regression) nad L2-regulariziranom regresijom jest u tome što L1-regularizirana regresija rezultira rijetkim modelima (engl. sparse models), odnosno modelima kod kojih su mnoge težine pritegnute na nulu. Pokažite da je to doista tako, ponovivši gornji eksperiment s L1-regulariziranom regresijom, implementiranom u klasi  Lasso u modulu sklearn.linear_model. Zanemarite upozorenja.
Can you write Python code for it?


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(b)
Kao u zadataku 3b, razdvojite primjere na skup za učenje i skup za ispitivanje u omjeru 1:1. Prikažite krivulje logaritama pogreške učenja i ispitne pogreške u ovisnosti za model $\mathcal{H}_{d=10,\lambda}$, podešavajući faktor regularizacije $\lambda$ u rasponu $\lambda\in{0,1,\dots,50}$.
Q: Kojoj strani na grafikonu odgovara područje prenaučenosti, a kojoj podnaučenosti? Zašto?
Q: Koju biste vrijednosti za $\lambda$ izabrali na temelju ovih grafikona i zašto?
Can you write Python code for it?

# Vaš kôd ovdje

xTr, xTest, yTr, yTest = train_test_split(X2, y2, test_size=0.5)
figure(figsize=(10,10))
trainError = []
testError = []

for lambd in range(0,51):

    polyXTrain = PolynomialFeatures(10).fit_transform(xTr)
    polyXTest = PolynomialFeatures(10).fit_transform(xTest)

    l2 = Ridge(lambd).fit(polyXTrain, yTr)
    h2 = l2.predict(polyXTest)

    E = mt.mean_squared_error(h2, yTest)
    #print('d: ' + str(d) + ' E: ' + str(E))
    testError.append(log( E))

    h2 = l2.predict(polyXTrain)
    E = mt.mean_squared_error(h2, yTr)
    trainError.append(log(E))
    #print(p3)
    #plot(polyXTest, h2, label = str(d))

plot(numpy.log(numpy.array(testError)), label="test")
plot(numpy.log(numpy.array(trainError)), label="train")
legend()


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(b)
Trenirajte model polinomijalne regresije stupnja $d=3$. Na istom grafikonu prikažite naučeni model $h(\mathbf{x})=\mathbf{w}^\intercal\tilde{\mathbf{x}}$ i primjere za učenje. Izračunajte pogrešku učenja modela.
Can you write Python code for it?

# Vaš kôd ovdje
import sklearn.linear_model as lm

def polyX(d):

    p3 = PolynomialFeatures(d).fit_transform(X2)
    l2 = LinearRegression().fit(p3, y2)
    h2 = l2.predict(p3)

    E = mt.mean_squared_error(h2, y2)
    print('d: ' + str(d) + ' E: ' + str(E))
    #print(p3)
    plot(X2, h2, label = str(d))

scatter(X2, y2)
polyX(3)


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(c)
Točnost modela ovisi o (1) njegovoj složenosti (stupanj $d$ polinoma), (2) broju primjera $N$, i (3) količini šuma. Kako biste to analizirali, nacrtajte grafikone pogrešaka kao u 3b, ali za sve kombinacija broja primjera $N\in{100,200,1000}$ i količine šuma $\sigma\in{100,200,500}$ (ukupno 9 grafikona). Upotrijebite funkciju subplots kako biste pregledno posložili grafikone u tablicu $3\times 3$. Podatci se generiraju na isti način kao u zadatku 2.
NB: Pobrinite se da svi grafikoni budu generirani nad usporedivim skupovima podataka, na sljedeći način. Generirajte najprije svih 1000 primjera, podijelite ih na skupove za učenje i skupove za ispitivanje (dva skupa od po 500 primjera). Zatim i od skupa za učenje i od skupa za ispitivanje načinite tri različite verzije, svaka s drugačijom količinom šuma (ukupno 2x3=6 verzija podataka). Kako bi simulirali veličinu skupa podataka, od tih dobivenih 6 skupova podataka uzorkujte trećinu, dvije trećine i sve podatke. Time ste dobili 18 skupova podataka -- skup za učenje i za testiranje za svaki od devet grafova.
Can you write Python code for it?

# Vaš kôd ovdje

# Vaš kôd ovdje
figure(figsize=(15,15))

N = 1000
def f(x):
    return 5 + x - 2*x*x - 5*x*x*x

X3 = make_instances(-5, 5, N)

xAllTrain, xAllTest = train_test_split(X3, test_size=0.5)
i = 0
j = 0

for N in [100, 200, 1000]:
    for noise in [100, 200, 500]:
        j += 1

        xTrain = xAllTrain[:N]
        xTest = xAllTest[:N]
        yTrain = make_labels(xTrain, f, noise)
        yTest = make_labels(xTest, f, noise)

        trainError = []
        testError = []

        for d in range(1,21):

            polyXTrain = PolynomialFeatures(d).fit_transform(xTrain)
            polyXTest = PolynomialFeatures(d).fit_transform(xTest)

            l2 = LinearRegression().fit(polyXTrain, yTrain)
            h2 = l2.predict(polyXTest)

            testE = mt.mean_squared_error(h2, yTest)
            testError.append(testE)

            h2 = l2.predict(polyXTrain)
            trainE = mt.mean_squared_error(h2, yTrain)
            trainError.append(trainE)
            #print('d: ' + str(d) + ' E: ' + str(E))
            #print(p3)
            #plot(polyXTest, h2, label = str(d))

        subplot(3,3,j, title = "N: " + str(N) + " noise: " + str(noise))
        plot(numpy.log(numpy.array(trainError)), label = 'train')
        plot(numpy.log(numpy.array(testError)), label = 'test')
        plt.legend(loc="center right")

#print(X)
#print(y)

#s = scatter(X2, y2)


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
2. Polinomijalna regresija i utjecaj šuma
(a)
Razmotrimo sada regresiju na većem broju primjera. Definirajte funkciju make_labels(X, f, noise=0) koja uzima matricu neoznačenih primjera $\mathbf{X}{N\times n}$ te generira vektor njihovih oznaka $\mathbf{y}{N\times 1}$. Oznake se generiraju kao $y^{(i)} = f(x^{(i)})+\mathcal{N}(0,\sigma^2)$, gdje je $f:\mathbb{R}^n\to\mathbb{R}$ stvarna funkcija koja je generirala podatke (koja nam je u stvarnosti nepoznata), a $\sigma$ je standardna devijacija Gaussovog šuma, definirana parametrom noise. Za generiranje šuma možete koristiti funkciju numpy.random.normal.
Generirajte skup za učenje od $N=50$ primjera uniformno distribuiranih u intervalu $[-5,5]$ pomoću funkcije $f(x) = 5 + x -2 x^2 -5 x^3$ uz šum  $\sigma=200$:
Can you write Python code for it?

from numpy.random import normal

def make_labels(X, f, noise=0) :
    # Vaš kôd ovdje
    N = numpy.random.normal
    fx = f(X)
    #nois = [N(0, noise) for _ in range(X.shape[0])]
    #print(nois)
    #y = f(X) + nois
    y = [ f(x) + N(0, noise) for x in X ]

    return y

def make_instances(x1, x2, N) :
    return np.array([np.array([x]) for x in np.linspace(x1,x2,N)])


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
3. Odabir modela
(a)
Na skupu podataka iz zadatka 2 trenirajte pet modela linearne regresije $\mathcal{H}_d$ različite složenosti, gdje je $d$ stupanj polinoma, $d\in{1,3,5,10,20}$. Prikažite na istome grafikonu skup za učenje i funkcije $h_d(\mathbf{x})$ za svih pet modela (preporučujemo koristiti plot unutar for petlje). Izračunajte pogrešku učenja svakog od modela.
Q: Koji model ima najmanju pogrešku učenja i zašto?
Can you write Python code for it?

# Vaš kôd ovdje
figure(figsize=(15,10))
scatter(X2, y2)
polyX(1)
polyX(3)
polyX(5)
polyX(10)
polyX(20)

s = plt.legend(loc="center right")


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
6. L1-regularizacija i L2-regularizacija
Svrha regularizacije jest potiskivanje težina modela $\mathbf{w}$ prema nuli, kako bi model bio što jednostavniji. Složenost modela može se okarakterizirati normom pripadnog vektora težina $\mathbf{w}$, i to tipično L2-normom ili L1-normom. Za jednom trenirani model možemo izračunati i broj ne-nul značajki, ili L0-normu, pomoću sljedeće funkcije koja prima vektor težina $\mathbf{w}$:
Can you write Python code for it?

def nonzeroes(coef, tol=1e-6):
    return len(coef) - len(coef[np.isclose(0, coef, atol=tol)])


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
7. Značajke različitih skala
Često se u praksi možemo susreti sa podatcima u kojima sve značajke nisu jednakih magnituda. Primjer jednog takvog skupa je regresijski skup podataka grades u kojem se predviđa prosjek ocjena studenta na studiju (1--5) na temelju dvije značajke: bodova na prijamnom ispitu (1--3000) i prosjeka ocjena u srednjoj školi. Prosjek ocjena na studiju izračunat je kao težinska suma ove dvije značajke uz dodani šum.
Koristite sljedeći kôd kako biste generirali ovaj skup podataka.
Can you write Python code for it?

n_data_points = 500
np.random.seed(69)

# Generiraj podatke o bodovima na prijamnom ispitu koristeći normalnu razdiobu i ograniči ih na interval [1, 3000].
exam_score = np.random.normal(loc=1500.0, scale = 500.0, size = n_data_points)
exam_score = np.round(exam_score)
exam_score[exam_score > 3000] = 3000
exam_score[exam_score < 0] = 0

# Generiraj podatke o ocjenama iz srednje škole koristeći normalnu razdiobu i ograniči ih na interval [1, 5].
grade_in_highschool = np.random.normal(loc=3, scale = 2.0, size = n_data_points)
grade_in_highschool[grade_in_highschool > 5] = 5
grade_in_highschool[grade_in_highschool < 1] = 1

# Matrica dizajna.
grades_X = np.array([exam_score,grade_in_highschool]).T

# Završno, generiraj izlazne vrijednosti.
rand_noise = np.random.normal(loc=0.0, scale = 0.5, size = n_data_points)
exam_influence = 0.9
grades_y = ((exam_score / 3000.0) * (exam_influence) + (grade_in_highschool / 5.0) \
            * (1.0 - exam_influence)) * 5.0 + rand_noise
grades_y[grades_y < 1] = 1
grades_y[grades_y > 5] = 5


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Ponovno, naučite na ovom skupu L2-regularizirani model regresije ($\lambda = 0.01$).
Can you write Python code for it?


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Prikažite taj skup funkcijom scatter.
Can you write Python code for it?

# Vaš kôd ovdje
N = 50
def f(x):
    return 5 + x - 2*x*x - 5*x*x*x
noise = 200

X2 = make_instances(-5, 5, N)
y2 = make_labels(X2, f, noise)

#print(X)
#print(y)

s = scatter(X2, y2)


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Radi jasnoće, u nastavku je vektor $\mathbf{x}$ s dodanom dummy jedinicom $x_0=1$ označen kao $\tilde{\mathbf{x}}$.
(c)
Prikažite primjere iz $\mathcal{D}$ i funkciju $h(\tilde{\mathbf{x}})=\mathbf{w}^\intercal\tilde{\mathbf{x}}$. Izračunajte pogrešku učenja prema izrazu $E(h|\mathcal{D})=\frac{1}{2}\sum_{i=1}^N(\tilde{\mathbf{y}}^{(i)} - h(\tilde{\mathbf{x}}))^2$. Možete koristiti funkciju srednje kvadratne pogreške mean_squared_error iz modula sklearn.metrics.
Q: Gore definirana funkcija pogreške $E(h|\mathcal{D})$ i funkcija srednje kvadratne pogreške nisu posve identične. U čemu je razlika? Koja je "realnija"?
Can you write Python code for it?

import sklearn.metrics as mt

wt = w #(np.array([w]))

print(wt)
print(phi)

hx = np.dot(phi, w)

E = mt.mean_squared_error(hx, y)
print(E)

# Vaš kôd ovdje


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Sada ponovite gornji eksperiment, ali prvo skalirajte podatke grades_X i grades_y i spremite ih u varijable grades_X_fixed i grades_y_fixed. Za tu svrhu, koristite StandardScaler.
Can you write Python code for it?

from sklearn.preprocessing import StandardScaler

# Vaš kôd ovdje


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Zadatci
1. Jednostavna regresija
Zadan je skup primjera $\mathcal{D}={(x^{(i)},y^{(i)})}_{i=1}^4 = {(0,4),(1,1),(2,2),(4,5)}$. Primjere predstavite matrixom $\mathbf{X}$ dimenzija $N\times n$ (u ovom slučaju $4\times 1$) i vektorom oznaka $\textbf{y}$, dimenzija $N\times 1$ (u ovom slučaju $4\times 1$), na sljedeći način:
Can you write Python code for it?


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB01-Regresija-checkpoint.ipynb".
The first task is:
b) Naučite model L2-regularizirane regresije ($\lambda = 0.01$), na podacima grades_X i grades_y:
Can you write Python code for it?


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB02-LDM-LR-checkpoint.ipynb".
The first task is:
(a)
Prvo, isprobajte ugrađeni model na linearno odvojivom skupu podataka seven ($N=7$).
Can you write Python code for it?


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB02-LDM-LR-checkpoint.ipynb".
The first task is:
(b)
Trenirajte model logističke regresije na skupu seven te na dva odvojena grafikona prikažite, kroz iteracije optimizacijskoga algoritma, (1) izlaz modela $h(\mathbf{x})$ za svih sedam primjera te (2) vrijednosti težina $w_0$, $w_1$, $w_2$.
Can you write Python code for it?


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB02-LDM-LR-checkpoint.ipynb".
The first task is:
(c)
Ponovite eksperiment iz podzadatka (b) koristeći linearno neodvojiv skup podataka unsep iz prvog zadatka.
Q: Usporedite grafikone za slučaj linearno odvojivih i linearno neodvojivih primjera te komentirajte razliku.
Can you write Python code for it?


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB02-LDM-LR-checkpoint.ipynb".
The first task is:
3. Logistička regresija
Ovaj zadatak bavi se probabilističkim diskriminativnim modelom, logističkom regresijom, koja je, unatoč nazivu, klasifikacijski model.
Logistička regresija tipičan je predstavnik tzv. poopćenih linearnih modela koji su oblika: $h(\mathbf{x})=f(\mathbf{w}^\intercal\tilde{\mathbf{x}})$. Logistička funkcija za funkciju $f$ koristi tzv. logističku (sigmoidalnu) funkciju $\sigma (x) = \frac{1}{1 + \textit{exp}(-x)}$.
(a)
Definirajte logističku (sigmoidalnu) funkciju $\mathrm{sigm}(x)=\frac{1}{1+\exp(-\alpha x)}$ i prikažite je za $\alpha\in{1,2,4}$.
Can you write Python code for it?


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB02-LDM-LR-checkpoint.ipynb".
The first task is:
5. Regularizirana logistička regresija
Trenirajte model logističke regresije na skupu seven s različitim faktorima L2-regularizacije, $\alpha\in{0,1,10,100}$. Prikažite na dva odvojena grafikona (1) pogrešku unakrsne entropije te (2) L2-normu vektora $\mathbf{w}$ kroz iteracije optimizacijskog algoritma.
Q: Jesu li izgledi krivulja očekivani i zašto?
Q: Koju biste vrijednost za $\alpha$ odabrali i zašto?
Can you write Python code for it?

from numpy.linalg import norm

# Vaš kôd ovdje


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB02-LDM-LR-checkpoint.ipynb".
The first task is:
6. Logistička regresija s funkcijom preslikavanja
Proučite funkciju datasets.make_classification. Generirajte i prikažite dvoklasan skup podataka s ukupno $N=100$ dvodimenzijskih ($n=2)$ primjera, i to sa dvije grupe po klasi (n_clusters_per_class=2). Malo je izgledno da će tako generiran skup biti linearno odvojiv, međutim to nije problem jer primjere možemo preslikati u višedimenzijski prostor značajki pomoću klase preprocessing.PolynomialFeatures, kao što smo to učinili kod linearne regresije u prvoj laboratorijskoj vježbi. Trenirajte model logističke regresije koristeći za preslikavanje u prostor značajki polinomijalnu funkciju stupnja $d=2$ i stupnja $d=3$. Prikažite dobivene granice između klasa. Možete koristiti svoju implementaciju, ali se radi brzine preporuča koristiti linear_model.LogisticRegression. Regularizacijski faktor odaberite po želji.
NB: Kao i ranije, za prikaz granice između klasa koristite funkciju plot_2d_clf_problem. Funkciji kao argumente predajte izvorni skup podataka, a preslikavanje u prostor značajki napravite unutar poziva funkcije h koja čini predikciju, na sljedeći način:
Can you write Python code for it?

from sklearn.preprocessing import PolynomialFeatures

#poly = PolynomialFeatures(2)
#...
#mlutils.plot_2d_clf_problem(X, y, lambda x : model.predict(poly.transform(x))

# Vaš kôd ovdje


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB02-LDM-LR-checkpoint.ipynb".
The first task is:
Kako bi se uvjerili da se u isprobanoj implementaciji ne radi o ničemu doli o običnoj linearnoj regresiji, napišite kôd koji dolazi do jednakog rješenja korištenjem isključivo razreda LinearRegression. Funkciju za predikciju, koju predajete kao treći argument h funkciji plot_2d_clf_problem, možete definirati lambda-izrazom: lambda x : model.predict(x) >= 0.5.
Can you write Python code for it?


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB02-LDM-LR-checkpoint.ipynb".
The first task is:
Q: Kako bi bila definirana granica između klasa ako bismo koristili oznake klasa $-1$ i $1$ umjesto $0$ i $1$?
(b)
Probajte isto na linearno odvojivom skupu podataka outlier ($N=8$):
Can you write Python code for it?

outlier_X = np.append(seven_X, [[12,8]], axis=0)
outlier_y = np.append(seven_y, 0)

# Vaš kôd ovdje


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB02-LDM-LR-checkpoint.ipynb".
The first task is:
Q: Koji kriterij zaustavljanja je aktiviran?
Q: Zašto dobivena pogreška unakrsne entropije nije jednaka nuli?
Q: Kako biste utvrdili da je optimizacijski postupak doista pronašao hipotezu koja minimizira pogrešku učenja? O čemu to ovisi?
Q: Na koji način biste preinačili kôd ako biste htjeli da se optimizacija izvodi stohastičkim gradijentnim spustom (online learning)?
(d)
Prikažite na jednom grafikonu pogrešku unakrsne entropije (očekivanje logističkog gubitka) i pogrešku klasifikacije (očekivanje gubitka 0-1) na skupu seven kroz iteracije optimizacijskog postupka. Koristite trag težina funkcije lr_train iz zadatka (b) (opcija trace=True). Na drugom grafikonu prikažite pogrešku unakrsne entropije kao funkciju broja iteracija za različite stope učenja, $\eta\in{0.005,0.01,0.05,0.1}$.
Can you write Python code for it?


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB02-LDM-LR-checkpoint.ipynb".
The first task is:
Q: Zašto je pogreška unakrsne entropije veća od pogreške klasifikacije? Je li to uvijek slučaj kod logističke regresije i zašto?
Q: Koju stopu učenja $\eta$ biste odabrali i zašto?
(e)
Upoznajte se s klasom linear_model.LogisticRegression koja implementira logističku regresiju. Usporedite rezultat modela na skupu seven s rezultatom koji dobivate pomoću vlastite implementacije algoritma.
NB: Kako ugrađena implementacija koristi naprednije verzije optimizacije funkcije, vrlo je vjerojatno da Vam se rješenja neće poklapati, ali generalne performanse modela bi trebale. Ponovno, pripazite na broj iteracija i snagu regularizacije.
Can you write Python code for it?

from sklearn.linear_model import LogisticRegression

# Vaš kôd ovdje


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB02-LDM-LR-checkpoint.ipynb".
The first task is:
Q: Zašto model ne ostvaruje potpunu točnost iako su podatci linearno odvojivi?
(c)
Završno, probajte isto na linearno neodvojivom skupu podataka unsep ($N=8$):
Can you write Python code for it?

unsep_X = np.append(seven_X, [[2,2]], axis=0)
unsep_y = np.append(seven_y, 0)

# Vaš kôd ovdje


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB02-LDM-LR-checkpoint.ipynb".
The first task is:
Trenirajte tri binarna klasifikatora, $h_1$, $h_2$ i $h_3$ te prikažite granice između klasa (tri grafikona). Zatim definirajte $h(\mathbf{x})=\mathrm{argmax}_j h_j(\mathbf{x})$  (napišite svoju funkciju predict koja to radi) i prikažite granice između klasa za taj model. Zatim se uvjerite da biste identičan rezultat dobili izravno primjenom modela RidgeClassifier, budući da taj model za višeklasan problem zapravo interno implementira shemu jedan-naspram-ostali.
Q: Alternativna shema jest ona zvana jedan-naspram-jedan (engl, one-vs-one, OVO). Koja je prednost sheme OVR nad shemom OVO? A obratno?
Can you write Python code for it?


I am working on the file "STRUCE/.ipynb_checkpoints/SU-2019-LAB02-LDM-LR-checkpoint.ipynb".
The first task is:
Zadatci
1. Linearna regresija kao klasifikator
U prvoj laboratorijskoj vježbi koristili smo model linearne regresije za, naravno, regresiju. Međutim, model linearne regresije može se koristiti i za klasifikaciju. Iako zvuči pomalo kontraintuitivno, zapravo je dosta jednostavno. Naime, cilj je naučiti funkciju $f(\mathbf{x})$ koja za negativne primjere predviđa vrijednost $1$, dok za pozitivne primjere predviđa vrijednost $0$. U tom slučaju, funkcija $f(\mathbf{x})=0.5$ predstavlja granicu između klasa, tj. primjeri za koje vrijedi $h(\mathbf{x})\geq 0.5$ klasificiraju se kao pozitivni, dok se ostali klasificiraju kao negativni.
Klasifikacija pomoću linearne regresije implementirana je u razredu RidgeClassifier. U sljedećim podzadatcima istrenirajte taj model na danim podatcima i prikažite dobivenu granicu između klasa. Pritom isključite regularizaciju ($\alpha = 0$, odnosno alpha=0). Također i ispišite točnost vašeg klasifikacijskog modela (smijete koristiti funkciju metrics.accuracy_score). Skupove podataka vizualizirajte korištenjem pomoćne funkcije plot_clf_problem(X, y, h=None) koja je dostupna u pomoćnom paketu mlutils (datoteku mlutils.py možete preuzeti sa stranice kolegija). X i y predstavljaju ulazne primjere i oznake, dok h predstavlja funkciju predikcije modela (npr. model.predict).
U ovom zadatku cilj je razmotriti kako se klasifikacijski model linearne regresije ponaša na linearno odvojim i neodvojivim podatcima.
Can you write Python code for it?

from sklearn.linear_model import LinearRegression, RidgeClassifier
from sklearn.metrics import accuracy_score


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(a)
Proučite funkciju PolynomialFeatures iz biblioteke sklearn i upotrijebite je za generiranje matrice dizajna $\mathbf{\Phi}$ koja ne koristi preslikavanje u prostor više dimenzije (samo će svakom primjeru biti dodane dummy jedinice; $m=n+1$).
Can you write Python code for it?

from sklearn.preprocessing import PolynomialFeatures
Phi = PolynomialFeatures(1, False, True).fit_transform(X)
print(Phi)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(b)
Kao u zadataku 3b, razdvojite primjere na skup za učenje i skup za ispitivanje u omjeru 1:1. Prikažite krivulje logaritama pogreške učenja i ispitne pogreške u ovisnosti za model $\mathcal{H}_{d=20,\lambda}$, podešavajući faktor regularizacije $\lambda$ u rasponu $\lambda\in{0,1,\dots,50}$.
Q: Kojoj strani na grafikonu odgovara područje prenaučenosti, a kojoj podnaučenosti? Zašto?
Q: Koju biste vrijednosti za $\lambda$ izabrali na temelju ovih grafikona i zašto?
Can you write Python code for it?

X5a_train, X5a_test, y5a_train, y5a_test = cross_validation.train_test_split(x5a, y5a, test_size = 0.5)
err5a_train = [];
err5a_test = [];
d = 20;
lambda5a = range(0, 50)

for i in lambda5a:
    Phi5a_train = PolynomialFeatures(d).fit_transform(X5a_train.reshape(-1, 1))
    Phi5a_test = PolynomialFeatures(d).fit_transform(X5a_test.reshape(-1, 1))
    w5a_train = np.dot(np.dot(np.linalg.inv(np.dot(Phi5a_train.T, Phi5a_train) + np.dot(i, np.eye(d+1))), Phi5a_train.T), y5a_train);
    h5a_train = np.dot(Phi5a_train, w5a_train)
    h5a_test = np.dot(Phi5a_test, w5a_train)

    err5a_train.insert(i, np.log(mean_squared_error(y5a_train, h5a_train)))
    err5a_test.insert(i, np.log(mean_squared_error(y5a_test, h5a_test)))

plt.figure(figsize=(8,4))
plt.plot(lambda5a, err5a_train, lambda5a, err5a_test);
plt.grid(), plt.xlabel('$\lambda$'), plt.ylabel('err');
plt.legend(['Greska ucenja', 'Ispitna pogreska'], loc='best');


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(b)
Proučite klasu Ridge iz modula sklearn.linear_model, koja implementira L2-regularizirani regresijski model. Parametar $\alpha$ odgovara parametru $\lambda$. Primijenite model na istim primjerima kao u prethodnom zadatku i ispišite težine $\mathbf{w}$ (atributi coef_ i intercept_).
Q: Jesu li težine identične onima iz zadatka 4a? Ako nisu, objasnite zašto je to tako i kako biste to popravili.
Can you write Python code for it?

from sklearn.linear_model import Ridge

for i in lam:
    w_foo = [];
    w_L22 = Ridge(alpha = i).fit(Phi3d, y)

    w_foo.append(w_L22.intercept_)
    for i in range(0, len(w_L22.coef_[1:])):
        w_foo.append(w_L22.coef_[i])

    print (w_foo)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(b)
Razdvojite skup primjera iz zadatka 2 pomoću funkcije cross_validation.train_test_split na skup za učenja i skup za ispitivanje u omjeru 1:1. Prikažite na jednom grafikonu pogrešku učenja i ispitnu pogrešku za modele polinomijalne regresije $\mathcal{H}_d$, sa stupnjem polinoma $d$ u rasponu $d\in [1,2,\ldots,20]$. Radi preciznosti, funkcije $h(\mathbf{x})$ iscrtajte na cijelom skupu primjera (ali pogrešku generalizacije računajte, naravno, samo na ispitnome skupu). Budući da kvadratna pogreška brzo raste za veće stupnjeve polinoma, umjesto da iscrtate izravno iznose pogrešaka, iscrtajte njihove logaritme.
NB: Podjela na skupa za učenje i skup za ispitivanje mora za svih pet modela biti identična.
Q: Je li rezultat u skladu s očekivanjima? Koji biste model odabrali i zašto?
Q: Pokrenite iscrtavanje više puta. U čemu je problem? Bi li problem bio jednako izražen kad bismo imali više primjera? Zašto?
Can you write Python code for it?

from sklearn import cross_validation

X_train, X_test, y_train, y_test = cross_validation.train_test_split(x, y, test_size = 0.5)
err_train = [];
err_test = [];
d = range(0, 20)

for i in d:
    Phi_train = PolynomialFeatures(i).fit_transform(X_train.reshape(-1, 1))
    Phi_test = PolynomialFeatures(i).fit_transform(X_test.reshape(-1, 1))
    w_train = np.dot(np.linalg.pinv(Phi_train), y_train)
    h_train = np.dot(Phi_train, w_train)
    h_test = np.dot(Phi_test, w_train)

    err_train.insert(i, np.log(mean_squared_error(y_train, h_train)))
    err_test.insert(i, np.log(mean_squared_error(y_test, h_test)))

plt.figure(figsize=(10,5))
plt.plot(d, err_train, d, err_test)
plt.grid()


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(b)
Trenirajte model polinomijalne regresije stupnja $d=3$. Na istom grafikonu prikažite naučeni model $h(\mathbf{x})=\mathbf{w}^\intercal\tilde{\mathbf{x}}$ i primjere za učenje. Izračunajte pogrešku učenja modela.
Can you write Python code for it?

from sklearn.preprocessing import PolynomialFeatures

Phi = PolynomialFeatures(3).fit_transform(x.reshape(-1, 1))
w = np.dot(np.linalg.pinv(Phi), y)
h = np.dot(Phi, w)
error = mean_squared_error(y, h)
print('error: ', error)

plt.figure(figsize=(10,5))
plt.grid()
plt.scatter(x, y)
plt.plot(x, h, 'r', linewidth=1)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(b)
Upoznajte se s modulom linalg. Izračunajte težine $\mathbf{w}$ modela linearne regresije kao $\mathbf{w}=(\mathbf{\Phi}^\intercal\mathbf{\Phi})^{-1}\mathbf{\Phi}^\intercal\mathbf{y}$. Zatim se uvjerite da isti rezultat možete dobiti izračunom pseudoinverza $\mathbf{\Phi}^+$ matrice dizajna, tj. $\mathbf{w}=\mathbf{\Phi}^+\mathbf{y}$, korištenjem funkcije pinv.
Can you write Python code for it?

from numpy import linalg

w = np.dot(np.dot(np.linalg.inv(np.dot(np.transpose(Phi), Phi)), np.transpose(Phi)), y)
print('w = ', w)

w2 = np.dot(np.linalg.pinv(Phi), y)
print('w = ', w2)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(c)
Točnost modela ovisi o (1) njegovoj složenosti (stupanj $d$ polinoma), (2) broju primjera $N$, i (3) količini šuma. Kako biste to analizirali, nacrtajte grafikone pogrešaka kao u 3b, ali za sve kombinacija broja primjera $N\in{100,200,1000}$ i količine šuma $\sigma\in{100,200,500}$ (ukupno 9 grafikona). Upotrijebite funkciju subplots kako biste pregledno posložili grafikone u tablicu $3\times 3$. Podatci se generiraju na isti način kao u zadatku 2.
NB: Pobrinite se da svi grafikoni budu generirani nad usporedivim skupovima podataka, na sljedeći način. Generirajte najprije svih 1000 primjera, podijelite ih na skupove za učenje i skupove za ispitivanje (dva skupa od po 500 primjera). Zatim i od skupa za učenje i od skupa za ispitivanje načinite tri različite verzije, svaka s drugačijom količinom šuma (ukupno 2x3=6 verzija podataka). Kako bi simulirali veličinu skupa podataka, od tih dobivenih 6 skupova podataka uzorkujte trećinu, dvije trećine i sve podatke. Time ste dobili 18 skupova podataka -- skup za učenje i za testiranje za svaki od devet grafova.
Q: Jesu li rezultati očekivani? Obrazložite.
Can you write Python code for it?

N2 = [100, 200, 1000];
sigma = [100, 200, 500];

X_train4c_temp = [];
X_test4c_temp = [];
y_train4c_temp = [];
y_test4c_temp = [];

x_tmp = np.linspace(-5, 5, 1000);
X_train, X_test = cross_validation.train_test_split(x_tmp, test_size = 0.5)

for i in range(0, 3):

    y_tmp_train = list(make_labels(X_train, fun, sigma[i]))
    y_tmp_test = list(make_labels(X_test, fun, sigma[i]))
    for j in range(0,3):
        X_train4c_temp.append(X_train[0:int(N2[j]/2)])
        X_test4c_temp.append(X_test[0:int(N2[j]/2)])
        y_train4c_temp.append(y_tmp_train[0:int(N2[j]/2)])
        y_test4c_temp.append(y_tmp_test[0:int(N2[j]/2)])

err_tr = [];
err_tst = [];

for i in range(0, 9):
    X_train4c = X_train4c_temp[i]
    X_test4c = X_test4c_temp[i]
    y_train4c = y_train4c_temp[i]
    y_test4c = y_test4c_temp[i]

    err_train4c = [];
    err_test4c = [];
    d4c = range(0, 20)

    for j in d4c:
        Phi_train4c = PolynomialFeatures(j).fit_transform(X_train4c.reshape(-1, 1))
        Phi_test4c = PolynomialFeatures(j).fit_transform(X_test4c.reshape(-1, 1))
        w_train4c = np.dot(np.linalg.pinv(Phi_train4c), y_train4c)
        h_train4c = np.dot(Phi_train4c, w_train4c)
        h_test4c = np.dot(Phi_test4c, w_train4c)
        err_train4c.insert(j, np.log(mean_squared_error(y_train4c, h_train4c)))
        err_test4c.insert(j, np.log(mean_squared_error(y_test4c, h_test4c)))

    err_tr.append(err_train4c);
    err_tst.append(err_test4c);

fig = plt.figure(figsize=(15, 10))
fig.subplots_adjust(wspace=0.2, hspace = 0.35)

Nn = [100, 200, 1000, 100, 200, 1000, 100, 200, 1000]
sgm = [100, 100, 100, 200, 200, 200, 500, 500, 500]

for i in range(0, 9):
    ax = fig.add_subplot(3, 3, i+1)
    plt.plot(d, err_tr[i], d, err_tst[i]); grid;
    ax.grid();


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(d)
Uvjerite se da za primjere iz $\mathcal{D}$ težine $\mathbf{w}$ ne možemo naći rješavanjem sustava $\mathbf{w}=\mathbf{\Phi}^{-1}\mathbf{y}$, već da nam doista treba pseudoinverz.
Q: Zašto je to slučaj? Bi li se problem mogao riješiti preslikavanjem primjera u višu dimenziju? Ako da, bi li to uvijek funkcioniralo, neovisno o skupu primjera $\mathcal{D}$? Pokažite na primjeru.
Can you write Python code for it?

try:
    np.dot(np.linalg.inv(Phi), y)
except LinAlgError as err:
    print(err)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(e)
Proučite klasu LinearRegression iz modula sklearn.linear_model. Uvjerite se da su težine koje izračunava ta funkcija (dostupne pomoću atributa coef_ i intercept_) jednake onima koje ste izračunali gore. Izračunajte predikcije modela (metoda predict) i uvjerite se da je pogreška učenja identična onoj koju ste ranije izračunali.
Can you write Python code for it?

from sklearn.linear_model import LinearRegression

lr = LinearRegression().fit(Phi, y)

w2 = [lr.intercept_, lr.coef_[1]]
h2 = lr.predict(Phi)
error2 = mean_squared_error(y, h)

print ('old: ')
print (w)
print (h)
print (error)

print('new: ')
print (w2)
print (h2)
print (error2)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
3. Odabir modela
(a)
Na skupu podataka iz zadatka 2 trenirajte pet modela linearne regresije $\mathcal{H}_d$ različite složenosti, gdje je $d$ stupanj polinoma, $d\in{1,3,5,10,20}$. Prikažite na istome grafikonu skup za učenje i funkcije $h_d(\mathbf{x})$ za svih pet modela (preporučujemo koristiti plot unutar for petlje). Izračunajte pogrešku učenja svakog od modela.
Q: Koji model ima najmanju pogrešku učenja i zašto?
Can you write Python code for it?

Phi_d = [];
w_d = [];
h_d = [];
err_d = [];

d = [1, 3, 5, 10, 20]

for i in d:
    Phi_d.append(PolynomialFeatures(i).fit_transform(x.reshape(-1,1)))

for i in range(0, len(d)):
    w_d.insert(i, np.dot(np.linalg.pinv(Phi_d[i]), y))
    h_d.insert(i, np.dot(Phi_d[i], w_d[i]))

for i in range(0, len(d)):
    err_d.insert(i, mean_squared_error(y, h_d[i]))
    print ('error for d=' + str(d[i]) + ': ' + str(err_d[i]))

fig = plt.figure(figsize=(15, 20))
fig.subplots_adjust(wspace=0.2)

for i in range(0, len(d)):

    ax = fig.add_subplot(5, 2, i+1)
    ax.scatter(x, y);
    ax.plot(x, h_d[i], 'r', linewidth = 1)
    ax.grid();


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
4. Regularizirana regresija
(a)
U gornjim eksperimentima nismo koristili regularizaciju. Vratimo se najprije na primjer iz zadatka 1. Na primjerima iz tog zadatka izračunajte težine $\mathbf{w}$ za polinomijalni regresijski model stupnja $d=3$ uz L2-regularizaciju (tzv. ridge regression), prema izrazu $\mathbf{w}=(\mathbf{\Phi}^\intercal\mathbf{\Phi}+\lambda\mathbf{I})^{-1}\mathbf{\Phi}^\intercal\mathbf{y}$. Napravite izračun težina za regularizacijske faktore $\lambda=0$, $\lambda=1$ i $\lambda=10$ te usporedite dobivene težine.
Q: Kojih je dimenzija matrica koju treba invertirati?
Q: Po čemu se razlikuju dobivene težine i je li ta razlika očekivana? Obrazložite.
Can you write Python code for it?

lam = [0, 1, 10]
y = np.array([4,1,2,5])

Phi3d = PolynomialFeatures(3).fit_transform(X)
w_L2 = [];

def w_reg(lam):
    t1 = np.dot(Phi3d.T, Phi3d) + np.dot(lam, np.eye(4))
    t2 = np.dot(np.linalg.inv(t1), Phi3d.T)
    return np.dot(t2, y)

for i in range(0, 3):
    w_L2.insert(i, w_reg(lam[i]))
    print (w_reg(lam[i]))


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
5. Regularizirana polinomijalna regresija
(a)
Vratimo se na slučaj $N=50$ slučajno generiranih primjera iz zadatka 2. Trenirajte modele polinomijalne regresije $\mathcal{H}_{\lambda,d}$ za $\lambda\in{0,100}$ i $d\in{2,10}$ (ukupno četiri modela). Skicirajte pripadne funkcije $h(\mathbf{x})$ i primjere (na jednom grafikonu; preporučujemo koristiti plot unutar for petlje).
Q: Jesu li rezultati očekivani? Obrazložite.
Can you write Python code for it?

x5a = linspace(-5, 5, 50);
f = (5 + x5a - 2*(x5a**2) - 5*(x5a**3));
y5a = f + normal(0, 200, 50);

lamd = [0, 100]
dd = [2, 10]
h5a = []

for i in lamd:
    for j in dd:
        Phi5a = PolynomialFeatures(j).fit_transform(x5a.reshape(-1,1))
        w_5a = np.dot(np.dot(np.linalg.inv(np.dot(Phi5a.T, Phi5a) + np.dot(i, np.eye(j+1))), Phi5a.T), y5a);
        h_5a = np.dot(Phi5a, w_5a)
        h5a.append(h_5a)

lamdd = [0, 0, 100, 100]
ddd = [2, 10, 2, 10]

fig = plt.figure(figsize=(15, 10))
fig.subplots_adjust(wspace=0.2, hspace = 0.2)

for i in range(0, len(lamdd)):
    ax = fig.add_subplot(2, 2, i+1)
    plt.plot(x5a, h5a[i], 'r', linewidth = 2)
    plt.scatter(x5a, y5a); grid()


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
7. Značajke različitih skala
Često se u praksi možemo susreti sa podatcima u kojima sve značajke nisu jednakih magnituda. Primjer jednog takvog skupa je regresijski skup podataka grades u kojem se predviđa prosjek ocjena studenta na studiju (1--5) na temelju dvije značajke: bodova na prijamnom ispitu (1--3000) i prosjeka ocjena u srednjoj školi. Prosjek ocjena na studiju izračunat je kao težinska suma ove dvije značajke uz dodani šum.
Koristite sljedeći kôd kako biste generirali ovaj skup podataka.
Can you write Python code for it?

n_data_points = 500
np.random.seed(69)

# Generiraj podatke o bodovima na prijamnom ispitu koristeći normalnu razdiobu i ograniči ih na interval [1, 3000].
exam_score = np.random.normal(loc=1500.0, scale = 500.0, size = n_data_points)
exam_score = np.round(exam_score)
exam_score[exam_score > 3000] = 3000
exam_score[exam_score < 0] = 0

# Generiraj podatke o ocjenama iz srednje škole koristeći normalnu razdiobu i ograniči ih na interval [1, 5].
grade_in_highschool = np.random.normal(loc=3, scale = 2.0, size = n_data_points)
grade_in_highschool[grade_in_highschool > 5] = 5
grade_in_highschool[grade_in_highschool < 1] = 1

# Matrica dizajna.
grades_X = np.array([exam_score,grade_in_highschool]).T

# Završno, generiraj izlazne vrijednosti.
rand_noise = np.random.normal(loc=0.0, scale = 0.5, size = n_data_points)
exam_influence = 0.9
grades_y = ((exam_score / 3000.0) * (exam_influence) + (grade_in_highschool / 5.0) \
            * (1.0 - exam_influence)) * 5.0 + rand_noise
grades_y[grades_y < 1] = 1
grades_y[grades_y > 5] = 5


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Ponovno, naučite na ovom skupu L2-regularizirani model regresije ($\lambda = 0.01$).
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Prikažite taj skup funkcijom scatter.
Can you write Python code for it?

plt.figure(figsize=(10, 5))
plt.grid()
plt.plot(x, fun(x), 'r', linewidth = 1)
plt.scatter(x, y)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Q: Kako regularizacija utječe na stabilnost težina?
Q: Jesu li koeficijenti jednakih magnituda kao u prethodnom pokusu? Objasnite zašto.
c)
Koristeći numpy.linalg.cond izračunajte kondicijski broj matrice $\mathbf{\Phi}^\intercal\mathbf{\Phi}+\lambda\mathbf{I}$, gdje je $\mathbf{\Phi}$ matrica dizajna (grades_fixed_X_colinear). Ponovite i za $\lambda=0.01$ i za $\lambda=10$.
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Zadatci
1. Jednostavna regresija
Zadan je skup primjera $\mathcal{D}={(x^{(i)},y^{(i)})}_{i=1}^4 = {(0,4),(1,1),(2,2),(4,5)}$. Primjere predstavite matrixom $\mathbf{X}$ dimenzija $N\times n$ (u ovom slučaju $4\times 1$) i vektorom oznaka $\textbf{y}$, dimenzija $N\times 1$ (u ovom slučaju $4\times 1$), na sljedeći način:
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
a)
Iscrtajte ovisnost ciljne vrijednosti (y-os) o prvoj i o drugoj značajki (x-os). Iscrtajte dva odvojena grafa.
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2017-LAB01-Regresija-checkpoint.ipynb".
The first task is:
b)
Naučite model L2-regularizirane regresije ($\lambda = 0.01$), na podacima grades_X i grades_y:
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(a)
Proučite funkciju PolynomialFeatures iz biblioteke sklearn i upotrijebite je za generiranje matrice dizajna $\mathbf{\Phi}$ koja ne koristi preslikavanje u prostor više dimenzije (samo će svakom primjeru biti dodane dummy jedinice; $m=n+1$).
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(a)
Za ovaj zadatak upotrijebite skup za učenje i skup za testiranje iz zadatka 3b. Trenirajte modele L2-regularizirane polinomijalne regresije stupnja $d=20$, mijenjajući hiperparametar $\lambda$ u rasponu ${1,2,\dots,100}$. Za svaki od treniranih modela izračunajte L{0,1,2}-norme vektora težina $\mathbf{w}$ te ih prikažite kao funkciju od $\lambda$.
Q: Objasnite oblik obiju krivulja. Hoće li krivulja za $\|\mathbf{w}\|_2$ doseći nulu? Zašto? Je li to problem? Zašto?
Q: Za $\lambda=100$, koliki je postotak težina modela jednak nuli, odnosno koliko je model rijedak?
Can you write Python code for it?

from sklearn.linear_model import Ridge
from sklearn.linear_model import Lasso

lambda6a = range(1,100)
d6a = 20
X6a_train, X6a_test, y6a_train, y6a_test = train_test_split(x6a, y6a, test_size = 0.5)
Phi6a_train = PolynomialFeatures(d6a).fit_transform(X6a_train.reshape(-1,1))

L0 = [];
L1 = [];
L2 = [];

L1_norm = lambda w: sum(abs(w));
L2_norm = lambda w: math.sqrt(np.dot(w.T, w));

for i in lambda6a:
    w6a = np.dot(np.dot(np.linalg.inv(np.dot(Phi6a_train.T, Phi6a_train) + np.dot(i, np.eye(d6a+1))), Phi6a_train.T), y6a_train);

    L0.append(nonzeroes(w6a))
    L1.append(L1_norm(w6a))
    L2.append(L2_norm(w6a))

plot(lambda6a, L0, lambda6a, L1, lambda6a, L2, linewidth = 1)
grid()


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(b)
Kao u zadataku 3b, razdvojite primjere na skup za učenje i skup za ispitivanje u omjeru 1:1. Prikažite krivulje logaritama pogreške učenja i ispitne pogreške u ovisnosti za model $\mathcal{H}_{d=20,\lambda}$, podešavajući faktor regularizacije $\lambda$ u rasponu $\lambda\in{0,1,\dots,50}$.
Q: Kojoj strani na grafikonu odgovara područje prenaučenosti, a kojoj podnaučenosti? Zašto?
Q: Koju biste vrijednosti za $\lambda$ izabrali na temelju ovih grafikona i zašto?
Can you write Python code for it?

X5a_train, X5a_test, y5a_train, y5a_test = train_test_split(x5a, y5a, test_size = 0.5)
err5a_train = [];
err5a_test = [];
d = 20;
lambda5a = range(0, 50)

for i in lambda5a:
    Phi5a_train = PolynomialFeatures(d).fit_transform(X5a_train.reshape(-1, 1))
    Phi5a_test = PolynomialFeatures(d).fit_transform(X5a_test.reshape(-1, 1))
    w5a_train = np.dot(np.dot(np.linalg.inv(np.dot(Phi5a_train.T, Phi5a_train) + np.dot(i, np.eye(d+1))), Phi5a_train.T), y5a_train);
    h5a_train = np.dot(Phi5a_train, w5a_train)
    h5a_test = np.dot(Phi5a_test, w5a_train)

    err5a_train.insert(i, np.log(mean_squared_error(y5a_train, h5a_train)))
    err5a_test.insert(i, np.log(mean_squared_error(y5a_test, h5a_test)))

plt.figure(figsize=(8,4))
plt.plot(lambda5a, err5a_train, lambda5a, err5a_test);
plt.grid(), plt.xlabel('$\lambda$'), plt.ylabel('err');
plt.legend(['ucenje', 'ispitna'], loc='best');


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(b)
Razdvojite skup primjera iz zadatka 2 pomoću funkcije cross_validation.train_test_split na skup za učenja i skup za ispitivanje u omjeru 1:1. Prikažite na jednom grafikonu pogrešku učenja i ispitnu pogrešku za modele polinomijalne regresije $\mathcal{H}_d$, sa stupnjem polinoma $d$ u rasponu $d\in [1,2,\ldots,20]$. Radi preciznosti, funkcije $h(\mathbf{x})$ iscrtajte na cijelom skupu primjera (ali pogrešku generalizacije računajte, naravno, samo na ispitnome skupu). Budući da kvadratna pogreška brzo raste za veće stupnjeve polinoma, umjesto da iscrtate izravno iznose pogrešaka, iscrtajte njihove logaritme.
NB: Podjela na skupa za učenje i skup za ispitivanje mora za svih pet modela biti identična.
Q: Je li rezultat u skladu s očekivanjima? Koji biste model odabrali i zašto?
Q: Pokrenite iscrtavanje više puta. U čemu je problem? Bi li problem bio jednako izražen kad bismo imali više primjera? Zašto?
Can you write Python code for it?

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(x, y, test_size = 0.5)
err_train = [];
err_test = [];
d = range(0, 20)

for i in d:
    Phi_train = PolynomialFeatures(i).fit_transform(X_train.reshape(-1, 1))
    Phi_test = PolynomialFeatures(i).fit_transform(X_test.reshape(-1, 1))
    w_train = np.dot(np.linalg.pinv(Phi_train), y_train)
    h_train = np.dot(Phi_train, w_train)
    h_test = np.dot(Phi_test, w_train)

    err_train.insert(i, np.log(mean_squared_error(y_train, h_train)))
    err_test.insert(i, np.log(mean_squared_error(y_test, h_test)))

plt.figure(figsize=(10,5))
plt.plot(d, err_train, d, err_test)
plt.grid()


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(b)
Trenirajte model polinomijalne regresije stupnja $d=3$. Na istom grafikonu prikažite naučeni model $h(\mathbf{x})=\mathbf{w}^\intercal\tilde{\mathbf{x}}$ i primjere za učenje. Izračunajte pogrešku učenja modela.
Can you write Python code for it?

from sklearn.preprocessing import PolynomialFeatures

Phi = PolynomialFeatures(3).fit_transform(x.reshape(-1, 1))
w = np.dot(np.linalg.pinv(Phi), y)
h = np.dot(Phi, w)
error = mean_squared_error(y, h)
print(error)

plt.figure(figsize=(10,5))
plt.scatter(x, y)
plt.plot(x, h, 'r', linewidth=1)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
(d)
Uvjerite se da za primjere iz $\mathcal{D}$ težine $\mathbf{w}$ ne možemo naći rješavanjem sustava $\mathbf{w}=\mathbf{\Phi}^{-1}\mathbf{y}$, već da nam doista treba pseudoinverz.
Q: Zašto je to slučaj? Bi li se problem mogao riješiti preslikavanjem primjera u višu dimenziju? Ako da, bi li to uvijek funkcioniralo, neovisno o skupu primjera $\mathcal{D}$? Pokažite na primjeru.
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
2. Polinomijalna regresija i utjecaj šuma
(a)
Razmotrimo sada regresiju na većem broju primjera. Koristite funkciju make_labels(X, f, noise=0) koja uzima matricu neoznačenih primjera $\mathbf{X}{N\times n}$ te generira vektor njihovih oznaka $\mathbf{y}{N\times 1}$. Oznake se generiraju kao $y^{(i)} = f(x^{(i)})+\mathcal{N}(0,\sigma^2)$, gdje je $f:\mathbb{R}^n\to\mathbb{R}$ stvarna funkcija koja je generirala podatke (koja nam je u stvarnosti nepoznata), a $\sigma$ je standardna devijacija Gaussovog šuma, definirana parametrom noise. Za generiranje šuma koristi se funkcija numpy.random.normal.
Generirajte skup za učenje od $N=50$ primjera uniformno distribuiranih u intervalu $[-5,5]$ pomoću funkcije $f(x) = 5 + x -2 x^2 -5 x^3$ uz šum  $\sigma=200$:
Can you write Python code for it?

from numpy.random import normal
def make_labels(X, f, noise=0) :
    return map(lambda x : f(x) + (normal(0,noise) if noise>0 else 0), X)

def make_instances(x1, x2, N) :
    return sp.array([np.array([x]) for x in np.linspace(x1,x2,N)])

N = 50
sigma = 200
fun = lambda x :5 + x - 2*x**2 - 5*x**3
x = make_instances(-5, 5, N)
y = list(make_labels(x, fun, sigma))

y6a = y
x6a = x


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
3. Odabir modela
(a)
Na skupu podataka iz zadatka 2 trenirajte pet modela linearne regresije $\mathcal{H}_d$ različite složenosti, gdje je $d$ stupanj polinoma, $d\in{1,3,5,10,20}$. Prikažite na istome grafikonu skup za učenje i funkcije $h_d(\mathbf{x})$ za svih pet modela (preporučujemo koristiti plot unutar for petlje). Izračunajte pogrešku učenja svakog od modela.
Q: Koji model ima najmanju pogrešku učenja i zašto?
Can you write Python code for it?

Phi_d = [];
w_d = [];
h_d = [];
err_d = [];

d = [1, 3, 5, 10, 20]

for i in d:
    Phi_d.append(PolynomialFeatures(i).fit_transform(x.reshape(-1,1)))

for i in range(0, len(d)):
    w_d.insert(i, np.dot(np.linalg.pinv(Phi_d[i]), y))
    h_d.insert(i, np.dot(Phi_d[i], w_d[i]))

for i in range(0, len(d)):
    err_d.insert(i, mean_squared_error(y, h_d[i]))
    print (str(d[i]) + ': ' + str(err_d[i]))

fig = plt.figure(figsize=(15, 20))
fig.subplots_adjust(wspace=0.2)

for i in range(0, len(d)):
    ax = fig.add_subplot(5, 2, i+1)
    ax.scatter(x, y);
    ax.plot(x, h_d[i], 'r', linewidth = 1)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
4. Regularizirana regresija
(a)
U gornjim eksperimentima nismo koristili regularizaciju. Vratimo se najprije na primjer iz zadatka 1. Na primjerima iz tog zadatka izračunajte težine $\mathbf{w}$ za polinomijalni regresijski model stupnja $d=3$ uz L2-regularizaciju (tzv. ridge regression), prema izrazu $\mathbf{w}=(\mathbf{\Phi}^\intercal\mathbf{\Phi}+\lambda\mathbf{I})^{-1}\mathbf{\Phi}^\intercal\mathbf{y}$. Napravite izračun težina za regularizacijske faktore $\lambda=0$, $\lambda=1$ i $\lambda=10$ te usporedite dobivene težine.
Q: Kojih je dimenzija matrica koju treba invertirati?
Q: Po čemu se razlikuju dobivene težine i je li ta razlika očekivana? Obrazložite.
Can you write Python code for it?

lam = [0, 1, 10]
y = np.array([4,1,2,5])

Phi4a = PolynomialFeatures(3).fit_transform(X)
w_L2 = [];

def w_reg(lam):
    t1 = np.dot(Phi4a.T, Phi4a) + np.dot(lam, np.eye(4))
    t2 = np.dot(np.linalg.inv(t1), Phi4a.T)
    return np.dot(t2, y)

for i in range(0, 3):
    w_L2.insert(i, w_reg(lam[i]))
    print (w_reg(lam[i]))


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
6. L1-regularizacija i L2-regularizacija
Svrha regularizacije jest potiskivanje težina modela $\mathbf{w}$ prema nuli, kako bi model bio što jednostavniji. Složenost modela može se okarakterizirati normom pripadnog vektora težina $\mathbf{w}$, i to tipično L2-normom ili L1-normom. Za jednom trenirani model možemo izračunati i broj ne-nul značajki, ili L0-normu, pomoću sljedeće funkcije:
Can you write Python code for it?

def nonzeroes(coef, tol=1e-6):
    return len(coef) - len(coef[sp.isclose(0, coef, atol=tol)])


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
7. Značajke različitih skala
Često se u praksi možemo susreti sa podatcima u kojima sve značajke nisu jednakih magnituda. Primjer jednog takvog skupa je regresijski skup podataka grades u kojem se predviđa prosjek ocjena studenta na studiju (1--5) na temelju dvije značajke: bodova na prijamnom ispitu (1--3000) i prosjeka ocjena u srednjoj školi. Prosjek ocjena na studiju izračunat je kao težinska suma ove dvije značajke uz dodani šum.
Koristite sljedeći kôd kako biste generirali ovaj skup podataka.
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Ponovno, naučite na ovom skupu L2-regularizirani model regresije ($\lambda = 0.01$).
Can you write Python code for it?

w = Ridge(alpha = 0.01).fit(grades_X_fixed_colinear, grades_y_fixed).coef_
print(w)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Prikažite taj skup funkcijom scatter.
Can you write Python code for it?

plt.figure(figsize=(10, 5))
plt.plot(x, fun(x), 'r', linewidth = 1)
plt.scatter(x, y)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Q: Gledajući grafikone iz podzadatka (a), koja značajka bi trebala imati veću magnitudu, odnosno važnost pri predikciji prosjeka na studiju? Odgovaraju li težine Vašoj intuiciji? Objasnite.
8. Multikolinearnost i kondicija matrice
a)
Izradite skup podataka grades_X_fixed_colinear tako što ćete u skupu grades_X_fixed iz
zadatka 7b duplicirati zadnji stupac (ocjenu iz srednje škole). Time smo efektivno uveli savršenu multikolinearnost.
Can you write Python code for it?

grades_X_fixed_colinear = [[g[0],g[1],g[1]] for g in grades_X_fixed]


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Q: Kako regularizacija utječe na stabilnost težina?
Q: Jesu li koeficijenti jednakih magnituda kao u prethodnom pokusu? Objasnite zašto.
c)
Koristeći numpy.linalg.cond izračunajte kondicijski broj matrice $\mathbf{\Phi}^\intercal\mathbf{\Phi}+\lambda\mathbf{I}$, gdje je $\mathbf{\Phi}$ matrica dizajna (grades_fixed_X_colinear). Ponovite i za $\lambda=0.01$ i za $\lambda=10$.
Can you write Python code for it?

lam = 0.01

phi = grades_X_fixed_colinear
s = np.add(np.dot(np.transpose(phi), phi), lam * np.identity(len(a)))
print(np.linalg.cond(s))

lam = 10

phi = grades_X_fixed_colinear
s = np.add(np.dot(np.transpose(phi), phi), lam * np.identity(len(a)))
print(np.linalg.cond(s))


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Radi jasnoće, u nastavku je vektor $\mathbf{x}$ s dodanom dummy jedinicom $x_0=1$ označen kao $\tilde{\mathbf{x}}$.
(c)
Prikažite primjere iz $\mathcal{D}$ i funkciju $h(\tilde{\mathbf{x}})=\mathbf{w}^\intercal\tilde{\mathbf{x}}$. Izračunajte pogrešku učenja prema izrazu $E(h|\mathcal{D})=\frac{1}{2}\sum_{i=1}^N(\tilde{\mathbf{y}}^{(i)} - h(\tilde{\mathbf{x}}))^2$. Možete koristiti funkciju srednje kvadratne pogreške mean_squared_error iz modula sklearn.metrics.
Q: Gore definirana funkcija pogreške $E(h|\mathcal{D})$ i funkcija srednje kvadratne pogreške nisu posve identične. U čemu je razlika? Koja je "realnija"?
Can you write Python code for it?

from sklearn.metrics import mean_squared_error

h = np.dot(Phi, w)
print (h)

error = mean_squared_error(y, h)
print (error)

plt.plot(X, y, '+', X, h, linewidth = 1)
plt.axis([-3, 6, -1, 7])


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
Zadatci
1. Jednostavna regresija
Zadan je skup primjera $\mathcal{D}={(x^{(i)},y^{(i)})}_{i=1}^4 = {(0,4),(1,1),(2,2),(4,5)}$. Primjere predstavite matrixom $\mathbf{X}$ dimenzija $N\times n$ (u ovom slučaju $4\times 1$) i vektorom oznaka $\textbf{y}$, dimenzija $N\times 1$ (u ovom slučaju $4\times 1$), na sljedeći način:
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB01-Regresija-checkpoint.ipynb".
The first task is:
b)
Naučite model L2-regularizirane regresije ($\lambda = 0.01$), na podacima grades_X i grades_y:
Can you write Python code for it?

    w = Ridge(alpha = 0.01).fit(grades_X, grades_y).coef_
    print(w)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB02-LDM-i-LR-checkpoint.ipynb".
The first task is:
(a)
Prvo, isprobajte ugrađeni model na linearno odvojivom skupu podataka seven ($N=7$).
Can you write Python code for it?

seven_X = np.array([[2,1], [2,3], [1,2], [3,2], [5,2], [5,4], [6,3]])
seven_y = np.array([1, 1, 1, 1, 0, 0, 0])

clf = RidgeClassifier().fit(seven_X, seven_y)
predicted_y = clf.predict(seven_X)
score = accuracy_score(y_pred=predicted_y, y_true=seven_y)
print(score)

mlutils.plot_2d_clf_problem(X=seven_X, y=predicted_y, h=None)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB02-LDM-i-LR-checkpoint.ipynb".
The first task is:
(b)
Trenirajte model logističke regresije na skupu seven te na dva odvojena grafikona prikažite, kroz iteracije optimizacijskoga algoritma, (1) izlaz modela $h(\mathbf{x})$ za svih sedam primjera te (2) vrijednosti težina $w_0$, $w_1$, $w_2$.
Can you write Python code for it?

[w4b, w4b_trace] = lr_train(seven_X, seven_y, trace = True)

w0_4b = []; w1_4b = []; w2_4b = [];

for i in range(0, len(w4b_trace), 3):
    w0_4b.append(w4b_trace[i])
    w1_4b.append(w4b_trace[i+1])
    w2_4b.append(w4b_trace[i+2])

h_gl = []

for i in range(0, len(seven_X)):
    h = []

    for j in range(0, len(w4b_trace), 3):
        h.append(lr_h(seven_X[i], w4b_trace[j:j+3]))

    h_gl.append(h)

figure(figsize(7, 14))
subplot(2,1,1)
grid()
for i in range(0, len(h_gl)):
    plot(h_gl[i], label = 'x' + str(i))

legend(loc = 'best') ;

subplot(2,1,2)
grid()
plot(w0_4b); plot(w1_4b); plot(w2_4b);
legend(['w0', 'w1', 'w2'], loc = 'best');


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB02-LDM-i-LR-checkpoint.ipynb".
The first task is:
(c)
Koristeći funkciju lr_train, trenirajte model logističke regresije na skupu seven, prikažite dobivenu granicu između klasa te  izračunajte pogrešku unakrsne entropije.
NB: Pripazite da modelu date dovoljan broj iteracija.
Can you write Python code for it?

trained = lr_train(seven_X, seven_y)
print(cross_entropy_error(seven_X, seven_y, trained))
print(trained)

h3c = lambda x: lr_h(x, trained) > 0.5

figure()
mlutils.plot_2d_clf_problem(seven_X, seven_y, h3c)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB02-LDM-i-LR-checkpoint.ipynb".
The first task is:
(c)
Ponovite eksperiment iz podzadatka (b) koristeći linearno neodvojiv skup podataka unsep iz prvog zadatka.
Q: Usporedite grafikone za slučaj linearno odvojivih i linearno neodvojivih primjera te komentirajte razliku.
Can you write Python code for it?

unsep_y = np.append(seven_y, 0)
[w4c, w4c_trace] = lr_train(unsep_X, unsep_y, trace = True)

w0_4c = []; w1_4c = []; w2_4c = [];

for i in range(0, len(w4c_trace), 3):
    w0_4c.append(w4c_trace[i])
    w1_4c.append(w4c_trace[i+1])
    w2_4c.append(w4c_trace[i+2])

h_gl = []

for i in range(0, len(unsep_X)):
    h = []

    for j in range(0, len(w4c_trace), 3):
        h.append(lr_h(unsep_X[i], w4c_trace[j:j+3]))

    h_gl.append(h)

figure(figsize(7, 14))
subplots_adjust(wspace=0.1)
subplot(2,1,1)
grid()
for i in range(0, len(h_gl)):
    plot(h_gl[i], label = 'x' + str(i))

legend(loc = 'best') ;

subplot(2,1,2)
grid()
plot(w0_4c); plot(w1_4c); plot(w2_4c);
legend(['w0', 'w1', 'w2'], loc = 'best');


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB02-LDM-i-LR-checkpoint.ipynb".
The first task is:
3. Logistička regresija
Ovaj zadatak bavi se probabilističkim diskriminativnim modelom, logističkom regresijom, koja je, unatoč nazivu, klasifikacijski model.
Logistička regresija tipičan je predstavnik tzv. poopćenih linearnih modela koji su oblika: $h(\mathbf{x})=f(\mathbf{w}^\intercal\tilde{\mathbf{x}})$. Logistička funkcija za funkciju $f$ koristi tzv. logističku (sigmoidalnu) funkciju $\sigma (x) = \frac{1}{1 + \textit{exp}(-x)}$.
(a)
Definirajte logističku (sigmoidalnu) funkciju $\mathrm{sigm}(x)=\frac{1}{1+\exp(-\alpha x)}$ i prikažite je za $\alpha\in{1,2,4}$.
Can you write Python code for it?

def sigm(alpha):
    def f(x):
        return 1 / (1 + exp(-alpha*x))

    return f

ax = list(range(-10, 10))
ay1 = list(map(sigm(1), ax))
ay2 = list(map(sigm(2), ax))
ay3 = list(map(sigm(4), ax))

fig = plt.figure(figsize=(5,15))
p1 = fig.add_subplot(3, 1, 1)
p1.plot(ax, ay1)
p2 = fig.add_subplot(3, 1, 2)
p2.plot(ax, ay2)
p3 = fig.add_subplot(3, 1, 3)
p3.plot(ax, ay3)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB02-LDM-i-LR-checkpoint.ipynb".
The first task is:
4. Analiza logističke regresije
(a)
Koristeći ugrađenu implementaciju logističke regresije, provjerite kako se logistička regresija nosi s vrijednostima koje odskaču. Iskoristite skup outlier iz prvog zadatka. Prikažite granicu između klasa.
Q: Zašto se rezultat razlikuje od onog koji je dobio model klasifikacije linearnom regresijom iz prvog zadatka?
Can you write Python code for it?

    logReg4 = LogisticRegression(solver='liblinear').fit(outlier_X, outlier_y)
    mlutils.plot_2d_clf_problem(X=outlier_X, y=outlier_y, h= lambda x : logReg4.predict(x) >= 0.5)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB02-LDM-i-LR-checkpoint.ipynb".
The first task is:
5. Regularizirana logistička regresija
Trenirajte model logističke regresije na skupu seven s različitim faktorima L2-regularizacije, $\alpha\in{0,1,10,100}$. Prikažite na dva odvojena grafikona (1) pogrešku unakrsne entropije te (2) L2-normu vektora $\mathbf{w}$ kroz iteracije optimizacijskog algoritma.
Q: Jesu li izgledi krivulja očekivani i zašto?
Q: Koju biste vrijednost za $\alpha$ odabrali i zašto?
Can you write Python code for it?

from numpy.linalg import norm

alpha5 = [0, 1, 10, 100]

err_gl = []; norm_gl = [];

for a in alpha5:
    [w5, w5_trace] = lr_train(seven_X, seven_y, alpha = a, trace = True)
    err = []; L2_norm = [];

    for k in range(0, len(w5_trace), 3):
        err.append(cross_entropy_error(seven_X, seven_y, w5_trace[k:k+3]))
        L2_norm.append(linalg.norm(w5_trace[k:k+1]))

    err_gl.append(err)
    norm_gl.append(L2_norm)

figure(figsize(7, 14))
subplot(2,1,1)
grid()
for i in range(0, len(err_gl)):
    plot(err_gl[i], label = 'alpha = '  + str(alpha5[i])  )

legend(loc = 'best') ;

subplot(2,1,2)
grid()
for i in range(0, len(err_gl)):
    plot(norm_gl[i], label = 'alpha = ' + str(alpha5[i]) )

legend(loc = 'best');


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB02-LDM-i-LR-checkpoint.ipynb".
The first task is:
Kako bi se uvjerili da se u isprobanoj implementaciji ne radi o ničemu doli o običnoj linearnoj regresiji, napišite kôd koji dolazi do jednakog rješenja korištenjem isključivo razreda LinearRegression. Funkciju za predikciju, koju predajete kao treći argument h funkciji plot_2d_clf_problem, možete definirati lambda-izrazom: lambda x : model.predict(x) >= 0.5.
Can you write Python code for it?

lr = LinearRegression().fit(seven_X, seven_y)
predicted_y_2 = lr.predict(seven_X)

mlutils.plot_2d_clf_problem(X=seven_X, y=seven_y, h= lambda x : lr.predict(x) >= 0.5)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB02-LDM-i-LR-checkpoint.ipynb".
The first task is:
Q: Kako bi bila definirana granica između klasa ako bismo koristili oznake klasa $-1$ i $1$ umjesto $0$ i $1$?
(b)
Probajte isto na linearno odvojivom skupu podataka outlier ($N=8$):
Can you write Python code for it?

outlier_X = np.append(seven_X, [[12,8]], axis=0)
outlier_y = np.append(seven_y, 0)

lr2 = LinearRegression().fit(outlier_X, outlier_y)
predicted_y_2 = lr2.predict(outlier_X)

mlutils.plot_2d_clf_problem(X=outlier_X, y=outlier_y, h= lambda x : lr2.predict(x) >= 0.5)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB02-LDM-i-LR-checkpoint.ipynb".
The first task is:
Q: Očito je zašto model nije u mogućnosti postići potpunu točnost na ovom skupu podataka. Međutim, smatrate li da je problem u modelu ili u podacima? Argumentirajte svoj stav.
2. Višeklasna klasifikacija
Postoji više načina kako se binarni klasifikatori mogu se upotrijebiti za višeklasnu klasifikaciju. Najčešće se koristi shema tzv. jedan-naspram-ostali (engl. one-vs-rest, OVR), u kojoj se trenira po jedan klasifikator $h_j$ za svaku od $K$ klasa. Svaki klasifikator $h_j$ trenira se da razdvaja primjere klase $j$ od primjera svih drugih klasa, a primjer se klasificira u klasu $j$ za koju je $h_j(\mathbf{x})$ maksimalan.
Pomoću funkcije datasets.make_classification generirajte slučajan dvodimenzijski skup podataka od tri klase i prikažite ga koristeći funkciju plot_2d_clf_problem. Radi jednostavnosti, pretpostavite da nema redundantnih značajki te da je svaka od klasa "zbijena" upravo u jednu grupu.
Can you write Python code for it?

from sklearn.datasets import make_classification

x, y = sklearn.datasets.make_classification(n_samples=100, n_informative=2, n_redundant=0, n_repeated=0, n_features=2, n_classes=3, n_clusters_per_class=1)

#print(dataset)
mlutils.plot_2d_clf_problem(X=x, y=y, h=None)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB02-LDM-i-LR-checkpoint.ipynb".
The first task is:
Q: Zašto je pogreška unakrsne entropije veća od pogreške klasifikacije? Je li to uvijek slučaj kod logističke regresije i zašto?
Q: Koju stopu učenja $\eta$ biste odabrali i zašto?
(e)
Upoznajte se s klasom linear_model.LogisticRegression koja implementira logističku regresiju. Usporedite rezultat modela na skupu seven s rezultatom koji dobivate pomoću vlastite implementacije algoritma.
NB: Kako ugrađena implementacija koristi naprednije verzije optimizacije funkcije, vrlo je vjerojatno da Vam se rješenja neće poklapati, ali generalne performanse modela bi trebale. Ponovno, pripazite na broj iteracija i snagu regularizacije.
Can you write Python code for it?

from sklearn.linear_model import LogisticRegression

reg3e = LogisticRegression(max_iter=2000, tol=0.0001, C=0.01**-1, solver='lbfgs').fit(seven_X,seven_y)
h3e = lambda x : reg3e.predict(x)

figure(figsize(7, 7))
mlutils.plot_2d_clf_problem(seven_X,seven_y, h3e)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB02-LDM-i-LR-checkpoint.ipynb".
The first task is:
Q: Zašto je sigmoidalna funkcija prikladan izbor za aktivacijsku funkciju poopćenoga linearnog modela?
</br>
Q: Kakav utjecaj ima faktor $\alpha$ na oblik sigmoide? Što to znači za model logističke regresije (tj. kako izlaz modela ovisi o normi vektora težina $\mathbf{w}$)?
(b)
Implementirajte funkciju

lr_train(X, y, eta=0.01, max_iter=2000, alpha=0, epsilon=0.0001, trace=False)

za treniranje modela logističke regresije gradijentnim spustom (batch izvedba). Funkcija uzima označeni skup primjera za učenje (matrica primjera X i vektor oznaka y) te vraća $(n+1)$-dimenzijski vektor težina tipa ndarray. Ako je trace=True, funkcija dodatno vraća listu (ili matricu) vektora težina $\mathbf{w}^0,\mathbf{w}^1,\dots,\mathbf{w}^k$ generiranih kroz sve iteracije optimizacije, od 0 do $k$. Optimizaciju treba provoditi dok se ne dosegne max_iter iteracija, ili kada razlika u pogrešci unakrsne entropije između dviju iteracija padne ispod vrijednosti epsilon. Parametar alpha predstavlja faktor regularizacije.
Preporučamo definiranje pomoćne funkcije lr_h(x,w) koja daje predikciju za primjer x uz zadane težine w. Također, preporučamo i funkciju cross_entropy_error(X,y,w) koja izračunava pogrešku unakrsne entropije modela na označenom skupu (X,y) uz te iste težine.
NB: Obratite pozornost na to da je način kako su definirane oznake (${+1,-1}$ ili ${1,0}$) kompatibilan s izračunom funkcije gubitka u optimizacijskome algoritmu.
Can you write Python code for it?

from sklearn.preprocessing import PolynomialFeatures as PolyFeat
from sklearn.metrics import log_loss

def loss_function(h_x, y):
    return -y * np.log(h_x) - (1 - y) * np.log(1 - h_x)

def lr_h(x, w):
    Phi = PolyFeat(1).fit_transform(x.reshape(1,-1))
    return sigm(1)(Phi.dot(w))

def cross_entropy_error(X, y, w):
    Phi = PolyFeat(1).fit_transform(X)
    return log_loss(y, sigm(1)(Phi.dot(w)))

def lr_train(X, y, eta = 0.01, max_iter = 2000, alpha = 0, epsilon = 0.0001, trace= False):
    w = zeros(shape(X)[1] + 1)
    N = len(X)
    w_trace = [];
    error = epsilon**-1

    for i in range(0, max_iter):
        dw0 = 0; dw = zeros(shape(X)[1]);
        new_error = 0

        for j in range(0, N):
            h = lr_h(X[j], w)
            dw0 += h - y[j]
            dw += (h - y[j])*X[j]

            new_error += loss_function(h, y[j])

        if abs(error - new_error) < epsilon:
            print('stagnacija na i = ', i)
            break

        else: error = new_error

        w[0] -= eta*dw0
        w[1:] = w[1:] * (1-eta*alpha) - eta*dw

        w_trace.extend(w)

    if trace:
        return w, w_trace

    else: return w


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB02-LDM-i-LR-checkpoint.ipynb".
The first task is:
Q: Zašto model ne ostvaruje potpunu točnost iako su podatci linearno odvojivi?
(c)
Završno, probajte isto na linearno neodvojivom skupu podataka unsep ($N=8$):
Can you write Python code for it?

unsep_X = np.append(seven_X, [[2,2]], axis=0)
unsep_y = np.append(seven_y, 0)

lr3 = LinearRegression().fit(unsep_X, unsep_y)
predicted_y_2 = lr3.predict(unsep_X)

mlutils.plot_2d_clf_problem(X=unsep_X, y=unsep_y, h= lambda x : lr3.predict(x) >= 0.5)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-0036477171-checkpoint.ipynb".
The first task is:
(a)
Proučite funkciju za iscrtavanje histograma hist. Prikažite histograme vrijednosti značajki $x_0$ i $x_1$ (ovdje i u sljedećim zadatcima koristite bins=50).
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-0036477171-checkpoint.ipynb".
The first task is:
(b)
Pomoću funkcije datasets.make_classification generirajte dva skupa podataka od $N=200$ primjera: jedan s $n=2$ dimenzije i drugi s $n=1000$ dimenzija. Primjeri neka dolaze iz dviju klasa, s time da svakoj klasi odgovaraju dvije grupe (n_clusters_per_class=2), kako bi problem bio nešto složeniji, tj. nelinearniji. Neka sve značajke budu informativne. Podijelite skup primjera na skup za učenje i skup za ispitivanje u omjeru 1:1.
Na oba skupa optimirajte SVM s jezgrenom funkcijom RBF, u rešetci $C\in{2^{-5},2^{-4},\dots,2^{15}}$ i $\gamma\in{2^{-15},2^{-14},\dots,2^{3}}$. Prikažite površinu pogreške modela na skupu za učenje i skupu za provjeru, i to na oba skupa podataka (ukupno četiri grafikona) te ispišite optimalne kombinacije hiperparametara. Za prikaz površine pogreške modela možete koristiti funkciju mlutils.plot_error_surface.
Can you write Python code for it?

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# Vaš kôd ovdje
X1, y1 = make_classification(n_samples=200, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=2)
X1_train, X1_validate, y1_train, y1_validate = train_test_split(X1, y1, test_size = 0.5)

X2, y2 = make_classification(n_samples=200, n_features=1000, n_informative=1000, n_redundant=0, n_clusters_per_class=2)
X2_train, X2_validate, y2_train, y2_validate = train_test_split(X2, y2, test_size = 0.5)

c_range=(-5, 15)
g_range=(-15, 3)

C1_opt, G1_opt, err_train1, err_validate1 = grid_search(X1_train, X1_validate, y1_train, y1_validate, c_range, g_range, True)
C2_opt, G2_opt, err_train2, err_validate2 = grid_search(X2_train, X2_validate, y2_train, y2_validate, c_range, g_range, True)

print("C1 optimal:", C1_opt, "C2 optimal:", C2_opt)
print("gamma1 optimal:", G1_opt, "G2 optimal:", G2_opt)

fig = plt.figure(figsize=(12, 8))

ax = fig.add_subplot(2, 2, 1)
ax.grid()
mlutils.plot_error_surface(err_train1, c_range, g_range)
title("TRAIN1 error")

ax = fig.add_subplot(2, 2, 2)
ax.grid()
mlutils.plot_error_surface(err_train2, c_range, g_range)
title("TRAIN2 error")

ax = fig.add_subplot(2, 2, 3)
ax.grid()
mlutils.plot_error_surface(err_validate1, c_range, g_range)
title("VALIDATION1 errors")

ax = fig.add_subplot(2, 2, 4)
ax.grid()
mlutils.plot_error_surface(err_validate2, c_range, g_range)
title("VALIDATION2 errors")


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-0036477171-checkpoint.ipynb".
The first task is:
(b)
Proučite razred preprocessing.MinMaxScaler. Prikažite histograme vrijednosti značajki $x_0$ i $x_1$ ako su iste skalirane min-max skaliranjem (ukupno dva histograma).
Can you write Python code for it?

from sklearn.preprocessing import MinMaxScaler

x0b = MinMaxScaler().fit_transform(X[:,0].reshape(-1,1), y)
x1b = MinMaxScaler().fit_transform(X[:,1].reshape(-1,1), y)

figure(figsize(10, 5))
subplot(1,2,1)
hist(x0b, bins = 50)
subplot(1,2,2)
hist(x1b, bins = 50)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-0036477171-checkpoint.ipynb".
The first task is:
(c)
Vratit ćemo se na skupove podataka outlier ($N=8$) i unsep ($N=8$) iz prošle laboratorijske vježbe (dani niže) i pogledati kako se model SVM-a nosi s njima. Naučite ugrađeni model SVM-a (s linearnom jezgrom) na ovim podatcima i iscrtajte decizijsku granicu (skupa s marginom). Također ispišite točnost modela korištenjem funkcije metrics.accuracy_score.
Can you write Python code for it?

from sklearn.metrics import accuracy_score

outlier_X = np.append(seven_X, [[12,8]], axis=0)
outlier_y = np.append(seven_y, -1)

unsep_X = np.append(seven_X, [[2,2]], axis=0)
unsep_y = np.append(seven_y, -1)

outlier = SVC(kernel = 'linear').fit(outlier_X, outlier_y)
outlier_accuracy = accuracy_score(outlier_y, outlier.predict(outlier_X))

print('outlier acc:')
print(outlier_accuracy)

unsep = SVC(kernel = 'linear').fit(unsep_X, unsep_y)
unsep_accuracy = accuracy_score(unsep_y, unsep.predict(unsep_X))

print('unsep acc:')
print(unsep_accuracy)

figure(figsize(12,4))
subplot(1,2,1)
mlutils.plot_2d_svc_problem(outlier_X, outlier_y, outlier)
mlutils.plot_2d_clf_problem(outlier_X, outlier_y, outlier.predict)

subplot(1,2,2)
mlutils.plot_2d_svc_problem(unsep_X, unsep_y, unsep)
mlutils.plot_2d_clf_problem(unsep_X, unsep_y, unsep.predict)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-0036477171-checkpoint.ipynb".
The first task is:
6. Analiza algoritma k-najbližih susjeda
Algoritam k-nn ima hiperparametar $k$ (broj susjeda). Taj hiperparametar izravno utječe na složenost algoritma, pa je stoga izrazito važno dobro odabrati njegovu vrijednost. Kao i kod mnogih drugih algoritama, tako i kod algoritma k-nn optimalna vrijednost hiperametra $k$ ovisi o konkretnom problemu, uključivo broju primjera $N$, broju značajki (dimenzija) $n$ te broju klasa $K$.
Kako bismo dobili pouzdanije rezultate, potrebno je neke od eksperimenata ponoviti na različitim skupovima podataka i zatim uprosječiti dobivene vrijednosti pogrešaka. Koristite funkciju: mlutils.knn_eval koja trenira i ispituje model k-najbližih susjeda na ukupno n_instances primjera, i to tako da za svaku vrijednost hiperparametra iz zadanog intervala k_range ponovi n_trials mjerenja, generirajući za svako od njih nov skup podataka i dijeleći ga na skup za učenje i skup za ispitivanje. Udio skupa za ispitivanje definiran je parametrom test_size. Povratna vrijednost funkcije jest četvorka (ks, best_k, train_errors, test_errors). Vrijednost best_k je optimalna vrijednost hiperparametra $k$ (vrijednost za koju je pogreška na skupu za ispitivanje najmanja). Vrijednosti train_errors i test_errors  liste su pogrešaka na skupu za učenja odnosno skupu za testiranje za sve razmatrane vrijednosti hiperparametra $k$, dok ks upravo pohranjuje sve razmatrane vrijednosti hiperparametra $k$.
(a)
Na podatcima iz zadatka 5, pomoću funkcije mlutils.plot_2d_clf_problem iscrtajte prostor primjera i područja koja odgovaraju prvoj odnosno drugoj klasi. Ponovite ovo za $k\in[1, 5, 20, 100]$.
NB: Implementacija algoritma KNeighborsClassifier iz paketa scikit-learn vjerojatno će raditi brže od Vaše implementacije, pa u preostalim eksperimentima koristite nju.
Can you write Python code for it?

def knn_eval(n_instances=100, n_features=2, n_classes=2, n_informative=2, test_size=0.3, k_range=(1, 20), n_trials=100):

    best_k = 0; train_errors = []; test_errors = [];

    for k in range(k_range[0],k_range[1]+1):

        train_error = []
        test_error = []

        for j in range(0, n_trials):

            X, y = make_classification(n_samples=n_instances, n_features=n_features, n_classes=n_classes, n_informative=n_informative, n_redundant=0, n_clusters_per_class=1)
            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = test_size)

            mod = KNeighborsClassifier(algorithm = 'brute', n_neighbors = k).fit(X_train, y_train)
            prediction_train = mod.predict(X_train)
            prediction_test = mod.predict(X_test)

            train_error.append(zero_one_loss(y_train, prediction_train))
            test_error.append(zero_one_loss(y_test, prediction_test))

        train_errors.append(mean(train_error))
        test_errors.append(mean(test_error))

    best_k = k_range[0] + test_errors.index(min(test_errors))

    return (best_k, train_errors, test_errors)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-0036477171-checkpoint.ipynb".
The first task is:
Q: Kako $k$ utječe na izgled granice između klasa?
Q: Kako se algoritam ponaša u ekstremnim situacijama: $k=1$ i $k=100$?
(b)
Pomoću funkcije mlutils.knn_eval, iscrtajte pogreške učenja i ispitivanja kao funkcije hiperparametra $k\in{1,\dots,20}$, za $N={100, 500, 1000, 3000}$ primjera. Načinite 4 zasebna grafikona (generirajte ih u 2x2 polju). U svakoj iteraciji ispišite optimalnu vrijednost hiperparametra $k$ (najlakše kao naslov grafikona; vidi plt.title).
Can you write Python code for it?

hiperparams = range(1, 21)
N = [100, 500, 1000, 3000]

figure(figsize(11, 8))

i = 1
for n in N:
    [k, err_tr, err_tst] = knn_eval(n_instances=n, k_range=(1, 20))

    subplot(2,2,i)
    plot(np.array(range(1,21)), err_tr)
    plot(np.array(range(1,21)), err_tst)
    scatter(k,err_tst[hiperparams.index(k)])
    legend(['train error', 'test error', 'min test err'], loc = 'best', prop={'size':10})
    title('\nN = ' + str(n) + '\nk = ' + str(k))
    xticks(rng)
    grid()

    i+=1


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-0036477171-checkpoint.ipynb".
The first task is:
Q: Kako radi ovo skaliranje?

Q: Dobiveni histogrami su vrlo slični. U čemu je razlika?

(c)
Proučite razred preprocessing.StandardScaler. Prikažite histograme vrijednosti značajki $x_0$ i $x_1$ ako su iste skalirane standardnim skaliranjem (ukupno dva histograma).
Can you write Python code for it?

from sklearn.preprocessing import StandardScaler

x0b = StandardScaler().fit_transform(X[:,0].reshape(-1,1), y)
x1b = StandardScaler().fit_transform(X[:,1].reshape(-1,1), y)

figure(figsize(10, 5))
subplot(1,2,1)
hist(x0b, bins = 50)
subplot(1,2,2)
hist(x1b, bins = 50)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-0036477171-checkpoint.ipynb".
The first task is:
Q: Koliko iznosi širina margine i zašto?
Q: Koji primjeri su potporni vektori i zašto?
(b)
Definirajte funkciju hinge(model, x, y) koja izračunava gubitak zglobnice modela SVM na primjeru x. Izračunajte gubitke modela naučenog na skupu seven za primjere $\mathbf{x}^{(2)}=(3,2)$ i $\mathbf{x}^{(1)}=(3.5,2)$ koji su označeni pozitivno ($y=1$) te za $\mathbf{x}^{(3)}=(4,2)$ koji je označen negativno ($y=-1$). Također, izračunajte prosječni gubitak SVM-a na skupu seven. Uvjerite se da je rezultat identičan onome koji biste dobili primjenom ugrađene funkcije metrics.hinge_loss.
Can you write Python code for it?

from sklearn.metrics import hinge_loss

def hinge(model, x, y):
    return max(0, 1-y*model.decision_function(x))

x1b = np.array([[3,2], [3.5, 2], [4,2]])
y1b = np.array([1, 1, -1])

suma = 0
for i in range(0, len(seven_X)):
    suma += hinge(fit, seven_X[i].reshape(1,-1), seven_y[i])
my_hinge_loss = suma / len(seven_X)

print('my hinge loss: ' + str(my_hinge_loss[0]))
print('inbuild hinge loss: ' + str(hinge_loss(seven_y, fit.decision_function(seven_X))))


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-SVM-i-kNN-checkpoint.ipynb".
The first task is:
(b)
Kako biste se uvjerili da je Vaša implementacija ispravna, usporedite ju s onom u razredu neighbors.KNeighborsClassifier. Budući da spomenuti razred koristi razne optimizacijske trikove pri pronalasku najboljih susjeda, obavezno postavite parametar algorithm=brute, jer bi se u protivnom moglo dogoditi da Vam se predikcije razlikuju. Usporedite modele na danom (umjetnom) skupu podataka (prisjetite se kako se uspoređuju polja; numpy.all).
Can you write Python code for it?

from sklearn.datasets import make_classification
X_art, y_art = make_classification(n_samples=100, n_features=2, n_classes=2,
                                   n_redundant=0, n_clusters_per_class=2,
                                   random_state=69)
mlutils.plot_2d_clf_problem(X_art, y_art)

from sklearn.neighbors import KNeighborsClassifier

# Vaš kôd ovdje


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-SVM-i-kNN-checkpoint.ipynb".
The first task is:
(b)
Pomoću funkcije datasets.make_classification generirajte dva skupa podataka od $N=200$ primjera: jedan s $n=2$ dimenzije i drugi s $n=1000$ dimenzija. Primjeri neka dolaze iz dviju klasa, s time da svakoj klasi odgovaraju dvije grupe (n_clusters_per_class=2), kako bi problem bio nešto složeniji, tj. nelinearniji. Neka sve značajke budu informativne. Podijelite skup primjera na skup za učenje i skup za ispitivanje u omjeru 1:1.
Na oba skupa optimirajte SVM s jezgrenom funkcijom RBF, u rešetci $C\in{2^{-5},2^{-4},\dots,2^{15}}$ i $\gamma\in{2^{-15},2^{-14},\dots,2^{3}}$. Prikažite površinu pogreške modela na skupu za učenje i skupu za provjeru, i to na oba skupa podataka (ukupno četiri grafikona) te ispišite optimalne kombinacije hiperparametara. Za prikaz površine pogreške modela možete koristiti funkciju mlutils.plot_error_surface.
Can you write Python code for it?

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# Vaš kôd ovdje


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-SVM-i-kNN-checkpoint.ipynb".
The first task is:
(b)
Proučite razred preprocessing.MinMaxScaler. Prikažite histograme vrijednosti značajki $x_0$ i $x_1$ ako su iste skalirane min-max skaliranjem (ukupno dva histograma).
Can you write Python code for it?

from sklearn.preprocessing import MinMaxScaler

x0b = MinMaxScaler().fit_transform(X[:,0].reshape(-1,1), y)
x1b = MinMaxScaler().fit_transform(X[:,1].reshape(-1,1), y)

figure(figsize(12, 4))
subplot(1,2,1)
hist(x0b, bins = 50)
subplot(1,2,2)
hist(x1b, bins = 50)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-SVM-i-kNN-checkpoint.ipynb".
The first task is:
1. Klasifikator stroja potpornih vektora (SVM)
(a)
Upoznajte se s razredom svm.SVC, koja ustvari implementira sučelje prema implementaciji libsvm. Primijenite model SVC s linearnom jezgrenom funkcijom (tj. bez preslikavanja primjera u prostor značajki) na skup podataka seven (dan niže) s $N=7$ primjera. Ispišite koeficijente $w_0$ i $\mathbf{w}$. Ispišite dualne koeficijente i potporne vektore. Završno, koristeći funkciju mlutils.plot_2d_svc_problem iscrtajte podatke, decizijsku granicu i marginu. Funkcija prima podatke, oznake i klasifikator (objekt klase SVC).
Izračunajte širinu dobivene margine (prisjetite se geometrije linearnih modela).
Can you write Python code for it?

from sklearn.svm import SVC

seven_X = np.array([[2,1], [2,3], [1,2], [3,2], [5,2], [5,4], [6,3]])
seven_y = np.array([1, 1, 1, 1, -1, -1, -1])

fit = SVC(gamma = 'scale', kernel = 'linear').fit(seven_X, seven_y)
mlutils.plot_2d_svc_problem(seven_X, seven_y, fit)