def updata_img(self): if self.type == "curve": self.img = polynomial(self.raw_img, self.X, self.Y) self.show_img() self.show_curve() elif self.type == "line": self.img = line(self.raw_img, self.a, self.b) self.show_line() self.show_img() elif self.type == "broken": self.img = polynomial(self.raw_img, self.X, self.Y) self.show_img() self.show_curve() elif self.type == "histeq": self.img, self.cdf = histeq(self.raw_img) self.show_img() self.show_histeq() elif self.type == "gamma": self.img = gamma_trans(self.raw_img, self.gamma) self.show_img() self.show_gamma()
def sin_with_noise(N=20, min_val=0, max_val=1, M=9, std=0.25): x = np.linspace(min_val, max_val, N) train_y = pi_sin_noise(x, std=std) train_X = polynomial(x, M) test_x = np.linspace(min_val, max_val, N * 2) t = pi_sin(test_x) test_X = polynomial(test_x, M) return train_X, train_y, test_X, t
def design_matrix(x_train, M): ''' :param x_train: input vector Nx1 :param M: polynomial degree 0,1,2,... :return: Design Matrix Nx(M+1) for M degree polynomial ''' return polynomial(x_train, M)
def predict(self,datax): if len(datax.shape)==1: datax = datax.reshape(1,-1) if self.gaussian_kernel: datax = gaussian_transformation(datax, self.sigma) else: datax = polynomial(datax, self.polynomial_degree) return np.array([np.sign(np.dot(self.w.T,x)) for x in datax]).flatten()
def mean_squared_error(x, y, w): ''' :param x: ciag wejsciowy Nx1 :param y: ciag wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: blad sredniokwadratowy pomiedzy wyjsciami y oraz wyjsciami uzyskanymi z wielowamiu o parametrach w dla wejsc x ''' return np.sum((y - polynomial(x,w))**2)/np.shape(x)[0]
def mean_squared_error(x, y, w): """ :param x: ciag wejsciowy Nx1 :param y: ciag wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: blad sredniokwadratowy pomiedzy wyjsciami y oraz wyjsciami uzyskanymi z wielowamiu o parametrach w dla wejsc x """ return np.mean(np.power(polynomial(x, w) - y, 2))
def mean_squared_error(x, y, w): """ :param x: ciąg wejściowy Nx1 :param y: ciąg wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: błąd średniokwadratowy pomiędzy wyjściami y oraz wyjściami uzyskanymi z wielowamiu o parametrach w dla wejść x """ return np.mean(np.square(y - polynomial(x, w)))
def mean_squared_error(x, y, w): """ :param x: ciąg wejściowy Nx1 :param y: ciąg wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: błąd średniokwadratowy pomiędzy wyjściami y oraz wyjściami uzyskanymi z wielowamiu o parametrach w dla wejść x """ polinom = np.array(polynomial(x, w)) es = ((y - polinom)**2) / np.shape(x)[0] return np.sum(es)
def mean_squared_error(x, y, w): ''' :param x: ciag wejsciowy Nx1 :param y: ciag wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: blad sredniokwadratowy pomiedzy wyjsciami y oraz wyjsciami uzyskanymi z wielowamiu o parametrach w dla wejsc x ''' N = len(x) dm = [(y[i] - polynomial(x[i], w))**2 for i in range(N)] return (1 / N) * np.sum(dm)
def mean_squared_error(x, y, w): ''' :param x: ciag wejsciowy Nx1 :param y: ciag wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: blad sredniokwadratowy pomiedzy wyjsciami y oraz wyjsciami uzyskanymi z wielowamiu o parametrach w dla wejsc x ''' y_cal = polynomial(x, w) N = y.shape[0] return (((y - y_cal)**2).sum()) / N
def mean_squared_error(x, y, w): ''' :param x: ciag wejsciowy Nx1 :param y: ciag wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: blad sredniokwadratowy pomiedzy wyjsciami y oraz wyjsciami uzyskanymi z wielowamiu o parametrach w dla wejsc x ''' differences_vector = np.subtract(y, polynomial(x, w)) squared_vector = np.multiply(differences_vector, differences_vector) sum = np.sum(squared_vector) return (1 / x.size) * sum
def mean_squared_error(x, y, w): ''' :param x: ciag wejsciowy Nx1 :param y: ciag wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: blad sredniokwadratowy pomiedzy wyjsciami y oraz wyjsciami uzyskanymi z wielowamiu o parametrach w dla wejsc x ''' N = len(x) err = 1 / N * np.sum([(y[n] - polynomial(x[n], w))**2 for n in range(N)]) #n - numer przykladu ze zbioru x return err
def mean_squared_error(x, y, w): """ :param x: ciąg wejściowy Nx1 :param y: ciąg wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: błąd średniokwadratowy pomiędzy wyjściami y oraz wyjściami uzyskanymi z wielowamiu o parametrach w dla wejść x """ y_train = polynomial(x, w) #y- Nx1 error = np.subtract(y, y_train) ** 2#bledy Nx1 return np.mean(error)
def mean_squared_error(x, y, w): ''' :param x: ciag wejsciowy Nx1 :param y: ciag wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: blad sredniokwadratowy pomiedzy wyjsciami y oraz wyjsciami uzyskanymi z wielowamiu o parametrach w dla wejsc x ''' _y = polynomial(x, w) sum = 0 for n in range(y.shape[0]): sum += (y[n] - _y[n])**2 return float(sum / y.shape[0])
def mean_squared_error(x, y, w): ''' :param x: ciag wejsciowy Nx1 :param y: ciag wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: blad sredniokwadratowy pomiedzy wyjsciami y oraz wyjsciami uzyskanymi z wielowamiu o parametrach w dla wejsc x ''' mean_error = 0 values = polynomial(x, w) for i in range(values.shape[0]): mean_error += (np.square(y[i] - values[i])) mean_error = mean_error / values.shape[0] return float(mean_error)
def mean_squared_error(x, y, w): """ :param x: ciag wejsciowy Nx1 :param y: ciag wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: blad sredniokwadratowy pomiedzy wyjsciami y oraz wyjsciami uzyskanymi z wielowamiu o parametrach w dla wejsc x """ error = 0.0 wartosciZModelu = polynomial(x, w) for i in range(y.size): error += (y[i][0] - wartosciZModelu[i][0])**2 error /= y.size return error
def mean_squared_error(x, y, w): """ :param x: ciag wejsciowy Nx1 :param y: ciag wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: blad sredniokwadratowy pomiedzy wyjsciami y oraz wyjsciami uzyskanymi z wielowamiu o parametrach w dla wejsc x """ pass result = 0 for i in range(x.shape[0]): result += pow(((y[i][0] - polynomial(x,w)[i][0])),2) result = result / x.shape[0] return float(result)
def mean_squared_error(x, y, w): ''' :param x: input vector Nx1 :param y: output vector Nx1 :param w: model parameters (M+1)x1 :return: mean squared error between output y and model prediction for input x and parameters w ''' sum = 0 N = len(x) for i in range(0, N): pred_yi = polynomial(x[i], w) sum += (y[i] - pred_yi)**2 return sum / N
def fit(self,datax,datay,testx=None,testy=None): """ :datax: donnees de train :datay: label de train :testx: donnees de test :testy: label de test """ datay = datay.reshape(-1,1) N = len(datay) datax = datax.reshape(N,-1) if self.gaussian_kernel: datax = gaussian_transformation(datax, self.sigma) else: datax = polynomial(datax, self.polynomial_degree) D = datax.shape[1] xinit = np.random.random((1,D)) loss = lambda x: self.loss(datax, datay, x) loss_g = lambda x: self.loss_g(datax, datay, x) ### optimize x_histo = [] f_histo = [] batchsize = 32 batches = minibatch_indexes(datax.shape[0],batchsize, shuffle=True) batch_count = batches.shape[0] grad_histo = [] dernier = xinit for i in range(self.max_iter): batch = batches[i % batch_count] X = datax[batch] Y = datay[batch] fonc = lambda x: self.loss(X, Y, x) dfonc = lambda x: self.loss_g(X, Y, x) x_histo.append(dernier - (self.eps * dfonc(dernier))) f_histo.append(fonc(dernier)) grad_histo.append(dfonc(dernier)) dernier = x_histo[i] x_histo = np.array(x_histo) f_histo = np.array(f_histo) ### optimal_idx = f_histo.argmin() self.w = x_histo[optimal_idx].reshape(-1,1)
def mean_squared_error(x, y, w): """ :param x: ciąg wejściowy Nx1 :param y: ciąg wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: błąd średniokwadratowy pomiędzy wyjściami y oraz wyjściami uzyskanymi z wielowamiu o parametrach w dla wejść x """ predictedY = polynomial(x, w) size = np.shape(x)[0] error = 0.0 index = 0 while index < size: error += (y[index] - predictedY[index])**2 index += 1 error /= size arr = np.array(error)[0] return arr
def show_curve(self): if self.type == "curve": x = np.arange(0, 255, 1) y = polynomial(x, self.X, self.Y) self.axes.plot(x, y) self.axes.plot(self.X, self.Y, "ob") elif self.type == "line": x = np.arange(0, 255, 1) y = line(x, self.X, self.Y) self.axes.plot(x, y) elif self.type == "broken": x = np.arange(0, 255, 1) y = broken(x, self.X, self.Y) self.axes.plot(x, y) self.axes.plot(self.X, self.Y, "ob") elif self.type == "gamma": x = np.arange(0, 255, 1) y = gamma_trans(x, self.X) self.axes.plot(x, y)
def mean_squared_error(x, y, w): ''' :param x: ciag wejsciowy Nx1 :param y: ciag wyjsciowy Nx1 :param w: parametry modelu (M+1)x1 :return: blad sredniokwadratowy pomiedzy wyjsciami y oraz wyjsciami uzyskanymi z wielowamiu o parametrach w dla wejsc x ''' # print("1: ", x) # print("2: ", y) # print("3: ", w) # print("4: ", polynomial(x, w)) # print("5: ", y - polynomial(x, w)) # print("5: ", (y - polynomial(x, w)) ** 2) # print("6: ",((y - polynomial(x, w)) ** 2).sum()) # print("7: ",x.shape[0]) # print("8: ",((y - polynomial(x, w)) ** 2).sum() / x.shape[0]) # np.set_printoptions(precision=2, suppress=True) return ((y - polynomial(x, w)) ** 2).sum() / y.shape[0]
def mean_squared_error(x, y, w): return np.mean((y - polynomial(x, w))**2)
print("MLE for one feature") print(one_feature_error_train) print(one_feature_error_test) plt.plot(all_feature_error_train, 'r', label='E_train on MLE with all feature') plt.plot(all_feature_error_test, 'b', label='E_test on MLE with all feature') plt.plot(one_feature_error_train, 'y', label='E_train on MLE with one feature') plt.plot(one_feature_error_test, 'g', label='E_test on MLE with one feature') plt.legend() plt.show() #MLE + polynomial features: finally choose d = 2 for all features; 0 feature to plot #all features: N_pretraining only has 125 data for d in range(2, 5): (Dpt_tr_std_poly, Dpt_test_std_poly) = utils.polynomial(d, Dpt_tr_std, Dpt_test_std) (coef, y_train_pred, y_test_pred, error_train, error_test) = modules.MLE(Dpt_tr_std_poly, ypt_tr, Dpt_test_std_poly, ypt_test) print("-----") print(d) print(coef, error_train, error_test) #MLE + PCA: choose c = 7 etrain = [] etest = [] for c in range(1, 9): (pca_ratio, Dpt_tr_std_pca, Dpt_test_std_pca) = utils.doPCA(c, Dpt_tr_std, Dpt_test_std) (coef, y_train_pred, y_test_pred, error_train, error_test) = modules.MLE(Dpt_tr_std_pca, ypt_tr, Dpt_test_std_pca,
def MLE_poly(d, X_train, y_train, X_test, y_test): (X_train_poly, X_test_poly) = utils.polynomial(d, X_train, X_test) (coef, y_train_pred, y_test_pred, error_train, error_test) = MLE(X_train_poly, y_train, X_test_poly, y_test) return(coef, y_train_pred, y_test_pred, error_train, error_test)
# Ladowanie danych with open(os.path.join(os.path.dirname(__file__), 'data.pkl'), mode='rb') as file: data = pickle.load(file) x_plot = np.arange(0, 1.01, 0.01) y_obj = target_output(x_plot) # Dopasowanie wielomianow metoda najmniejszych kwadratow print('\n--- Dopasowanie wielomianow metoda najmniejszych kwadratow ---') print('-------------- Liczba punktow treningowych N=8. --------------') fig = plt.figure(figsize=(12, 6), num='Zadanie najmniejszych kwadratow dla N=8') for i in range(8): w, err = least_squares(data['x_train_8'], data['y_train_8'], i) y_model = polynomial(x_plot, w) sub = fig.add_subplot(2, 4, i + 1) plot_model(data['x_train_8'], data['y_train_8'], x_plot, y_obj, y_model) sub.set_title("M = {}".format(i)) plt.tight_layout() plt.draw() print('\n--- Wcisnij klawisz, aby kontynuowac ---') plt.waitforbuttonpress(0) print('\n--- Dopasowanie wielomianow metoda najmniejszych kwadratow ---') print('-------------- Liczba punktow treningowych N=50. --------------') fig = plt.figure(figsize=(12, 6), num='Zadanie najmniejszych kwadratow dla N=50')
partition = partition(x, K) coefficients, train_errors, test_errors = cross_validate_for_all_lambdas( x, y, partition, lambdas, degree=M) overfit_coeff = coefficients[0] optimal_coeff = coefficients[np.argmin(test_errors)] underfit_coeff = coefficients[-1] ''' Plotting begins here ''' X = np.linspace(0, 1, 500) plt.figure(figsize=(19, 9)) plt.subplot(121) plt.plot(x, y, 'o', label='data') plt.plot(X, polynomial(X, overfit_coeff), label='overfit, lambda = 0') plt.plot(X, f(X), '-.', label='ground truth') plt.plot(X, polynomial(X, optimal_coeff), label='optimal fit, log lamda = ' + str(round(loglambdas[np.argmin(test_errors)], 2))) plt.plot(X, polynomial(X, underfit_coeff), label='underfit, log lamda = ' + str(round(loglambdas[-1], 2))) plt.title('Interpolation with variing regularization (lambda)') plt.axis((-0.05, 1.05, -1.3, 1.3)) plt.legend() plt.subplot(122) plt.plot(loglambdas, train_errors, 'b', label='training') plt.plot(loglambdas, test_errors, 'r', label='test')