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')
