def run_network(save=True):
# THE MAIN FUNCTION. SET ALL HYPER-PARAMETERS HERE.
# Set predict_ny to True if you want to produce predictions for one year.
predict_ny = False
# years_ago is the number of seasons ago you want to use to make future predictons for. years_ago = 1 = 2016/17
years_ago = 2
# These are the input categories. It's important to list actual categories or NaNs are added to data and network breaks.
input_categories = ["GP","TOI","G","A1","A","P","iCF","iFF","iSF","iSCF","ixG","iFOW",
"Avg.DIST","D?","Age","GP_prev","G_prev","P_prev","iCF_prev","ixG_prev",
"GP_2prev","G_2prev","P_2prev", "iCF_2prev","ixG_2prev",
"GP_3prev","G_3prev","P_3prev","iCF_3prev","ixG_3prev"]
# Gets all the data.
train_set_x_orig, train_set_y, test_set_x_orig, test_set_y,names = get_inputs(input_categories,years_ago,predict_ny )
# x.shape = (dim,m) y.shape = (1,m)
layer1_dims = (train_set_x_orig.shape[0])
# Set the dimensions of network here
layers_dims = [layer1_dims,30,30, 1]
# Set the learning rate and # of iterations here.
# Learning rate seems to need to go down the more layers there are.
# beta1 controls the how much momentum the gradient has. Closer to 1 = more momentum. Set to 0 to turn off.
# beta2 slightly more complicated but it leads to gradient not getting out of control. Leave as is. Set to 0 to turn off.
# keep_prob controls dropout rate. Lower values lead to less overfitting. Set to 1 to turn off.
# However if there are layers with few neurons do not allow keep_prob to be too low.
# Don't want to lose all neurons in a layer
parameters = L_layer_model(train_set_x_orig, train_set_y, layers_dims,
learning_rate=0.01, beta1=0.9, beta2=0.999, num_iterations=4002, keep_prob=0.94,
print_cost=True)
Y_prediction_test = predict(parameters, test_set_x_orig)
Y_prediction_train = predict(parameters, train_set_x_orig)
# Print train/test Errors
# The average absolute difference between predicted points and actual points
# GOAL RIGHT NOW to get UNDER 9 for test set
print("train accuracy: {}".format(np.mean(np.abs(Y_prediction_train - train_set_y))))
print("test accuracy: {}".format(np.mean(np.abs(Y_prediction_test - test_set_y))))
if save:
save_predictions(test_set_y,Y_prediction_test,names)
def test_image(model, image_path):
classes = model['metadata']['classes']
print (classes)
img = Image.open(image_path)
plt.imshow(img)
new_shape = model['metadata']['input_size']
img = img.resize(new_shape, Image.ANTIALIAS)
img, _, _ = standardize(img, model['metadata']['train_mean'], model['metadata']['train_deviation'])
img = np.array(img).reshape((new_shape[0]*new_shape[1]*3, 1))
prediction = np.squeeze(NN.predict(model, img))
if prediction:
print ('The given model predicts this as a CAT image')
else:
print ('The given model predicts this as a NON-CAT image')
def main():
model = None
while True:
try:
print("\n1.Process images ")
print("2.Fit new model")
print("3.Load existing model")
print("4.Predict test data")
select = int(input("Please enter a number: "))
if select == 1:
print("\n\tProccesing train images...")
loadImages("images/TRAIN", True)
print("\tDONE! Train images are processed.")
print("\n\tProccesing test images...")
loadImages("images/TEST", True)
print("\tDONE! Test images are loaded.")
elif select == 2:
model = fitModel(epochs, batch_size)
elif select == 3:
try:
model = loadModel("network.h5")
except OSError:
print(
"\n!!! Model doesn't exist. You need first to fit model."
)
elif select == 4:
if model is not None:
predict(model)
else:
print("\n!!! You must first fit or load model")
except ValueError:
print("\n!!! That was no valid number. Try again...")
def conf_matrix(X_test,y_test, model):
rows_X, cols_X = X_test.shape
y_true = []
y_pred = []
for i in range(cols_X):
test = X_test[:,i]
p = nn.predict(test, model)
y_pred.append(int(p))
r = y_test[:,i]
if r[0]==1:
y_true.append(0)
elif r[1]==1:
y_true.append(1)
elif r[2]==1:
y_true.append(2)
r = confusion_matrix(y_true,y_pred)
r = np.asmatrix(r).transpose()
return r
def update_years_of_experience_input(quarter,
minute,
second,
down,
togo,
yardline,
formation,
yardlinedirection,
offenseteam,
defenseteam):
if years_of_experience is not None and years_of_experience is not '':
try:
salary = nn.predict(model, float(years_of_experience))
return salary
except ValueError:
return 'Unable to run'
def hyperparameter_search():
X, Y = neural_network.generate_dataset(8)
layers_shape = (8, 3, 8)
learning_performance = []
for learning_rate in [0, 0.03, 0.03, 0.1, 0.3, 1, 3, 10, 30, 100]:
for iterations in [0, 3, 10, 30, 100, 300, 1000, 3000, 10000]:
print("learning rate", learning_rate, "iterations", iterations)
# `parameters` are the weights and biases
parameters = neural_network.train_model(
X,
Y,
layers_shape,
learning_rate=learning_rate,
iterations=iterations,
log_costs=False,
save_graph=False)
numCorrect = 0
for x in X:
x = np.array([x]).T
h, predicted_label = neural_network.predict(x, parameters)
if np.array_equiv(x, predicted_label):
numCorrect += 1
learning_performance.append(
[learning_rate, iterations, numCorrect / x.size])
# create diagram
frame = pd.DataFrame(learning_performance,
columns=["Learning rate", "#Iterations", "Accuracy"])
wide_frame = pd.pivot_table(frame,
values="Accuracy",
index=["Learning rate"],
columns="#Iterations")
sns.heatmap(wide_frame, cmap="viridis", annot=True)
plt.savefig("learning_performance.png")
plt.close()
y_min, y_max = X[:, 0].min() - .5, X[:, 0].max() + .5
h = 0.01
# Generate a grid of points with a distance h between them
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
# Predict the function value for the whole grid
Z = pred_func(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
# Plot the contour and training examples
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Spectral)
np.random.seed(0)
X, y = make_moons(200, noise=0.20)
plt.scatter(X[:, 0], X[:, 1], s=40, c=y, cmap=plt.cm.Spectral)
plt.figure(figsize=(16, 32))
hidden_layer_dimensions = [1, 2, 3, 4]
for i, nn_hdim in enumerate(hidden_layer_dimensions):
plt.subplot(5, 2, i + 1)
plt.title("HiddenLayerSize % d" % nn_hdim)
model = build_model(X, y, nn_hdim, print_loss=False)
plot_decision_boundary(lambda x: predict(model, x), X, y)
poop = np.array([1.6, -0.4])
print(predict(model, poop))
plt.show()
y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
h = 0.01
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
Z = pred_func(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Spectral)
#X = np.array([[-2, 1], [1, 1], [1.5, -0.5], [-2, -1], [-1, -1.5], [2, -2]])
#Y = np.array([[0, 1], [0, 1], [0, 1], [1, 0], [1, 0], [1, 0]])
#b = nn.build_model(X, Y, 4, print_loss=True)
np.random.seed(0)
X, y = make_moons(200, noise=0.20)
#nn.build_model(X, y, 4, 200000,print_loss=True)
plt.scatter(X[:, 0], X[:, 1], s=40, c=y, cmap=plt.cm.Spectral)
plt.figure(figsize=(16, 32))
hidden_layer_dimensions = [1, 2, 3, 4]
for i, nn_hdim in enumerate(hidden_layer_dimensions):
plt.subplot(5, 2, i + 1)
plt.title('HiddenLayerSize%d' % nn_hdim)
model = nn.build_model(X, y, nn_hdim, 200000, print_loss=True)
#nn.plot_decision_boundary(lambda x: nn.predict(model, x), X, y)
plot_decision_boundary(
lambda X: np.array([nn.predict(model, x) for x in X]), X, y)
plt.savefig('foo.png')
blue_is_closer, dist = f.rectangle_to_closest_line_distance(
BlueA, BlueB, GreenA, GreenB, newbox)
if dist < limit:
if blue_is_closer:
if f.above_line(BlueA, BlueB, newbox):
if f.rectangle_close_to_line(BlueA, BlueB, newbox,
rectangle_distance_limit):
# frame, newbox(~rect), kernel
image = frame.copy()
A, B, C, D = f.rect_to_points(newbox)
xmin, xmax, ymin, ymax = f.get_offset_values(
A, B, C, D)
output_shape, input_image = f.pre_detect(
frame, kernel, xmin, xmax, ymin, ymax)
number = nn.predict(input_image)
if number == last_blue_predicted_number:
if output_shape[0] == last_blue_roi_shape[
0] and output_shape[
1] == last_blue_roi_shape[1]:
print()
else:
suma = suma + number
last_blue_roi_shape = output_shape
last_blue_predicted_number = number
else:
suma = suma + number
last_roi_shape = output_shape
last_predicted_number = number
print(number)
def read_doc(file, mode, read_up, read_low, read_digit):
"""
read data from specified document
:param
file: the image to be read
:param
mode: type of the document (train/test)
:param
read_up: whether to work with uppercase classes
:param
read_low: whether to work with lowercase classes
:param
read_digit: whether to work with digit classes
:return:
dictionary of results for the server
"""
# get cnn model and graph
global model
global graph
# dictionary with result
result = {}
# convert file to numpy array
file = np.fromstring(file.read(), np.uint8)
# extract data to predict and original image to show
if mode == 'train':
data = pdf_read.read_train(file)
org_images = data[1][1]
inputs = data[1][0]
# evaluate the model on the training data
if BACKEND == 'tensorflow': # workaround for tensorflow bug with django
with graph.as_default():
result.update(
train_evaluate(data, read_up, read_low, read_digit))
else:
result.update(train_evaluate(data, read_up, read_low, read_digit))
else:
data = pdf_read.read_test(file)
org_images = data[1]
inputs = data[0]
# predict the results
if BACKEND == 'tensorflow': # workaround for tensorflow bug with django
with graph.as_default():
text = neural_network.predict(
model, inputs,
get_ignored_classes(read_up, read_low, read_digit))
else:
text = neural_network.predict(
model, inputs, get_ignored_classes(read_up, read_low, read_digit))
# add text and images into one list
read_data = list(map(list, zip(text, org_images)))
# split data into lines
read_data = split_array(read_data, LINE_BREAK)
# add reading results
result.update({'read_data': read_data})
return result
def plot_decision_boundary(pred_func, X, y):
x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
h = .01
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
Z = pred_func(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Spectral)
X, y = make_moons(200, noise=0.20)
plt.scatter(X[:, 0], X[:, 1], s=40, c=y, cmap=plt.cm.Spectral)
plt.show()
plt.figure()
hidden_layer_dimensions = [1, 2, 4, 5]
# hidden_layer_dimensions = [10, 20, 50, 100]
for i, nn_hdim in enumerate(hidden_layer_dimensions):
plt.subplot(2, 2, i + 1, aspect='equal')
plt.title('Hidden Layer Size : ' + str(nn_hdim))
model = nn.build_model(X, y, nn_hdim, 30000, True)
plot_decision_boundary(lambda x: nn.predict(model, x), X, y)
plt.show()
def find_numbers_clean(frame, lines_points, suma, blue_numbers, green_numbers):
suma = suma
frame_for_numbers = frame.copy()
gray = cv2.cvtColor(frame_for_numbers, cv2.COLOR_BGR2GRAY)
ret, th = cv2.threshold(gray, 20, 255, cv2.THRESH_BINARY)
th_cont_img = th.copy()
img, contours, hierarchy = cv2.findContours(th_cont_img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
hierarchy = hierarchy[0]
number_contours = []
number_rect = []
BlueA = lines_points[0][0]
BlueB = lines_points[0][1]
GreenA = lines_points[1][0]
GreenB = lines_points[1][1]
for contour in contours:
center, size, angle = cv2.minAreaRect(contour)
(x, y, w, h) = cv2.boundingRect(contour)
width, height = size
if width > 1 and width < 30 and height > 1 and height < 30:
if width > 9 or height > 9:
aboveBlue = above_line(BlueA, BlueB, (x, y, w, h))
aboveGreen = above_line(GreenA, GreenB, (x, y, w, h))
if aboveGreen or aboveBlue:
number_contours.append(contour) #not used
number_rect.append((x, y, w, h))
img = frame.copy()
#cv2.drawContours(img, boxes, -1, (0, 255, 255), 1)
minDistBlue = 0
minDistGreen = 0
#print(len(number_rect))
for rect in number_rect:
A, B, C, D = rect_to_points(rect)
limit = 2
# Check if close to Blue line
closeToBlueLine = rectangle_close_to_line(BlueA, BlueB, rect, limit)
closeToGreenLine = rectangle_close_to_line(GreenA, GreenB, rect, limit)
if closeToBlueLine or closeToGreenLine:
# Rectangle is close to one line:
# Udaljenost temena A(x,y) od linija
dA_b = point_to_line_distance(BlueA, BlueB, A)
dA_g = point_to_line_distance(GreenA, GreenB, A)
# Udaljenost temena B(x+w, y) od linija
dB_b = point_to_line_distance(BlueA, BlueB, B)
dB_g = point_to_line_distance(GreenA, GreenB, B)
# Udaljenost temana C(x, y+h) od linija
dC_b = point_to_line_distance(BlueA, BlueB, C)
dC_g = point_to_line_distance(GreenA, GreenB, C)
# Udaljeost temena D(x+w, y+h) od linija
dD_b = point_to_line_distance(BlueA, BlueB, D)
dD_g = point_to_line_distance(GreenA, GreenB, D)
minDistBlue = min(dA_b, dB_b, dC_b, dD_b)
minDistGreen = min(dA_g, dB_g, dC_g, dD_g)
xmin, xmax, ymin, ymax = get_offset_values(A, B, C, D)
region = frame.copy()
kernel = np.ones((3, 3), np.uint8)
if minDistBlue < minDistGreen:
# Paint rectangle in blue
if above_line(BlueA, BlueB, rect):
# #cv2.drawContours(img, [box], 0, (255, 0, 0), 2)
# cv2.rectangle(img, A, D, (255, 0, 0), 2)
# # Add number
# roi = region[ymin: ymax, xmin: xmax]
#
# blank_image = np.zeros((28,28,3), np.uint8)
# x_offset = (28-roi.shape[0])/2
# y_offset = (28-roi.shape[1])/2
#
# x_offset = int(round(x_offset))
# y_offset = int(round(y_offset))
#
# blank_image[x_offset: x_offset+roi.shape[0], y_offset: y_offset+roi.shape[1]] = roi
#
# # ppp = blank_image.copy()
# # plt.imshow(ppp)
# # plt.show()
#
# gray = cv2.cvtColor(blank_image, cv2.COLOR_BGR2GRAY)
# ret, th = cv2.threshold(gray, 20, 255, cv2.THRESH_BINARY)
# th = cv2.morphologyEx(th, cv2.MORPH_OPEN, kernel)
# th = cv2.resize(th, (28, 28), interpolation=cv2.INTER_AREA)
# input = (np.expand_dims(th, 0))
output_shape, input = pre_detect(frame, kernel, xmin, xmax, ymin, ymax)
number = nn.predict(input)
number = number[0]
addNumber = False
# Check blue_numbers
for last_blue_predicted_number, last_blue_roi_shape in blue_numbers:
if number == last_blue_predicted_number:
if output_shape[0] == last_blue_roi_shape[0] and output_shape[1] == last_blue_roi_shape[1]:
print("Isti su")
addNumber = False
break
else:
# Dodaj u listu
addNumber = True
else:
addNumber = True
if addNumber:
suma = suma + number
value = [number, output_shape]
blue_numbers.append(value)
# if number == last_blue_predicted_number:
# if output_shape[0] == last_blue_roi_shape[0] and output_shape[1] == last_blue_roi_shape[1]:
# print()
# else:
# suma = suma + number
# last_blue_roi_shape = output_shape
# last_blue_predicted_number = number
# else:
# suma = suma + number
# last_blue_roi_shape = output_shape
# last_blue_predicted_number = number
print(number)
else:
if above_line(GreenA, GreenB, rect):
# #cv2.drawContours(img, [box], 0, (0, 255, 0), 2)
# cv2.rectangle(img, A, D, (0, 255, 0), 2)
# # Substract number
# roi = region[ymin: ymax, xmin: xmax]
#
# blank_image = np.zeros((28, 28, 3), np.uint8)
# x_offset = (28 - roi.shape[0]) / 2
# y_offset = (28 - roi.shape[1]) / 2
#
# x_offset = int(round(x_offset))
# y_offset = int(round(y_offset))
#
# blank_image[x_offset: x_offset + roi.shape[0], y_offset: y_offset + roi.shape[1]] = roi
#
# # ppp = blank_image.copy()
# # plt.imshow(ppp)
# # plt.show()
#
# gray = cv2.cvtColor(blank_image, cv2.COLOR_BGR2GRAY)
# ret, th = cv2.threshold(gray, 20, 255, cv2.THRESH_BINARY)
# th = cv2.morphologyEx(th, cv2.MORPH_OPEN, kernel)
# th = cv2.resize(th, (28, 28), interpolation=cv2.INTER_AREA)
# input = (np.expand_dims(th, 0))
output_shape, input = pre_detect(frame, kernel, xmin, xmax, ymin, ymax)
number = nn.predict(input)
number = number[0]
minusNumber = False
# Check green_numbers
for last_green_predicted_number, last_green_roi_shape in green_numbers:
if number == last_green_predicted_number:
if output_shape[0] == last_green_roi_shape[0] and output_shape[1] == last_green_roi_shape[1]:
print("Isti su")
minusNumber = False
break
else:
minusNumber = True
else:
minusNumber = True
if minusNumber:
suma = suma - number
value = [number, output_shape]
green_numbers.append(value)
# if number == last_green_predicted_number:
# if output_shape[0] == last_green_roi_shape[0] and output_shape[1] == last_green_roi_shape[1]:
# print()
# else:
# suma = suma - number
# last_green_roi_shape = output_shape
# last_green_predicted_number = number
# else:
# suma = suma - number
# last_green_roi_shape = output_shape
# last_green_predicted_number = number
print(number)
else:
# Rectangle is not close any line:
#cv2.drawContours(img, [box], 0, (0, 0, 255), 2)
cv2.rectangle(img, A, D, (0, 0, 255), 2)
retVal = []
retVal.append(blue_numbers)
retVal.append(green_numbers)
return img, suma, retVal
def find_numbers(frame, lines_points, suma):
suma = suma
frame_for_numbers = frame.copy()
gray = cv2.cvtColor(frame_for_numbers, cv2.COLOR_BGR2GRAY)
ret, th = cv2.threshold(gray, 20, 255, cv2.THRESH_BINARY)
th_cont_img = th.copy()
img, contours, hierarchy = cv2.findContours(th_cont_img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
hierarchy = hierarchy[0]
number_contours = []
number_rect = []
BlueA = lines_points[0][0]
BlueB = lines_points[0][1]
GreenA = lines_points[1][0]
GreenB = lines_points[1][1]
for contour in contours:
center, size, angle = cv2.minAreaRect(contour)
(x, y, w, h) = cv2.boundingRect(contour)
width, height = size
if width > 1 and width < 30 and height > 1 and height < 30:
if width > 9 or height > 9:
aboveBlue = above_line(BlueA, BlueB, (x, y, w, h))
aboveGreen = above_line(GreenA, GreenB, (x, y, w, h))
if aboveGreen or aboveBlue:
number_contours.append(contour) #not used
number_rect.append((x, y, w, h))
img = frame.copy()
#cv2.drawContours(img, boxes, -1, (0, 255, 255), 1)
minDistBlue = 0
minDistGreen = 0
#print(len(number_rect))
for rect in number_rect:
#(A, B, C, D) = rect
(x, y, w, h) = rect
A = (x, y)
B = (x + w, y)
C = (x, y + h)
D = (x + w, y + h)
limit = 2
# Check if close to Blue line
closeToBlueLine = rectangle_close_to_line(BlueA, BlueB, rect, limit)
closeToGreenLine = rectangle_close_to_line(GreenA, GreenB, rect, limit)
if closeToBlueLine or closeToGreenLine:
# Rectangle is close to one line:
# Udaljenost temena A(x,y) od linija
dA_b = point_to_line_distance(BlueA, BlueB, A)
dA_g = point_to_line_distance(GreenA, GreenB, A)
# Udaljenost temena B(x+w, y) od linija
dB_b = point_to_line_distance(BlueA, BlueB, B)
dB_g = point_to_line_distance(GreenA, GreenB, B)
# Udaljenost temana C(x, y+h) od linija
dC_b = point_to_line_distance(BlueA, BlueB, C)
dC_g = point_to_line_distance(GreenA, GreenB, C)
# Udaljeost temena D(x+w, y+h) od linija
dD_b = point_to_line_distance(BlueA, BlueB, D)
dD_g = point_to_line_distance(GreenA, GreenB, D)
minDistBlue = min(dA_b, dB_b, dC_b, dD_b)
minDistGreen = min(dA_g, dB_g, dC_g, dD_g)
ys = []
xs = []
ys.append(A[1])
ys.append(B[1])
ys.append(C[1])
ys.append(D[1])
xs.append(A[0])
xs.append(B[0])
xs.append(C[0])
xs.append(D[0])
ymin = min(ys)
ymax = max(ys)
xmin = min(xs)
xmax = max(xs)
region = frame.copy()
kernel = np.ones((3, 3), np.uint8)
if minDistBlue < minDistGreen:
# Paint rectangle in blue
if above_line(BlueA, BlueB, rect):
#cv2.drawContours(img, [box], 0, (255, 0, 0), 2)
cv2.rectangle(img, A, D, (255, 0, 0), 2)
# Add number
roi = region[ymin: ymax, xmin: xmax]
blank_image = np.zeros((28,28,3), np.uint8)
x_offset = (28-roi.shape[0])/2
y_offset = (28-roi.shape[1])/2
x_offset = int(round(x_offset))
y_offset = int(round(y_offset))
blank_image[x_offset: x_offset+roi.shape[0], y_offset: y_offset+roi.shape[1]] = roi
# ppp = blank_image.copy()
# plt.imshow(ppp)
# plt.show()
gray = cv2.cvtColor(blank_image, cv2.COLOR_BGR2GRAY)
ret, th = cv2.threshold(gray, 20, 255, cv2.THRESH_BINARY)
th = cv2.morphologyEx(th, cv2.MORPH_OPEN, kernel)
th = cv2.resize(th, (28, 28), interpolation=cv2.INTER_AREA)
input = (np.expand_dims(th, 0))
number = nn.predict(input)
#print(number)
#print("Number:")
#print(number)
suma += number
else:
if above_line(GreenA, GreenB, rect):
#cv2.drawContours(img, [box], 0, (0, 255, 0), 2)
cv2.rectangle(img, A, D, (0, 255, 0), 2)
# Substract number
roi = region[ymin: ymax, xmin: xmax]
blank_image = np.zeros((28, 28, 3), np.uint8)
x_offset = (28 - roi.shape[0]) / 2
y_offset = (28 - roi.shape[1]) / 2
x_offset = int(round(x_offset))
y_offset = int(round(y_offset))
blank_image[x_offset: x_offset + roi.shape[0], y_offset: y_offset + roi.shape[1]] = roi
# ppp = blank_image.copy()
# plt.imshow(ppp)
# plt.show()
gray = cv2.cvtColor(blank_image, cv2.COLOR_BGR2GRAY)
ret, th = cv2.threshold(gray, 20, 255, cv2.THRESH_BINARY)
th = cv2.morphologyEx(th, cv2.MORPH_OPEN, kernel)
th = cv2.resize(th, (28, 28), interpolation=cv2.INTER_AREA)
input = (np.expand_dims(th, 0))
number = nn.predict(input)
#print(number)
suma -= number
else:
# Rectangle is not close any line:
#cv2.drawContours(img, [box], 0, (0, 0, 255), 2)
cv2.rectangle(img, A, D, (0, 0, 255), 2)
return img, suma
print('\n\n')
print('Check gradients')
check_nn_gradients()
print('\nChecking Backpropagation (w/ Regularization) ... \n')
# Check gradients by running checkNNGradients
_lambda = 3
check_nn_gradients(_lambda)
# Also output the costFunction debugging values
debug_J = compute_cost(nn_params, input_layer_size, hidden_layer_size, num_labels, X, y_test, _lambda)
print('\n\nCost at (fixed) debugging parameters (w/ lambda = 3): ', debug_J,
'\n(this value should be about 0.576051)')
print('\nPress enter to start training:')
input()
print('\nTraining Neural Network... \n')
theta1, theta2 = train_model(X, y_test, input_layer_size, hidden_layer_size, num_labels)
print('\nVisualizing Neural Network... \n')
#display_data(theta1[:, 1:])
# predict using trained parameters
pred = predict(theta1, theta2, X)
print('\nTraining Set Accuracy: ', np.mean(pred == y_test) * 100)
import neural_network as nn
data_set = [[2.7810836, 2.550537003, 0],
[1.465489372, 2.362125076, 0],
[3.396561688, 4.400293529, 0],
[1.38807019, 1.850220317, 0],
[3.06407232, 3.005305973, 0],
[7.627531214, 2.759262235, 1],
[5.332441248, 2.088626775, 1],
[6.922596716, 1.77106367, 1],
[8.675418651, -0.242068655, 1],
[7.673756466, 3.508563011, 1]]
train = data_set
test = train[4:6]
n_inputs = 2 # number of features
n_hidden_layers = 1 # how many hidden layers
n_hidden_neurons = 5 # how many neuron per hidden layer
n_outputs = 2 # number of classes
my_neural_network = nn.initialize_network(n_inputs, n_hidden_layers, n_hidden_neurons, n_outputs)
n_epoch = 40
l_rate = .3
nn.train_the_network(my_neural_network, train, l_rate, n_epoch, n_outputs)
for row in test:
predict = nn.predict(my_neural_network, row)
print('actual=>', row[-1], 'predicted=>', predict)
## Load training data
X = digits.data
y = digits.target[:, np.newaxis]
## Load theta weights into a list of thetas
thetas = nn.create_hidden_layer_thetas(nn_layers_info)
## Unroll parameters
nn_params = nn.unroll_parameters(thetas)
## Training neural network
# optimal_thetas = nn.fmincg(nn_params, X, y, nn_layers_info, lambda_reg=0) # Using advanced algorithm fmincg
optimal_thetas = nn.gradient_decsend(nn_params,
X,
y,
nn_layers_info,
lambda_reg,
0.53,
300,
plot=True) # Handwritten gradient descend
## Predict - Compare result to training labels
prediction = nn.predict(optimal_thetas, X)
accuracy = np.mean(prediction == y) * 100
print("# Training set accuracy: {}".format(accuracy))
## Save trained weights
if accuracy >= 90:
np.save("8x8_weights.npy", nn.unroll_parameters(optimal_thetas))
a.array(temp[3], temp[2], temp[0], hunger)
a.plot()
e = Eliminator(user_info[0][3])
e.elimination()
e.plot()
elimination_array = np.load("eliminated_array.npy")
elim_time = np.array(elimination_array[minute], ndmin=2)
bac_array.append(elimination_array[minute])
# trains neural network every 5 inputs and lets it predict the drunkeness
user_input_array.append(how_drunk)
if len(bac_array) % 5 == 0:
neural_network.learn(bac_array, user_input_array)
if len(bac_array) == 1:
neural_network.learn(bac_array, user_input_array)
prediction = neural_network.predict(elim_time)
print(prediction)
np.save("drinking_session.npy", user_info)
# informs the elimination rate adjuster on how the elimination rate will have to be adjusted
elif decision == 2:
sober_time = 0
min = int(input("How many minutes ago did you sober up? \n"))
sober_time = minute - min
e.adjustment(sober_time)
elif decision == 3:
time = input("What time is it? (enter in hh:mm format) \n")
hour = int((time[0] + time[1]))
minute = int((time[3] + time[4]))
minute += hour * 60
temp.append(minute)
def on_button_release(self, event):
self.matrix.print_matrix()
str_prediction.set(predict(self.matrix.as_list()))
clf.fit(X.T, Y.T);
# Plot the decision boundary for logistic regression
plot_decision_boundary(lambda x: clf.predict(x), X, Y)
plt.title("Logistic Regression")
# Print accuracy
LR_predictions = clf.predict(X.T)
print ('Accuracy of logistic regression: %d ' % float((np.dot(Y,LR_predictions) + np.dot(1-Y,1-LR_predictions))/float(Y.size)*100) +
'% ' + "(percentage of correctly labelled datapoints)")
# Build a model with a n_h-dimensional hidden layer
parameters = nn_model(X, Y, n_h = 4, num_iterations = 10000, print_cost=True)
# Plot the decision boundary
plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)
plt.title("Decision Boundary for hidden layer size " + str(4))
'''
Accuracy is really high compared to Logistic Regression. The model has learnt
the leaf patterns of the flower! Neural networks are able to learn even
highly non-linear decision boundaries, unlike logistic regression.
'''
# Tuning hidden layer size
plt.figure(figsize=(16, 32))
hidden_layer_sizes = [1, 2, 3, 4, 5, 20, 50]
for i, n_h in enumerate(hidden_layer_sizes):
plt.subplot(5, 2, i+1)
plt.title('Hidden Layer of size %d' % n_h)
parameters = nn_model(X, Y, n_h, num_iterations = 5000)
