семестр 2 / лабы / lab5_prot

import os
import skimage
import numpy
import matplotlib.pyplot as plt
from scipy.optimize import minimize
from threading import Thread
import time

#Создание класса-наследника класса Thread с возвращением элементов
class ThreadRV(Thread):

    def __init__(self, group=None, target=None, name=None,
        args=(), kwargs={}, Verbose=None):
        Thread.__init__(self, group, target, name, args, kwargs)
        self._return = None

    def run(self):
        if self._target is not None:
            self._return = self._target(*self._args, ** self._kwargs)

    def result(self):
        return self._return

#Функция вызова потоков
def thrd_call(trg, argnt1, argnt2, a):
    thread1 = ThreadRV(target=trg, args =argnt1)
    thread2 = ThreadRV(target=trg, args =argnt2)
    thread1.start()
    thread2.start()
    if a == False:
        thread2.join()
        thread1.join()
    elif a == True:
        thread1.join()
        thread2.join()
        return (thread1.result(), thread2.result())

#Функция считывания названий файлов
def f_name(s):
    lt = os.listdir(s)
    return lt

#Функция создания списков изображений
def img_read(ls, path):
    array = []
    for i in ls:
        array.append(numpy.array(skimage.io.imread(f'{path}/{i}')))
    return array

#Функция «упрощения» изображений
def img_symplify(array):
    new_array = array.copy()
    c = 0
    l = int(len(new_array[0])*len(new_array[0][0])/2)
    for i in new_array:
        i = i[1::2]
        i = numpy.reshape(i, (l, 3))
        new_array[c] = numpy.mean(i, axis=1, dtype=numpy.int16)
        c += 1
    return new_array

#Функция извлечения части из массива
def arr_cut(array, left_border, right_border):
    array_cut = array[left_border:right_border]
    return array_cut

#Функция вычисления значений гипотезы
def h(th, arr):
    hypothesis = 1/(1+numpy.exp(-(arr@th)))
    return hypothesis

def h_thrd(th):
    h1, h2 = thrd_call(h,(theta,X_learn[0:int(len_X_learn/2)]),(theta,X_learn[int(len_X_learn/2)::]),True)
    return h1, h2

def h_test(th):
    hypothesis = 1/(1+numpy.exp(-(X_test@th)))
    return hypothesis

#Функция вычисления значения функции стоимости
def J(h,y,o):
    summ = numpy.sum(y.T@numpy.log(h) + (numpy.subtract(o,y)).T@numpy.log(numpy.subtract(o,h)))
    return summ

def J_thrd(th):
    h1, h2 = h_thrd(th)
    j1, j2 = thrd_call(J,(h1, Y_learn[0:int(len_Y_learn/2)],one[0:int(len_one/2)]),(h2, Y_learn[int(len_Y_learn/2)::],one[int(len_one/2)::]),True)
    summ = j1+j2
    return (-1)*summ/len_Y_learn

#Функция вычисления значений производных
def dJ(h,x,y):
    dif = (x.T@(numpy.subtract(h,y)))
    return numpy.divide(dif, len_Y_learn)

def dJ_thrd(th):
    h1, h2 = h_thrd(th)
    h_all = numpy.concatenate((h1, h2), axis=None)
    diff = dJ(h_all, X_learn, Y_learn)
    return diff

#Функция вычисления процента ошибок
def errors(theta):
    H = h_test(theta)
    H_sig = numpy.zeros(int(len(H)))
    c = 0
    for i in H:
        if i > 0.5:
            H_sig[c] +=1
        c += 1
    err = numpy.equal(H_sig,Y_test)
    return (numpy.sum(err)/len(H_sig))*100

def Callback(theta):
    print("HA!")

#Очистка окна консоли
os.system('cls')

#Запуск таймера
t1 = time.perf_counter_ns()

#Создание списков названий файлов в папках
trees_list, no_trees_list = thrd_call(f_name,("Trees",),("NoTrees",),True)

#Создание списков изображений в папке
trees_img_list, no_trees_img_list = thrd_call(img_read,(trees_list, "Trees"),(no_trees_list, "NoTrees"),True)

#Упрощение данных
trees_img_list, no_trees_img_list = thrd_call(img_symplify,(trees_img_list,),(no_trees_img_list,),True)

#Создание массива параметров
X = numpy.vstack((numpy.array(trees_img_list),numpy.array(no_trees_img_list)))
X = X.astype('float32')/255
X = numpy.hstack((numpy.ones((len(X),1),dtype=numpy.float16),X))

#Создание массива результатов
Y = numpy.hstack((numpy.ones(len(X)//2),numpy.zeros(len(X)//2)))

#Перемешивание массивов параметров и результатов
permutation = numpy.random.permutation(len(X))
X = X[permutation]
Y = Y[permutation]

#Разделение на части
##Выделение данных на обучение
X_learn, Y_learn = thrd_call(arr_cut,(X,0,6400),(Y,0,6400),True)
len_X_learn = len(X_learn)
len_Y_learn = len(Y_learn)
##Выделение данных на кроссвалидацию
X_cross, Y_cross = thrd_call(arr_cut,(X,6400,8400),(Y,6400,8400),True)
##Выделение данных на тестирование
X_test, Y_test = thrd_call(arr_cut,(X,8400,10400),(Y,8400,10400),True)

#Создание массива коэффициентов
theta = numpy.zeros(len(X_learn[0]))
len_theta = len(theta)
#theta = numpy.random.rand(len(X_learn[0]))
one = numpy.ones(len(Y_learn))
len_one = len(one)
k = 0
tmp = 1

print(f'Cost func at {k:03d} iteration: {J_thrd(theta):.4f}')
while tmp !=0:
    theta = numpy.subtract(theta, 0.03245*dJ_thrd(theta))
    tmp = J_thrd(theta)
    print(f'Cost func at {k:03d} iteration: {tmp:.4f}')
    k +=1

#Вывод времени выполнения программы
print(f'Total program execution time: \
{(time.perf_counter_ns()-t1)/10**9} seconds')