def main(argv):
model = nn.load(argv[1])
gui = paint.gui()
print("past init")
while True:
time.sleep(2 - time.monotonic() % 2)
image = gui.get_image()
data = np.array(image).astype(np.float32)
data = skimage.measure.block_reduce(data,
block_size=(10, 10),
func=np.mean)
data = torch.from_numpy(data)
data = data[None, None, :, :] # correct the number of dimensions
print(data.size())
nn.predict(model, data)
def update(words, gold_tags, gold_arclabels, gold_tree,i):
global y_train,x_test,y_test
buffer = words
stack = []
dummy = []
dummy = np.asarray(dummy)
pdt = [0]*len(words)
#tags = self.tagger.update(words, gold_tags)
#arc_tags = self.arc_tagger.update(words, gold_arclabels) # TODO: This is wrong, currently only looking at words , not pdt and words
x=0
while (True):
dummy = []
g_move = gold_move(x,stack,pdt,gold_tree)
if g_move is None:
break
#feature = features(words,tags,x,stack,pdt)
if i==0:
y_train.append(g_move)
else:
y_test.append(g_move)
dummy = nn.predict(buffer, stack, pdt, x, gold_tags, gold_arclabels)
if i==0:
x_train.append(dummy)
else:
x_test.append(dummy)
x, stack, pdt = move(x,stack,pdt,g_move)
return pdt
def fitness_func(solution, sol_idx):
global GANN_instance, data_inputs, data_outputs
predictions = nn.predict(last_layer=GANN_instance.population_networks[sol_idx],
data_inputs=data_inputs)
correct_predictions = numpy.where(predictions == data_outputs)[0].size
solution_fitness = (correct_predictions/data_outputs.size)*100
return solution_fitness
def test_predicts(self):
np.random.seed(1)
X_assess = np.random.randn(2, 3)
parameters = {'W1': np.array([[-0.00615039, 0.0169021 ],[-0.02311792, 0.03137121],
[-0.0169217 , -0.01752545],[ 0.00935436, -0.05018221]]),
'W2': np.array([[-0.0104319 , -0.04019007, 0.01607211, 0.04440255]]),
'b1': np.array([[ -8.97523455e-07], [ 8.15562092e-06], [ 6.04810633e-07],[ -2.54560700e-06]]),
'b2': np.array([[ 9.14954378e-05]])}
preds = nn.predict(parameters, X_assess)
self.assertEqual(np.mean(preds), 0.6666666666666666)
def get_acc(nn, X, Y):
"""
Calculates the accuracy of a neural network
Parameters:
- nn: the neural network
- X: the design matrix with shape (n, m), where n is the number
of features and m is the number of examples
- Y: the labels as an array with shape (m,), where m is the
number of examples
Returns:
- acc: the accuracy nn gets on predicting the labels
"""
m = X.shape[1]
Y_hat = nn.predict(X)
acc = np.sum(Y == Y_hat) / m
return acc
return X, y
train_set_x, train_set_y = prepare_data(train_images)
test_set_x, test_set_y = prepare_data(test_images)
train_set_x_flatten = train_set_x.reshape(train_set_x.shape[0], ROWS*COLS*CHANNELS).T
test_set_x_flatten = test_set_x.reshape(test_set_x.shape[0], -1).T
train_set_x = train_set_x_flatten/255
test_set_x = test_set_x_flatten/255
NN = nn.model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 10000, learning_rate = 0.003, print_loss= True)
im = cv2.imread('test/dog1.jpg',0)
im = cv2.resize(im,(ROWS,COLS))
test= im.reshape(1, ROWS*COLS).T
pred = nn.predict(NN["w"], NN["b"], test)
print(pred)
learning_rates = [0.001,0.01,0.005]
models = {}
for i in learning_rates:
print("learning rate is: ",i)
models[i] = nn.model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 10000, learning_rate = i, print_loss= True)
print("---------------------------------------------------------")
for i in learning_rates:
plt.plot(np.squeeze(models[i]["loss"]), label= str(models[i]["learning_rate"]))
plt.ylabel('Loss')
plt.xlabel("iterations (hundreds)")
legend = plt.legend(loc='upper center', shadow=True)
frame = legend.get_frame()
cv2.line(img,(last_x,last_y),(x,y),color=(255),thickness=75)
img = np.zeros((600,600,1), np.uint8)
cv2.namedWindow('draw')
cv2.setMouseCallback('draw',draw_line)
print(' _ _ _ _ __ __ ____ ______ _____ _____ ______ _______ ______ _____ _______ _____ ____ _ _ ')
print(' | \ | | | | | \/ | _ \| ____| __ \ | __ \| ____|__ __| ____/ ____|__ __|_ _/ __ \| \ | |')
print(' | \| | | | | \ / | |_) | |__ | |__) | | | | | |__ | | | |__ | | | | | || | | | \| |')
print(' | . ` | | | | |\/| | _ <| __| | _ / | | | | __| | | | __|| | | | | || | | | . ` |')
print(' | |\ | |__| | | | | |_) | |____| | \ \ | |__| | |____ | | | |___| |____ | | _| || |__| | |\ |')
print(' |_| \_|\____/|_| |_|____/|______|_| \_\ |_____/|______| |_| |______\_____| |_| |_____\____/|_| \_|')
print('---------------------------------------------------------------------------------------------------------')
print('[Enter] Predict Number | [C]lear | [Q]uit')
while(1):
cv2.imshow('draw',img)
key = cv2.waitKey(1)
if key == ord('q'):
break
if key == ord('c'):
img = np.zeros((600,600,1), np.uint8)
if key == 13:
image = cv2.resize(img,(28,28))
prediction = nn.predict(image)
max_index = np.argmax(prediction)
print("It's a "+'\033[1m'+str(max_index)+'\033[0m')
cv2.destroyAllWindows()
NeuralNetwork = nn.NeuralNetwork
nn = NeuralNetwork(2, 2, 1)
training = [
{
'inputs': [1, 0],
'targets': [1]
},
{
'inputs': [0, 1],
'targets': [1]
},
{
'inputs': [1, 1],
'targets': [0]
},
{
'inputs': [0, 0],
'targets': [0]
},
]
for i in range(100):
data = training[random.randint(0, 3)]
nn.train(data['inputs'], data['targets'])
answer = nn.predict([1, 0])
print(answer)
def predict(self):
self.set_status("Predicting...")
self.prediction = nn.predict(self.model, WAVE_OUTPUT_FILENAME)
self.string_prediction.set(COMMANDS[self.prediction])
self.set_status("Prediction calculated")
tw = re.sub(r'[^\w\s]', '', tw)
tw = tw.split()
posCnt = 0
negCnt = 0
small = []
for word in tw:
word = word.strip('\'"?,.!')
word = word.lower()
if word in positive:
posCnt += 1
if word in negative:
negCnt += 1
small.append(posCnt)
small.append(negCnt)
ans = nn.predict(small)
if ans >= 0.5:
pos = pos + 1
elif ans <= -0.4:
neg = neg + 1
else:
neut = neut + 1
print(ans)
print("\n\n")
posper = (pos * 100) / c
negper = (neg * 100) / c
neutper = (neut * 100) / c
print("Positive Tweets Percentage is: {}%".format(posper))
print("Negative Tweets Percentage is: {}%".format(negper))
from sklearn.datasets.samples_generator import make_blobs
import matplotlib.pyplot as plt
from nn import build_model
from nn import plot_decision_boundary
from nn import predict
from nn import build_model_691
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) #shows original scatter
plt.figure(figsize=(16, 32))
hidden_layer_dimensions = [1, 2, 3, 4]
for i, nn_hdim in enumerate(hidden_layer_dimensions):
plt.subplot(2, 2, i + 1)
plt.title('HiddenLayerSize%d' % nn_hdim)
model = build_model(X, y, nn_hdim)
plot_decision_boundary(lambda x: predict(model, x), X, y)
plt.show()
np.random.seed(0)
X, y = make_blobs(n_samples=100, centers=3, n_features=2, random_state=0)
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(2, 2, i + 1)
plt.title('HiddenLayerSize%d' % nn_hdim)
model = build_model_691(X, y, nn_hdim)
plot_decision_boundary(lambda x: predict(model, x), X, y)
plt.show()
num_iterations = 100
alpha = 1
if __name__ == '__main__':
sample_data = utils.linear_sep_data(num_of_examples)
train_data = sample_data[:num_of_train]
test_data = sample_data[num_of_train:]
plt.plot(train_data.T[0], train_data.T[1], 'ro')
plt.show()
# X, y = utils.load_train_set(num_of_examples)
X = train_data.T[:2]
y = train_data.T[2]
X_test = test_data.T[:2]
y_test = test_data.T[2]
X = X.reshape((2, num_of_train))
y = y.reshape((1, num_of_train))
X_test = X_test.reshape((2, num_of_test))
y_test = y_test.reshape((1, num_of_test))
# X = utils.normalize_features(X)
# X = X.T
# y = y.reshape((1, num_of_examples))
W, b = nn.zero_initializer(num_of_features)
optimal_params, costs = nn.gradient_descent_optimizer(
X, y, W, b, alpha, num_iterations)
W_opt = optimal_params[0]
b_opt = optimal_params[1]
print(costs)
y_pred = nn.predict(W_opt, b_opt, X_test)
print('real labels', y_test)
print('pred labels', y_pred)
if snake.alive == False:
continue
# pygame.draw.rect(screen, (255, 0, 0), (int(food[n].x) - block // 2, int(food[n].y) - block // 2, int(block), int(block)), 1)
# if keys[pygame.K_SPACE]:
# drawLine(snake, screen)
if keys[pygame.K_q]:
play = False
if keys[pygame.K_x]:
print('mutate_rate : ', rate)
inp = snake.processDistances(food, walls, screen)
outputs = predict(inp, snake.brain)
# a = inp.T
# a = a[0]
# print(a[0], a[3], a[6], a[9], a[12], a[15], a[18], a[21])
# if outputs == 0:
# snake.move(Vector2(0, -1))
# elif outputs == 1:
# snake.move(Vector2(1, 0))
# elif outputs == 2:
# snake.move(Vector2(0, 1))
def reply(self, received_data):
global GANN_instance, data_inputs, data_outputs, model
if (type(received_data) is dict):
if (("data" in received_data.keys())
and ("subject" in received_data.keys())):
subject = received_data["subject"]
print("Client's Message Subject is {subject}.".format(
subject=subject))
self.kivy_app.label.text = "Client's Message Subject is {subject}".format(
subject=subject)
print("Replying to the Client.")
self.kivy_app.label.text = "Replying to the Client"
if subject == "echo":
if model is None:
data = {"subject": "model", "data": GANN_instance}
else:
predictions = nn.predict(last_layer=model,
data_inputs=data_inputs)
error = numpy.sum(numpy.abs(predictions -
data_outputs))
# In case a client sent a model to the server despite that the model error is 0.0. In this case, no need to make changes in the model.
if error == 0:
data = {"subject": "done", "data": None}
else:
data = {"subject": "model", "data": GANN_instance}
try:
response = pickle.dumps(data)
except BaseException as e:
print("Error Encoding the Message: {msg}.\n".format(
msg=e))
self.kivy_app.label.text = "Error Encoding the Message"
elif subject == "model":
try:
GANN_instance = received_data["data"]
best_model_idx = received_data["best_solution_idx"]
best_model = GANN_instance.population_networks[
best_model_idx]
if model is None:
model = best_model
else:
predictions = nn.predict(last_layer=model,
data_inputs=data_inputs)
error = numpy.sum(
numpy.abs(predictions - data_outputs))
# In case a client sent a model to the server despite that the model error is 0.0. In this case, no need to make changes in the model.
if error == 0:
data = {"subject": "done", "data": None}
response = pickle.dumps(data)
return
self.model_averaging(model, best_model)
# print(best_model.trained_weights)
# print(model.trained_weights)
predictions = nn.predict(last_layer=model,
data_inputs=data_inputs)
print("Model Predictions: {predictions}".format(
predictions=predictions))
error = numpy.sum(numpy.abs(predictions -
data_outputs))
print("Prediction Error = {error}".format(error=error))
self.kivy_app.label.text = "Prediction Error = {error}".format(
error=error)
if error != 0:
data = {"subject": "model", "data": GANN_instance}
response = pickle.dumps(data)
else:
data = {"subject": "done", "data": None}
response = pickle.dumps(data)
except BaseException as e:
print("Error Decoding the Client's Data: {msg}.\n".
format(msg=e))
self.kivy_app.label.text = "Error Decoding the Client's Data"
else:
response = pickle.dumps("Response from the Server")
try:
self.connection.sendall(response)
except BaseException as e:
print("Error Sending Data to the Client: {msg}.\n".format(
msg=e))
self.kivy_app.label.text = "Error Sending Data to the Client: {msg}".format(
msg=e)
else:
print(
"The received dictionary from the client must have the 'subject' and 'data' keys available. The existing keys are {d_keys}."
.format(d_keys=received_data.keys()))
self.kivy_app.label.text = "Error Parsing Received Dictionary"
else:
print(
"A dictionary is expected to be received from the client but {d_type} received."
.format(d_type=type(received_data)))
self.kivy_app.label.text = "A dictionary is expected but {d_type} received.".format(
d_type=type(received_data))
model = 'lr'
model = 'nn'
# Neural Network
if model == 'nn':
(X, y) = get_numpy_data(train_data, model_features, my_output, with_constant=False, output_factor=1)
y = y.reshape(y.shape[0], 1) # make sure y has 2 dimensions
iterations=10
neurons = [ X.shape[1], 1 ]
weights = nn.neural_network_with_shapes(X, y, neurons, iterations=iterations, verbose=True, plot=False)
(test_X, test_y) = get_numpy_data(test_data, model_features, my_output)
test_predictions = nn.predict(test_X, weights)
train_r2 = regression.rsquared(nn.predict(X, weights), y)
test_r2 = regression.rsquared(test_predictions, test_y)
train_rss = regression.avg_prediction_error(nn.predict(X, weights), y)
test_rss = regression.avg_prediction_error(test_predictions, test_y)
print weights
print weights
print 'Train r2: {}, test r2: {}'.format(train_r2, test_r2)
print 'train rss: {}, test rss: {}'.format(train_rss, test_rss)
# Linear Regression
elif model == 'lr':
import MNB
import argparse
#import lsh
from sys import argv
import warnings
warnings.filterwarnings("ignore")
if __name__ == '__main__':
print('Welcome to the world of high and low dimensions!')
# The entire code should be able to run from this file!
test_data= argv[2]
test_label = argv[4]
data = argv[6]
if data == "dolphins":
run.predict_dolphins(test_data,test_label)
nn.predict("../data/dolphins/dolphins.csv","../data/dolphins/dolphins_label.csv",test_data,test_label)
bayes.predictNB("../data/dolphins/dolphins.csv","../data/dolphins/dolphins_label.csv",test_data,test_label)
#lsh.run("dolphins")
elif data == "twitter":
MNB.predict(test_data,test_label)
#run.predict_twitter(test_data,test_label)
#lsh.run("twitter")
nn.predict_twitter(test_data,test_label)
elif data == "pubmed":
bayes.predictNB("../data/pubmed/pubmed.csv","../data/pubmed/pubmed_label.csv",test_data,test_label)
#lsh.run("pubmed")
run.predict_pubmed(test_data,test_label)
nn.predict("../data/pubmed/pubmed.csv","../data/pubmed/pubmed_label.csv",test_data,test_label)
def main():
parser = argparse.ArgumentParser(description="Command Line Parser")
parser.add_argument("--train-data",
dest="train_data",
default='$',
help="Give path to the training data set.")
parser.add_argument("--test-data",
dest="test_data",
required=True,
help="Give path to the testing data set.")
parser.add_argument("--dataset",
dest="dataset",
required=True,
help="Give Name of data set.")
parser.add_argument("--configuration",
dest="configuration",
default='$',
help="Give structure of Neural Net.")
args = parser.parse_args()
train_data = args.train_data
test_data = args.test_data
dataset = args.dataset
configuration = args.configuration
if configuration != '$':
configuration = list(map(int, configuration.strip('[]').split(',')))
#Test mode
if train_data == '$':
test_filename = test_data
testdata = list()
if dataset == 'MNIST':
num_classes = 10
with open("../mem/weight_mnist.pkl", 'r') as saved:
w = pkl.load(saved)
with open("../mem/bias_mnist.pkl", 'r') as saved:
b = pkl.load(saved)
with open("../mem/configuration_mnist.pkl", 'r') as saved:
nn_structure = pkl.load(saved)
files = os.listdir(test_filename)
for f in files:
#print "Reading File", f
file_path = os.path.join(test_filename, f)
img = PIL.Image.open(file_path).convert("L")
matrix = np.array(img)
shape = matrix.shape
reshaped_matrix = np.reshape(matrix, [
shape[0] * shape[1],
])
testdata.append(reshaped_matrix)
e = float(files.index(f) + 1) / len(files)
sys.stdout.write('{}% File Reading Completed .....\r'.format(
int(e * 100)))
test_scaler = StandardScaler()
testdata = test_scaler.fit_transform(np.array(testdata))
n_components = 64
pca_test = PCA(n_components)
testdata = pca_test.fit_transform(testdata)
predicted_y = nn.predict(np.array(testdata), w, b,
len(nn_structure))
print "Prediction is: ", predicted_y
print len(nn_structure)
else:
num_classes = 2
with open("../mem/weight_catdog.pkl", 'r') as saved:
w = pkl.load(saved)
with open("../mem/bias_catdog.pkl", 'r') as saved:
b = pkl.load(saved)
with open("../mem/configuration_catdog.pkl", 'r') as saved:
nn_structure = pkl.load(saved)
files = os.listdir(test_filename)
for f in files:
#print "Reading File", f
file_path = os.path.join(test_filename, f)
img = PIL.Image.open(file_path).convert("L")
matrix = np.array(img)
shape = matrix.shape
reshaped_matrix = np.reshape(matrix, [
shape[0] * shape[1],
])
testdata.append(reshaped_matrix)
e = float(files.index(f) + 1) / len(files)
sys.stdout.write('{}% File Reading Completed .....\r'.format(
int(e * 100)))
test_scaler = StandardScaler()
testdata = test_scaler.fit_transform(np.array(testdata))
n_components = 64
pca_test = PCA(n_components)
testdata = pca_test.fit_transform(testdata)
predicted_y = nn.predict(np.array(testdata), w, b,
len(nn_structure))
predicted = ['cat' if x == 0 else 'dog' for x in predicted_y]
print "Prediction is:", predicted
else:
train_filename = train_data
test_filename = test_data
raw_data, raw_labels, num_classes = nn.read_data(train_filename)
#nn_structure = configuration
testdata = list()
if dataset == 'MNIST':
#configuration = [64]+configuration+[10]
#print configuration
nn_structure = [64] + configuration + [10]
scaler = StandardScaler()
scaled_data = scaler.fit_transform(raw_data)
print "Scaling Completed ....."
n_components = 64
pca = PCA(n_components)
data = pca.fit_transform(scaled_data)
print "Dimensionaly Reduced ....."
labels = np.array(list(map(int, raw_labels)))
onehot_labels = nn.one_hot(labels, num_classes)
w, b, cost_list = nn.train(nn_structure, data, onehot_labels)
with open("../mem/weight_mnist.pkl", 'w') as saver:
pkl.dump(w, saver)
with open("../mem/bias_mnist.pkl", 'w') as saver:
pkl.dump(b, saver)
with open("../mem/configuration_mnist.pkl", 'w') as saver:
pkl.dump(nn_structure, saver)
#num_classes = 10
files = os.listdir(test_filename)
for f in files:
#print "Reading File", f
file_path = os.path.join(test_filename, f)
img = PIL.Image.open(file_path).convert("L")
matrix = np.array(img)
shape = matrix.shape
reshaped_matrix = np.reshape(matrix, [
shape[0] * shape[1],
])
testdata.append(reshaped_matrix)
e = float(files.index(f) + 1) / len(files)
sys.stdout.write('{}% File Reading Completed .....\r'.format(
int(e * 100)))
test_scaler = StandardScaler()
testdata = test_scaler.fit_transform(np.array(testdata))
n_components = 64
pca_test = PCA(n_components)
testdata = pca_test.fit_transform(testdata)
predicted_y = nn.predict(np.array(testdata), w, b,
len(nn_structure))
print "Prediction is:", predicted_y
else:
nn_structure = [64] + configuration + [2]
scaler = StandardScaler()
scaled_data = scaler.fit_transform(raw_data)
print "Scaling Completed ....."
n_components = 64
pca = PCA(n_components)
data = pca.fit_transform(scaled_data)
print "Dimensionaly Reduced ....."
print "Cat is class 0 and Dog is class 1 ....."
labels = np.array([0 if x == 'cat' else 1 for x in raw_labels])
onehot_labels = nn.one_hot(labels, num_classes)
w, b, cost_list = nn.train(nn_structure, data, onehot_labels)
with open("../mem/weight_catdog.pkl", 'w') as saver:
pkl.dump(w, saver)
with open("../mem/bias_catdog.pkl", 'w') as saver:
pkl.dump(b, saver)
with open("../mem/configuration_catdog.pkl", 'w') as saver:
pkl.dump(nn_structure, saver)
files = os.listdir(test_filename)
for f in files:
#print "Reading File", f
file_path = os.path.join(test_filename, f)
img = PIL.Image.open(file_path).convert("L")
matrix = np.array(img)
shape = matrix.shape
reshaped_matrix = np.reshape(matrix, [
shape[0] * shape[1],
])
testdata.append(reshaped_matrix)
e = float(files.index(f) + 1) / len(files)
sys.stdout.write('{}% File Reading Completed .....\r'.format(
int(e * 100)))
test_scaler = StandardScaler()
testdata = test_scaler.fit_transform(np.array(testdata))
n_components = 64
pca_test = PCA(n_components)
testdata = pca_test.fit_transform(testdata)
predicted_y = nn.predict(np.array(testdata), w, b,
len(nn_structure))
predicted = ['cat' if x == 0 else 'dog' for x in predicted_y]
print "Prediction is:", predicted
with_constant=False,
output_factor=1)
y = y.reshape(y.shape[0], 1) # make sure y has 2 dimensions
iterations = 10
neurons = [X.shape[1], 1]
weights = nn.neural_network_with_shapes(X,
y,
neurons,
iterations=iterations,
verbose=True,
plot=False)
(test_X, test_y) = get_numpy_data(test_data, model_features, my_output)
test_predictions = nn.predict(test_X, weights)
train_r2 = regression.rsquared(nn.predict(X, weights), y)
test_r2 = regression.rsquared(test_predictions, test_y)
train_rss = regression.avg_prediction_error(nn.predict(X, weights), y)
test_rss = regression.avg_prediction_error(test_predictions, test_y)
print weights
print weights
print 'Train r2: {}, test r2: {}'.format(train_r2, test_r2)
print 'train rss: {}, test rss: {}'.format(train_rss, test_rss)
# Linear Regression
elif model == 'lr':
traindata[i]
for i in range(batchstartIndex, batchendIndex)
]
batchImageLabels = [
trainlabel[i]
for i in range(batchstartIndex, batchendIndex)
]
X = np.asarray(batchImagePixels, dtype=None, order=None)
y = []
for i in range(len(batchImageLabels)):
labellist = [0 for i in range(opdim)]
labellist[int(batchImageLabels[i])] = 1
y.append(labellist)
Y = np.asarray(y, dtype=None, order=None)
weights = nn.train(model, X, Y, weights, learning_rate)
batchstartIndex = batchendIndex
batchendIndex = batchstartIndex + batchsize
X_test = np.asarray(testdata, dtype=None, order=None)
accuracyOfMyCode, f1_score_macro, f1_score_micro = nn.predict(
X_test, testlabel, weights)
print("Test Accuracy ", accuracyOfMyCode)
f.write("Test Accuracy " + str(accuracyOfMyCode))
f.write("\n")
print("Test F1 Score(Macro) ", f1_score_macro)
f.write("Test F1 Score(Macro) " + str(f1_score_macro))
f.write("\n")
print("Test F1 Score(Micro) ", f1_score_micro)
f.write("Test F1 Score(Micro) " + str(f1_score_micro))
f.write("\n")
f.close()
def restest():
one = request.form.get('gender')
two = int(request.form.get('age'))
three = request.form.get('location')
four = request.form.get('dia')
five = request.form.get('head')
six = request.form.get('odour')
seven = request.form.get('sym')
eight = request.form.get('fever')
nine = request.form.get('dis')
ten = request.form.get('bp')
ele = request.form.get('trv')
j = [one, two, three, four, five, six, seven, eight, nine, ten]
states = [
"Tamil Nadu", "Maharashtra", "Delhi", "Gujarat", "Uttar Pradesh",
"Rajasthan", "Madhya Pradesh", "West Bengal", "Karnataka", "Bihar",
"Haryana", "Andhra Pradesh", "Jammu and Kashmir", "Telangana",
"Odisha", "Assam", "Punjab", "Kerala", "Jharkhand", "Uttarakhand",
"Chhattisgarh", "Tripura", "Himachal Pradesh", "Goa", "Manipur",
"Puducherry", "Ladakh", "Nagaland", "Mizoram", "Arunachal Pradesh",
"Meghalaya", "Andaman and Nicobar Islands", "Sikkim", "Lakshadweep",
"New York", "New Jersey", "California", "Illinois", "Massachusetts",
"Texas", "Pennsylvania", "Michigan", "Florida", "Maryland", "Georgia",
"Virginia", "Connecticut", "Louisiana", "North Carolina", "Ohio",
"Indiana", "Arizona", "Minnesota", "Colorado", "Tennessee",
"Washington", "Wisconsin", "lowa", "Alabama", "Mississippi",
"South Carolina", "Rhode island", "Nebraska", "Missouri", "Utah",
"Kansas", "Kentucky", "Delaware", "New Mexico", "Arkansas",
"Washington,D.c", "Nevada", "Oklahoma", "South Dakota",
"New Hampshire", "Oregon", "Puerto Rico", "Idaho", "North Dakota",
"Maine", "West Virginia", "Vermont", "Wyoming", "Hawai", "Montana",
"Alaska", "Guam", "U.S.Virgin islands", "Northern Mariana islands",
"American Samoa"
]
cases = [
"38716", "97648", "34687", "22032", "12088", "12076", "10241", "9768",
"6245", "5983", "5968", "5429", "4574", "4320", "3498", "3464", "2969",
"2327", "1599", "1411", "1398", "913", "470", "417", "366", "157",
"135", "128", "102", "61", "44", "38", "14", "0", "381000", "166000",
"133000", "131766", "104000", "83409", "77780", "64998", "66602",
"59136", "54242", "51721", "44092", "43492", "40791", "39266", "37623",
"31264", "29763", "28183", "24375", "22484", "21641", "2,015", "19614",
"18109", "15228", "14991", "14611", "13767", "12864", "10867", "10315",
"9773", "9367", "9549", "9016", "8935", "6676", "5095", "4876", "4576",
"3935", "2975", "2625", "2512", "2071", "1042", "903", "653", "525",
"487", "169", "73", "22", "0"
]
#cought
le = LabelEncoder()
prob = nn.predict("new_file.ogg", "trained_cnn.h5")
print(prob)
#video
a = bpmrpm()
x = 1.90
total = 0
if two > 50:
total = total + 2
if one == 'male':
total += 1.2
if ten == 'yes':
total += 2
if nine == 'yes':
total += 3
if four == 'yes':
total += 3
threee = states.index(three)
count = int(cases[threee])
if count < 1000:
total += 2
elif count < 3000:
total += 3
elif count < 10000:
total += 4
else:
total += 5
if ele == 'yes':
total += 3
if five == 'yes':
total += 1
if seven == 'yes':
total += 2
if six == 'no':
total += 2
if eight == 'yes':
total += 2
test = 0
total = total * x
if a[0] < 60 or a[0] > 100:
test += 100
if prob > 80:
test += 100
elif prob > 60:
test += 75
elif prob > 50:
test += 50
test = test / 4
total = total + test
print(test, total)
cur = mysql.connection.cursor()
cur.execute(
'INSERT INTO record(name,email,cough,bpm,resp,risk) VALUES (%s,%s,%s,%s,%s,%s);',
(
acc,
email1,
prob,
a[0],
a[1],
total,
))
mysql.connection.commit()
cur.close()
return render_template("testresult.html",
cou=prob,
res=a[1],
bp=a[0],
risk=total,
email=email1,
name=acc)
import numpy as np
import nn
Xtr = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]).T
Ytr = np.array([[0], [1], [1], [0]]).T
ld = [2, 1]
lrate = 10
num_iterations = 10000
#print(Ytr.shape[1])
parameters = nn.model(X=Xtr,
Y=Ytr,
nn_architecture=ld,
start_learning_rate=lrate,
num_iterations=num_iterations,
learning_decay=0.01)
#parameters = nn.initialize_parameters(ld)
#print(nn.forward_propagation(Xtr, parameters)[0])
nn.predict([[0], [0]], parameters)
nn.predict([[1], [0]], parameters)
nn.predict([[0], [1]], parameters)
nn.predict([[1], [1]], parameters)
#val_dataset = val_dataset.batch(batch_size)
model = nn.create_cnn(num_labels)
# train model
print("Training..")
#nn.trainloop(X_train, y_train, model)
nn.train(model, X_train, X_test, y_train, y_test, "trained_cnn.h5")
# compute test loss and accuracy
test_loss, test_accuracy = nn.compute(X_test, y_test, "trained_cnn.h5")
print("Test loss", test_loss)
print("Test accuracy", test_accuracy)
# predicting using trained model with any test file in dataset
nn.predict("dataset/001 - Dog bark/1-30226-A.ogg", le,
"trained_cnn.h5")
elif sys.argv[1] == "mlp":
#convert into numpy array
X, y, le = get_numpy_array(features_df)
# split into training and testing data
X_train, X_test, y_train, y_test = get_train_test(X, y)
num_labels = y.shape[1]
# create model architecture
model = nn.create_mlp(num_labels)
# train model
print("Training..")
X_test = np.expand_dims(X_test, axis=2)
# create model architecture
model = nn.create_cnn(num_labels)
# train model
print("Training..")
nn.train(model, X_train, X_test, y_train, y_test, "trained_cnn.h5")
# compute test loss and accuracy
test_loss, test_accuracy = nn.compute(X_test, y_test, "trained_cnn.h5")
print("Test loss", test_loss)
print("Test accuracy", test_accuracy)
# predicting using trained model with any test file in dataset
nn.predict("sample_wav/new_file_Chainsaw.wav", le, "trained_cnn.h5")
elif sys.argv[1] == "mlp":
#convert into numpy array
X, y, le = get_numpy_array(features_df)
# split into training and testing data
X_train, X_test, y_train, y_test = get_train_test(X, y)
num_labels = y.shape[1]
# create model architecture
model = nn.create_mlp(num_labels)
# train model
print("Training..")
def add_message():
content = request.json
res, prob = predict(content["image"])
return jsonify({"res": res.item(), "probabilities": prob.tolist()})
