def fit(self, X, Y):
"""
Callable method of an instance of this class
to determine a set of coefficients for the
given data
:param X: The conditioned input data
:param Y: The conditioned output data
"""
# Section 1: Condition the input and output data
self.X = self.__condition_data(X)
self.Y = self.__condition_data(Y)
# Section 2: Append a column of 1's unless the
# the user knows this is NOT necessary
if self.fit_intercept:
self.X = self.__add_ones_column_for_intercept(self.X)
# Section 3: Transpose the data into the null
# space of the X matrix using the transpose of X
# and solve for the coefficients using our general
# solve equations function
AT = la.transpose(self.X)
ATA = la.matrix_multiply(AT, self.X)
ATB = la.matrix_multiply(AT, self.Y)
self.coefs = la.solve_equations(ATA,ATB,tol=self.tol)
def __orient_data_correctly(self, D):
"""
Private function to ensure data is oriented
correctly for least squares operations;
This allows more flexible entry of data
:param D: The data structure to be
oriented; want more rows than columns
:returns: Correctly oriented data
"""
if len(D) < len(D[0]):
return la.transpose(D)
else:
return D
def predict(self, X_test):
"""
Condition the test data and then use the existing
model (existing coefficients) to solve for test
results
:param X_test: Input test data
:returns: Output results for test data
"""
# Section 1: Condition the input data
self.X_test = self.__condition_data(X_test)
# Section 2: Append a column of 1's unless the
# the user knows this is NOT necessary
if self.fit_intercept and self.add_ones_column:
self.X_test = self.__add_ones_column_for_intercept(self.X_test)
# Section 3: Apply the conditioned input data to the
# model coefficients
return la.matrix_multiply(self.X_test, self.coefs)
# Import conditioned data
X_train = cd.X_train
Y_train = cd.Y_train
X_test = cd.X_test
Y_test = cd.Y_test
# Solve for coefficients
mlls = ml.Least_Squares()
mlls.fit(X_train, Y_train)
print('Pure Coefficients:')
print(mlls.coefs, '\n')
# Make a prediction
YLS = mlls.predict(X_test)
YLST = la.transpose(YLS)[0]
# Look at our predictions and the actual values
print('PurePredictions:\n', YLST[0], '\n')
# Compare to sklearn
SKLearnData = [
103015.20159796, 132582.27760816, 132447.73845175, 71976.09851258,
178537.48221056, 116161.24230165, 67851.69209676, 98791.73374687,
113969.43533013, 167921.06569551
]
print('Delta Between SKLearnPredictions and Pure Predictions:')
for i in range(len(SKLearnData)):
delta = round(SKLearnData[i], 6) - round(YLST[i], 6)
print('\tDelta for outputs {} is {}'.format(i, delta))
import LinearAlgebraPurePython as la
import numpy as np
print('Shtuff from Basic Tools Post')
print()
la.print_matrix(la.zeros_matrix(3, 3))
print()
ID = la.identity_matrix(4)
la.print_matrix(ID)
print()
A = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
la.print_matrix(A)
print()
AM = la.copy_matrix(A)
la.print_matrix(AM)
print()
AT = la.transpose(A)
la.print_matrix(AT)
print()
C = la.matrix_addition(A, AT)
la.print_matrix(C)
print()
D = la.matrix_subtraction(C, AT)
la.print_matrix(D)
print()
AID = la.matrix_multiply(A, ID)
la.print_matrix(AID)
print()
MatrixList = [A, AT, ID]
Prod3 = la.multiply_matrices(MatrixList)
la.print_matrix(Prod3)
# and visualization
X = [float(x) / 20.0 for x in range(100)]
def y_of_x(x):
return 0.2 * x + 0.7 * x**2 + random.uniform(-1, 1)
Y = []
for x in X:
Y.append(y_of_x(x))
plt.scatter(X, Y) # sys.exit()
# Section 2: Get fake data in correct format
X = la.transpose([X])
Y = la.transpose([Y])
# Section 3: Pure Python Tools Fit
poly_pp = ml.Poly_Features_Pure_Py(order=2)
Xpp = poly_pp.fit_transform(X)
ls_pp = ml.Least_Squares(tol=2, add_ones_column=False)
ls_pp.fit(Xpp, Y)
# Section 4: SciKit Learn Fit
poly_sk = PolynomialFeatures(degree=2)
Xsk = poly_sk.fit_transform(X)
ls_sk = LinearRegression()
ls_sk.fit(Xsk, Y)
# Section 5: Coefficients Comparison
import LinearAlgebraPurePython as la
import conditioned_data as cd
import sys
# Import conditioned data
X_train = cd.X_train
Y_train = cd.Y_train
X_test = cd.X_test
Y_test = cd.Y_test
# Solve for coefficients
coefs = la.least_squares(X_train, Y_train)
print('Pure Coefficients:')
la.print_matrix(coefs)
print()
# Make a prediction
XLS1 = la.insert_at_nth_column_of_matrix(1, X_test, len(X_test[0]))
YLS = la.matrix_multiply(XLS1, coefs)
YLST = la.transpose(YLS)
# Look at our predictions and the actual values
print('PurePredictions:\n', YLST[0], '\n')
# Compare to sklearn
SKLearnData = [
103015.20159796, 132582.27760816, 132447.73845175, 71976.09851258,
178537.48221056, 116161.24230165, 67851.69209676, 98791.73374687,
113969.43533013, 167921.06569551
]
import LinearAlgebraPurePython as la
import MachineLearningPurePy as ml
import matplotlib.pyplot as plt
X = [[1, 2], [1, 4]]
Y = [2, 3]
plt.scatter(la.transpose(X)[1], Y)
mlls = ml.Least_Squares(fit_intercept=False)
mlls.fit(X, Y)
print(mlls.coefs)
XLS = [[1, 0], [1, 1], [1, 2], [1, 3], [1, 4], [1, 5]]
YLS = mlls.predict(XLS)
plt.plot(la.transpose(XLS)[1], YLS)
plt.xlabel('X Values')
plt.ylabel('Y Values')
plt.title('Pure Python Least Squares Line Fit')
plt.show()
import LinearAlgebraPurePython as la
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import sys
X = [[2, 3, 4, 2, 3, 4], [1, 2, 3, 1, 2, 3]]
Y = [1.8, 2.3, 2.8, 2.2, 2.7, 3.2]
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.scatter3D(X[0], X[1], Y)
ax.set_xlabel('X1 Values')
ax.set_ylabel('X2 Values')
ax.set_zlabel('Y Values')
ax.set_title('Pure Python Least Squares Two Inputs Data Fit')
coefs = la.least_squares(X, Y)
la.print_matrix(coefs)
XLS = [[1, 1.5, 2, 2.5, 3, 3.5, 4], [0, 0.5, 1, 1.5, 2, 2.5, 3]]
XLST = la.transpose(XLS)
XLST1 = la.insert_at_nth_column_of_matrix(1, XLST, len(XLST[0]))
YLS = la.matrix_multiply(XLST1, coefs)
YLST = la.transpose(YLS)
ax.plot3D(XLS[0], XLS[1], YLST[0])
plt.show()
if type(X) != list:
raise TypeError(error_string)
if type(X[0]) != list:
raise TypeError(error_string)
import LinearAlgebraPurePython as la
###############################################################################
max_range = 2
X = [[1*x for x in range(max_range)],
[2*x for x in range(max_range)]]
X = la.transpose(X)
la.print_matrix(X)
print()
my_poly = Poly_Features_Pure_Py(order=2)
my_poly.fit(X)
feature_names = my_poly.get_feature_names()
feature_names.sort()
print(feature_names)
print()
wxMax = ['x1^2', 'x0 x1', 'x1', 'x0^2', 'x0', '1']
wxMax.sort()
sklearn_poly_features = ['1', 'x0', 'x0 x1', 'x0^2', 'x1', 'x1^2']
sklearn_poly_features.sort()
import LinearAlgebraPurePython as la max_range = 2 X = [[1 * x for x in range(max_range)], [2 * x for x in range(max_range)]] # [3*x for x in range(max_range)], # [4*x for x in range(max_range)], # [5*x for x in range(max_range)]] X = la.transpose(X) # print(X) # Fitting Polynomial Regression to the dataset from sklearn.preprocessing import PolynomialFeatures poly_reg = PolynomialFeatures(degree=2) X_poly_features = poly_reg.fit(X) # print(X_poly_features) # print() # fit or fit_transform must be called before this is called feature_names = poly_reg.get_feature_names() feature_names.sort() print(feature_names) print() # X_poly_transform = poly_reg.transform(X) # print(len(poly_reg.get_feature_names())) # print(X_poly_transform) # print() # print(poly_reg.get_feature_names())
def y_of_x(x):
return 0.2 * x + 0.5 * x**2
Y = []
for x in X:
Y.append(y_of_x(x))
print('Calculated Y Values:', Y)
print()
plt.scatter(X, Y)
poly_sk = PolynomialFeatures(degree=2)
Xsk = poly_sk.fit_transform(la.transpose([X]))
ls_sk = LinearRegression()
ls_sk.fit(Xsk, Y)
print('SKLearn LS coefficients:', ls_sk.coef_, '\n')
XLS = [0, 1, 2, 3, 4, 5]
XLSsk = poly_sk.transform(la.transpose([XLS]))
YLS = ls_sk.predict(XLSsk)
plt.plot(XLS, YLS)
plt.xlabel('X Values')
plt.ylabel('Y Values')
plt.title('Pure Python Least Squares Line Fit')
plt.show()
def y_of_x(x):
return 0.2 * x + 0.5 * x**2
Y = []
for x in X:
Y.append(y_of_x(x))
print('Calculated Y Values:', Y)
print()
plt.scatter(X, Y)
poly_pp = ml.Poly_Features_Pure_Py(order=2)
Xpp = poly_pp.fit_transform(la.transpose([X]))
ls_pp = ml.Least_Squares(add_ones_column=False)
ls_pp.fit(Xpp, Y)
print('LS coefficients:', ls_pp.coefs)
XLS = [0, 1, 2, 3, 4, 5]
XLSpp = poly_pp.transform(la.transpose([XLS]))
YLS = ls_pp.predict(XLSpp)
plt.plot(XLS, la.transpose(YLS)[0])
plt.xlabel('X Values')
plt.ylabel('Y Values')
plt.title('Pure Python Least Squares Line Fit')
plt.show()
import LinearAlgebraPurePython as la
import ShortImplementation as si
print('A matrix')
A = [[5, 4, 3, 2, 1], [4, 3, 2, 1, 5], [3, 2, 9, 5, 4], [2, 1, 5, 4, 3],
[1, 2, 3, 4, 5]]
la.print_matrix(A)
print()
print('X matrix')
X = [[3], [4], [2], [5], [1]]
la.print_matrix(X)
print()
print('Calculate B from X')
B = la.matrix_multiply(A, X)
la.print_matrix(B)
print()
print('Solve for X')
XS = la.solve_equations(A, B, 9)
la.print_matrix(XS)
print()
# print('Solve for X')
# XS = si.solve_equations(A,B)
# la.print_matrix(XS)