## Convolution neuron network

import tensorflow as tf
tf.__version__

from tensorflow import keras
keras.__version__

from keras.datasets import cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()

x_train.shape

y_train.shape

x_train[0]

import matplotlib.pyplot as plt
plt.imshow(x_train[0])

print('Oznaka prve slike:', y_train[0])

y_train_one_hot=keras.utils.to_categorical(y_train,10)
y_test_one_hot=keras.utils.to_categorical(y_test,10)

y_train_one_hot[0]

x_train=x_train/255
x_test=x_test/255

#Kreiranje CNN-a:

model=keras.models.Sequential()
model.add(keras.layers.Conv2D(32,(3,3), activation='relu',padding='same',input_shape=(32,32,3)))
model.add(keras.layers.Conv2D(32,(3,3), activation='relu',padding='same'))
model.add(keras.layers.MaxPooling2D(pool_size=(2,2)))

#Odbacivanje - dropout

model.add(keras.layers.Dropout(0.25))

#5.- 8. sloj
model.add(keras.layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(keras.layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(keras.layers.MaxPooling2D(pool_size=(2,2)))
model.add(keras.layers.Dropout(0.25))

model.add(keras.layers.Flatten())

model.add(keras.layers.Dense(512, activation='relu'))

model.add(keras.layers.Dropout(0.5))

model.add(keras.layers.Dense(10, activation='softmax'))

model.summary()

#Treniranje CNN-a

model.compile(loss='categorical_crossentropy', optimizer='adam',metrics=['accuracy'])

povijest_modela=model.fit(x_train,y_train_one_hot, batch_size=32, epochs=20,validation_split=0.2)

import pandas as pd
pd.DataFrame(povijest_modela.history).plot(figsize=(8,5))
plt.grid(True)
plt.xlabel('Epochs')
plt.show

model.save('my_cifar_model.h5')

model.evaluate(x_test,y_test_one_hot)

#Testiranje na vlastitim slikama:

!curl -o macka.jpg https://www.kucni-ljubimci.com/wp-content/uploads/2017/04/Sretna-maca.jpg

slika = plt.imread("/content/macka.jpg")

slika.shape

from skimage.transform import resize
slika_resized = resize(slika, (32,32))

plt.imshow(slika_resized)

import numpy as np
vjerojatnosti = model.predict(np.array( [slika_resized,] ))

vjerojatnosti

broj_u_klase=['avion','automobil','ptica','mačka','jelen','pas','zaba','konj','brod', 'kamion']

index = np.argsort(vjerojatnosti[0,:])

for i in range (9,5,-1): #prvih nekoliko vjerojatnosti
print(broj_u_klase[index[i]], ":", vjerojatnosti[0,index[i]])

#
#

## Neutral network

Radi se u Google Colabu, ovo je moj kod. Zapamti ga za buduće radnje i na principu njega napravi zadani zadatak.

import tensorflow as tf
from tensorflow import keras

tf.__version__

#Dohvaćanje podataka

baza=keras.datasets.fashion_mnist
(X_train,y_train), (X_test,y_test)=baza.load_data()

X_train.shape

y_train

class_names=["T-shirt/top", "Trouser", "Pullover","Dress", "Coat", "Sandal", "Shirt", "Sneaker", "Bag", "Ankle boot"]

y_train[0]

class_names[y_train[0]]

X_train[0].shape

import matplotlib.pyplot as plt
plt.imshow(X_train[0], cmap='gray')

X_train=X_train/255

X_valid=X_train[:5000]
X_train=X_train[5000:]
y_valid=y_train[:5000]
y_train=y_train[5000:]

for i in range(0,5):
plt.subplot(151+i)
plt.imshow(X_valid[i], cmap='gray')
plt.title(class_names[y_valid[i]])
plt.show()

#Definiranje modela

model=keras.models.Sequential()

model.add(keras.layers.Flatten(input_shape=[28,28]))

model.add(keras.layers.Dense(300, activation="relu"))

model.add(keras.layers.Dense(100, activation="relu"))

model.add(keras.layers.Dense(10, activation="softmax"))

model.layers

#Prikaz arhitekture stvorenog modela

model.summary()

keras.utils.plot_model(model, show_shapes=True)

hidden1=model.layers[1]

weights, bias= hidden1.get_weights()

weights

#Kompailiranje modela

model.compile(loss="sparse_categorical_crossentropy",
optimizer="sgd",
metrics=["accuracy"]) #mozemo nabrojati više metrika

#Treniranje modela

history=model.fit(X_train,y_train,batch_size=32, epochs=20, validation_data=(X_valid, y_valid))
#history=model.fit(X_train,y_train,batch_size=256, epochs=20, validation_split=0.2)

#Vizualizacija rezultata treniranja

history.history.keys()

import pandas as pd
pd.DataFrame(history.history).plot(figsize=(8, 5))
plt.grid(True)
plt.ylim(0,1)
plt.show()

#Testiranje

model.evaluate(X_test,y_test)

predikcije=model.predict(X_test)

predikcije

import numpy as np
y_pred=np.argmax(predikcije,axis=-1)

y_pred

np.array(class_names)[y_pred]

for i in range(0,5):
plt.subplot(151+i)
plt.imshow(X_test[i], cmap='gray')
plt.title(class_names[y_pred[i]]) #što je predvidjelo
plt.show()

from sklearn.metrics import classification_report
print(classification_report(y_test,y_pred))

#
#

## Autoencoders

Radi se u Google Colabu, ovo je moj kod. Zapamti ga za buduće radnje i na principu njega napravi zadani zadatak. Autoencoderi.

import tensorflow
from tensorflow import keras
import matplotlib.pyplot as plt
import numpy as np

(x_train, _), (x_test, _) = keras.datasets.mnist.load_data()

x_train = x_train / 255
x_test = x_test / 255

encoder=keras.models.Sequential([
keras.layers.Flatten(input_shape=[28,28]),
keras.layers.Dense(100, activation="relu"),
keras.layers.Dense(30, activation="relu") #bottleneck
])

decoder=keras.models.Sequential([
keras.layers.Dense(100, activation="relu",input_shape=[30]),
keras.layers.Dense(28*28, activation="sigmoid"),
keras.layers.Reshape([28,28])
])

stacked_autoencoder=keras.models.Sequential([encoder,decoder])

stacked_autoencoder.compile(loss="binary_crossentropy", optimizer='adam', metrics=['accuracy'])

history=stacked_autoencoder.fit(x_train,x_train, epochs=10,validation_data=[x_test,x_test])

plt.figure(figsize=(20,5))
for i in range(8):
plt.subplot(2,8,i+1)
plt.imshow(x_test[i], cmap="binary")
plt.subplot(2,8,8+1+i)
pred=stacked_autoencoder.predict(x_test[i].reshape(1,28,28))
plt.imshow(pred.reshape(28,28),cmap="binary")

plt.figure(figsize=(10,5))
plt.subplot(1,3,1)
plt.imshow(x_test[0], cmap="binary")
plt.subplot(1,3,2)
latent_vector=encoder.predict(x_test[0].reshape(1,28,28))
plt.imshow(latent_vector, cmap="binary")
plt.subplot(1,3,3)
pred=decoder.predict(latent_vector)
plt.imshow(pred.reshape(28,28),cmap="binary")

1-30/(28*28)

#Denoising autoencoder

plt.figure(figsize=(10,5))
plt.subplot(1,2,1)
plt.imshow(x_test[0], cmap="binary")
plt.subplot(1,2,2)
noise=np.random.random((28,28))/4
plt.imshow(x_test[0]+noise, cmap="binary")

encoder=keras.models.Sequential([
keras.layers.Flatten(input_shape=[28,28]),
keras.layers.Dense(100, activation="relu"),
keras.layers.Dense(100, activation="relu"), ######
keras.layers.Dense(30, activation="relu") #bottleneck
])

decoder=keras.models.Sequential([
keras.layers.Dense(100, activation="relu",input_shape=[30]),
keras.layers.Dense(100, activation="relu"),#####
keras.layers.Dense(28*28, activation="sigmoid"),
keras.layers.Reshape([28,28])
])

stacked_autoencoder=keras.models.Sequential([encoder,decoder])

stacked_autoencoder.compile(loss="binary_crossentropy", optimizer='adam', metrics=['accuracy'])

#dodavanje šuma
x_train_noise=x_train+((np.random.random(x_train.shape))/4)
x_test_noise=x_test+((np.random.random(x_test.shape))/4)

history=stacked_autoencoder.fit(x_train_noise,x_train, epochs=10,validation_data=[x_test_noise,x_test])

plt.figure(figsize=(20,5))

for i in range(8):
plt.subplot(2,8,i+1)
plt.imshow(x_test_noise[i], cmap="binary")

plt.subplot(2,8,8+1+i)
pred=stacked_autoencoder.predict(x_test_noise[i].reshape(1,28,28))
plt.imshow(pred.reshape(28,28),cmap="binary")