import cv2
import numpy as np
import os
import pickle
import tensorflow as tf
from sklearn.metrics import confusion_matrix
import cv2
import numpy as np
import os
import pickle
import tensorflow as tf
from sklearn.metrics import confusion_matrix

#Funkcja pobierz n elementow
def prepare_y(result):
    tmp = np.zeros(output_size)
    tmp[result] = 1
    return tmp.tolist()

def get_next_batch(batch_size, data_set):
    elements = np.random.randint(0, len(data_set), batch_size)
    x = np.array([tmp[0].tolist() for tmp in [data_set[i] for i in elements]])
    y = np.array([prepare_y(tmp[1]) for tmp in [data_set[i] for i in elements]])

    return (x, y)

def get_all_set(data_set):
    x = np.array([tmp[0].tolist() for tmp in data_set])
    y = np.array([prepare_y(tmp[1]) for tmp in data_set])

    return (x, y)
#Funkcja pobierz n elementow
def prepare_y(result):
    tmp = np.zeros(output_size)
    tmp[result] = 1
    return tmp.tolist()
​
def get_next_batch(batch_size, data_set):
    elements = np.random.randint(0, len(data_set), batch_size)
    x = np.array([tmp[0].tolist() for tmp in [data_set[i] for i in elements]])
    y = np.array([prepare_y(tmp[1]) for tmp in [data_set[i] for i in elements]])

    return (x, y)
​
def get_all_set(data_set):
    x = np.array([tmp[0].tolist() for tmp in data_set])
    y = np.array([prepare_y(tmp[1]) for tmp in data_set])

    return (x, y)

folder_path = "F:\\EiTI Infa\\Semestr 6\\SNR\\SNR Projekt\\"
​
path = folder_path + "SET_C\\"
bounding_boxes = folder_path + "bounding_boxes.txt"
class_min = 483
class_max = 538
size_x = 64
size_y = 128
boxes = {}
hog = cv2.HOGDescriptor() # grupa IC
data_set = []

for row in open(bounding_boxes).read().split('\n'):
    if row == "":
        break
    tmp = row.split()
    boxes[tmp[0]+".jpg"] = list(map(int, tmp[1:5]))

for folder in os.listdir(path):
    print(folder)
    for file in os.listdir(path+folder):
        img = cv2.imread(path+folder+"\\"+file, cv2.IMREAD_COLOR)
        bb = boxes[file]
        crop_img = img[bb[1]:bb[1]+bb[3], bb[0]:bb[0]+bb[2]]
        resized_image = cv2.resize(crop_img, (size_x, size_y))
        hog_descriptor = hog.compute(resized_image)
​
        data_set.append([hog_descriptor.reshape(hog_descriptor.size), int(folder) - class_min])
​
data_set = np.array(data_set)

#Zapis danych!
​
data_set_file = open('birds.data', 'wb')
pickle.dump(data_set, data_set_file)
data_set_file.close()

#Odczyt danych!
​
data_set_file = open('birds.data', 'rb')
data_set = pickle.load(data_set_file)
data_set_file.close()

#Przygotowanie zbiorow testowego i treningowego
test_set_ratio = 0.3
test_set_elements = []
for i in range(class_max - class_min + 1):
    tmp = data_set[np.array(data_set)[:, 1] == i]
    test_element_count = int(len(tmp) * test_set_ratio)
    test_set_elements = test_set_elements + list(np.random.permutation([True] * test_element_count + [False] * (len(tmp) - test_element_count)))
​
test_set_elements
training_set_elements = np.logical_not(test_set_elements)
​
test_set = data_set[test_set_elements]
training_set = data_set[training_set_elements]

activation
### SIEC NEURONOWA ###
​
layer_size_base = 32
layers = np.array([2, 4, 5, 8, 10])
#layers = np.array([3, 6, 9, 12])
#layers = np.array([5, 10, 15])
#layers = np.array([10, 20])
#layers = np.array([30])
​
layers = layers * layer_size_base
​
input_size = len(data_set[0][0])
output_size = class_max - class_min + 1
activation = tf.nn.relu
​
layers = np.insert(layers, 0, input_size)
layers = np.append(layers, output_size)

## MODEL SIECI!
tf.reset_default_graph()
​
x  = tf.placeholder(tf.float32, [None, input_size], name = 'x')
y_ = tf.placeholder(tf.float32, [None, output_size], name = 'y_')
eps = tf.placeholder(tf.float32, name = 'eps')
​
layers_count = len(layers)
​
for i in range(layers_count - 1):
    W = tf.Variable(tf.truncated_normal([layers[i], layers[i+1]], 0, 1/np.sqrt(layers[i])))
    b = tf.Variable(np.zeros(layers[i + 1]), dtype = tf.float32)
    if i == 0:
        y = activation(tf.matmul(x, W) + b)
    else:
        y = activation(tf.matmul(y, W) + b)
​
y = tf.nn.softmax(y)
cross_entropy = -tf.reduce_sum(y_*tf.log(y))
​
opimalizer = tf.train.GradientDescentOptimizer(eps)
train_step = opimalizer.minimize(cross_entropy)

#Inicjalizacja grafu
​
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())

#Uczenie sieci
batch_size = 200
test_batch_size = 200
iteration_count = 10_000
eps_param = 0.0009
print_info_rate = 10000
​
​
print("Iteracja\tBłąd\t\tSkuteczność[zbior treningowy]\tSkuteczność[zbior testowy]")
test_xs, test_ys = get_all_set(test_set)
​
for i in range(0, iteration_count + 1, batch_size):
    batch_xs, batch_ys = get_next_batch(batch_size, training_set)
    sess.run(train_step, feed_dict = {x: batch_xs, y_: batch_ys, eps: eps_param})

    if i % print_info_rate == 0:
        training_error = cross_entropy.eval(feed_dict={x: batch_xs, y_: batch_ys})

        result = y.eval(feed_dict={x:test_xs})

        trening_xs, trening_ys = get_next_batch(1000, training_set)
        traning_result = y.eval(feed_dict={x:trening_xs})

        print(str(i) + "\t\t" +
              str(training_error) + "\t\t" +
              "{:0,.2f}".format(100*np.mean(np.argmax(traning_result, axis = 1) == np.argmax(trening_ys, axis = 1)))+"%\t\t\t\t"+
              "{:0,.2f}".format(100*np.mean(np.argmax(result, axis = 1) == np.argmax(test_ys, axis = 1)))+"%")
​

#Macierz pomyłek
​
predictions = np.argmax(y.eval(feed_dict={x:test_xs}), axis = 1)
true_labels = np.argmax(test_ys, axis = 1)
​
conf_matrix = confusion_matrix(true_labels, predictions)
#parami trzeba łączyć True Positive, False Positive, ....
#Keras to liczy,
​

sess
pred = sess.predict(x_test)
pred = pred[:,1] # Only positive cases
plot_roc(pred,y_compare)

​

https://docs.google.com/document/d/1fLzQAGQgCDiCle04cCRCOCefYD1_2co6nqC2ica1jv4/edit



Ta część zadania bazuje na sieciach splotowych. W pierwszej kolejności uczą Państwo

(a konkretnie douczają) sieć na gotowej, popularnej i skutecznej strukturze, np. VGG-
16, VGG-19, AlexNet, ResNet-50, ResNet-101, GoogleNet, Inception-v3, SqueezeNet itp.

Wynik klasyfikacji na znanym modelu, będzie stanowił dla Państwa podstawę do porówania
skuteczności Państwa sieci. W następnym kroku tworzą Państwo swoją strukturę sieci
(może być wzorowana na popularnych sieciach, ale może to być kilka warstw splotowych,
muszą Państwo pamiętać ze im większa sieć, tym więcej parametrów do nauki i czas
treningu może być bardzo długi). Najlepiej, aby eksperymenty zacząć od:
- podziału danych na zbiory treningowy i testowy (np. w stosunku 5:1, wystarczy raz
podzielić dane i się tego trzymać)
- trenowania sieci
- wrzucania zdjęć bez modyfikacji danych
- sztucznego zwielokrotniania zdjęć treningowych (testowych nie ruszamy!), np.
każde zdjęcie poddajemy dodatkowo: a) rotacji, b) translacji, c) rotacji i translacji.
Modyfikacji dokonujemy np. losując dziesięć lub dwadzieścia razy kąt z pewnego
niewielkiego przedziału, np. ±5° lub/i wektory przesunięcia [x,y]. Do modyfikacji,
która najbardziej poprawi skuteczność klasyfikacji dodajemy losowo szum (np.
gaussowski). W ten sposób uzbierały się nam już cztery eksperymenty z sieciami. Z
tych czterech wybieramy jeden najlepszy i...
- sprawdzamy różne rozmiary deskryptora na warstwie przed klasyfikacją (trzy
dowolne rozmiary) – eksperyment piąty
- na najlepszej strukturze sprawdzamy, co się stanie, jak dodamy dropout –
eksperyment szósty
- na koniec badamy wpływ przesłonięcia obrazu:
- grupy A i B zakrywają fragmenty obrazów tylko ze zbioru treningowego
(zobaczymy, jak sobie radzi sieć, jeśli ma styczność z zasłoniętym częściowo
obrazkiem)
- grupy C i D zakrywają fragmenty obrazów treningowych (pewnej części obrazów,
nie wszystkich), będziemy chcieli sprawdzić jak sieć sobie poradzi, gdy do
treningu wejdą dane zakłócone (ktoś np. wsadzi palec, lub inaczej przesłoni
zdjęcie)
Eksperyment z wczesnym zatrzymaniem uczenia niech Państwo wprowadzą na dowolnym
etapie, na początku, w środku, na końcu,
(Uwaga, liczą się wyniki na zbiorze testowym, w treningu powinno się udać zejść do
100% skuteczności.)