def get_act_map(x, y, batch_size, sess, model, w_plus):
"""
Computes the class activation maps
:param x: input images of size (#imgs, args.img_h, args.img_w, 1)
:param y: corresponding labels of size (#imgs, args.n_cls)
:param batch_size: batch size
:param sess: Tensorflow session
:param model: Full network model
:param w_plus: weights for the positive class (to be used in the loss function)
:return: array of class activation maps, (#imgs, 64, args.n_cls)
"""
model.is_train = False
x, y = randomize(x, y)
step_count = int(len(x) / batch_size)
all_features = np.zeros((0, 64, args.n_cls))
for step in range(step_count):
start = step * batch_size
end = (step + 1) * batch_size
x_batch, y_batch = get_next_batch(x, y, start, end)
feed_dict_batch = {
model.x: x_batch,
model.y: y_batch,
model.w_plus: w_plus
}
features = sess.run(model.get_cls_act_map, feed_dict=feed_dict_batch)
all_features = np.concatenate((all_features, features), axis=0)
return all_features
def train(in_file):
xvals, yvals = utils.load_data(in_file)
xvals, yvals = utils.randomize(xvals, yvals)
network = build_network()
model = tflearn.DNN(network)
model.fit(xvals, yvals, n_epoch=200, validation_set=0.2)
model.save('circle.tflearn')
def train(in_file):
xvals, yvals = utils.load_hot(in_file)
xvals, yvals = utils.randomize(xvals, yvals)
network = build_network()
model = tflearn.DNN(network)
model.fit(xvals, yvals, n_epoch=400, validation_set=0.2, show_metric=True)
model.save('complicated.tflearn')
def __init__(self, sizex, sizey, sizez, pointsLen, stokLen, stokR):
self.vertex = [sizex, sizey, sizez]
self.stoks = []
self.stoks = [
Stok(
randomize(sizex, sizey, sizez, self.is_normal_positioned_stok),
stokR) for _ in range(0, stokLen)
]
self.points = [
Point(randomize(sizex, sizey, sizex, self.is_normal_positioned))
for _ in range(0, pointsLen)
]
print(self.stoks)
print(self.points)
self.stok_pos = [sizex / 2, sizey / 2, sizez / 2]
self.R = stokR
def train(classifier_out_name, noInitialFeatures, noWantedFeatures, noEstimators):
posImages = utils.getFullImages(
"/home/mataevs/ptz/INRIAPerson/train/pos",
"/home/mataevs/ptz/positive")
posImages = utils.randomize(posImages)
negImages = utils.getFullImages(
"/home/mataevs/ptz/INRIAPerson/train/neg",
"/home/mataevs/ptz/negative")
negImages = utils.randomize(negImages)
print len(posImages)
print len(negImages)
c = Classifier()
print "Starting training"
c.train(posImages, negImages, initialFeatures=noInitialFeatures, wantedFeatures=noWantedFeatures, noEstimators=noEstimators)
print "Finished training"
c.saveClassifier(classifier_out_name)
def compute_features(x,
y,
batch_size,
sess,
model,
w_plus,
after_pooling=True):
"""
Feeds the data to the network and extracts the features from the last layers
:param x: input images of size (#imgs, args.img_h, args.img_w, 1)
:param y: corresponding labels of size (#imgs, args.n_cls)
:param batch_size: batch size
:param sess: Tensorflow session
:param model: Full network model
:param w_plus: weights for the positive class (to be used in the loss function)
:param after_pooling: boolean.
If True, computes the features after the final global average pooling layer (#imgs, 2048)
Else, computes the features before the pooling, (#imgs, 8, 8, 2048)
:return:
"""
model.is_train = False
x, y = randomize(x, y)
step_count = int(len(x) / batch_size)
if after_pooling:
all_features = np.zeros((0, 2048))
for step in range(step_count):
start = step * batch_size
end = (step + 1) * batch_size
x_batch, y_batch = get_next_batch(x, y, start, end)
feed_dict_batch = {
model.x: x_batch,
model.y: y_batch,
model.w_plus: w_plus
}
features = sess.run(model.get_features, feed_dict=feed_dict_batch)
all_features = np.concatenate((all_features, features), axis=0)
return all_features
else:
all_features = np.zeros((0, 8, 8, 2048))
for step in range(step_count):
start = step * batch_size
end = (step + 1) * batch_size
x_batch, y_batch = get_next_batch(x, y, start, end)
feed_dict_batch = {
model.x: x_batch,
model.y: y_batch,
model.w_plus: w_plus
}
features = sess.run(model.get_vol_features,
feed_dict=feed_dict_batch)
all_features = np.concatenate((all_features, features), axis=0)
return all_features
def train(classifier_out_name, noInitialFeatures, noWantedFeatures,
noEstimators):
posImages = utils.getFullImages("/home/mataevs/ptz/INRIAPerson/train/pos",
"/home/mataevs/ptz/positive")
posImages = utils.randomize(posImages)
negImages = utils.getFullImages("/home/mataevs/ptz/INRIAPerson/train/neg",
"/home/mataevs/ptz/negative")
negImages = utils.randomize(negImages)
print len(posImages)
print len(negImages)
c = Classifier()
print "Starting training"
c.train(posImages,
negImages,
initialFeatures=noInitialFeatures,
wantedFeatures=noWantedFeatures,
noEstimators=noEstimators)
print "Finished training"
c.saveClassifier(classifier_out_name)
def is_stok(self, point: Point):
if dist(point.x, point.y, point.z, *self.stok_pos) < self.R:
self.accelerator.append(point.counter)
self.pDrawer.append(point.counter)
if len(self.pDrawer) >= 5:
self.pDrawer.change_p(self.pDrawer.p + 0.1)
if self.pDrawer.p >= 0.89:
self.pDrawer.draw()
exit(0)
point.set_stok(True)
pos = randomize(*self.vertex, self.is_normal_positioned)
point.x = pos[0]
point.y = pos[1]
point.z = pos[2]
else:
point.set_stok(False)
import numpy as np
import matplotlib.pyplot as plt
from utils import randomize
# Hyper-parameters
EPOCHS = 500
NUM_HIDDEN_UNITS = 64
LEARNING_RATE = 0.001
BATCH_SIZE = 32
# Load the Boston Housing Prices dataset
(X_train, y_train), (X_test, y_test) = boston_housing.load_data()
num_features = X_train.shape[1]
# Shuffle the training set
X_train, y_train = randomize(X_train, y_train)
print("Train data size -> input: {}, output: {}".format(
X_train.shape, y_train.shape))
print("Test data size: -> input: {}, output: {}".format(
X_test.shape, y_test.shape))
# Normalize features
# Test data is *not* used when calculating the mean and std
mean = X_train.mean(axis=0)
std = X_train.std(axis=0)
X_train = (X_train - mean) / std
X_test = (X_test - mean) / std
# Build the model
model = Sequential()
tf.argmax(y, 1),
name='correct_pred')
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32),
name='accuracy')
# Creating the op for initializing all variables
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
global_step = 0
# Number of training iterations in each epoch
num_tr_iter = int(len(y_train) / batch_size)
for epoch in range(epochs):
print('Training epoch: {}'.format(epoch + 1))
x_train, y_train = randomize(x_train, y_train)
for iteration in range(num_tr_iter):
global_step += 1
start = iteration * batch_size
end = (iteration + 1) * batch_size
x_batch, y_batch = get_next_batch(x_train, y_train, start, end)
x_batch = x_batch.reshape((batch_size, timesteps, num_input))
# Run optimization op (backprop)
feed_dict_batch = {x: x_batch, y: y_batch}
sess.run(optimizer, feed_dict=feed_dict_batch)
if iteration % display_freq == 0:
# Calculate and display the batch loss and accuracy
loss_batch, acc_batch = sess.run([loss, accuracy],
feed_dict=feed_dict_batch)
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.svm import SVC
from utils import randomize, draw_learning_curves
data = pd.read_csv('data.csv')
X = np.array(data[['x1', 'x2']])
y = np.array(data['y'])
# Fix random seed caca
np.random.seed(55)
### Imports
# TODO: Uncomment one of the three classifiers, and hit "Test Run"
# to see the learning curve. Use these to answer the quiz below.
### Logistic Regression
estimator = LogisticRegression()
### Decision Tree
#estimator = GradientBoostingClassifier()
### Support Vector Machine
#estimator = SVC(kernel='rbf', gamma=1000)
X2, y2 = randomize(X, y)
draw_learning_curves(X, y, X2, y2, estimator, 10)
def train(network,
train_base,
test_base,
val_base,
batch_size=20,
num_epochs_without_change=100,
printing=True):
start_time = datetime.datetime.now()
best_loss = np.inf
Stop = False
h = 0
num_error_starvation = 0
lenBase = len(train_base[0])
maxLen = math.ceil(lenBase / float(batch_size))
labels = ["Por neuronio", "MSE", "MAPE"]
oldLabels = [[], [], []]
oldValLabels = [[], [], []]
oldTrainLabels = [[], [], []]
directory = path_graphs
if not os.path.exists(directory):
os.makedirs(directory)
while (not Stop):
epoch_start = datetime.datetime.now()
train_elems = train_base[0]
train_labels = train_base[1]
randomize(train_elems, train_labels)
loss = [0, 0]
for x in range(0, maxLen):
if (printing):
updateBar(x, maxLen, loss)
x_train = train_elems[batch_size * x:batch_size * (x + 1)]
x_test = train_labels[batch_size * x:batch_size * (x + 1)]
train_loss = network.train_on_batch(x_train, x_test)
for index in range(0, len(train_loss) - 1):
loss[index] += train_loss[index + 1]
if (printing):
print()
results_train = network.predict(train_elems)
tLoss = calculateErrorPerNeuron(results_train, train_labels)
for index in range(0, len(tLoss)):
oldTrainLabels[index].append(tLoss[index])
test_loss = test_network(test_base, network)
for i in range(0, len(test_loss)):
oldLabels[i].append(test_loss[i])
val_loss = test_network(val_base, network)
for i in range(0, len(val_loss)):
oldValLabels[i].append(val_loss[i])
if (printing):
print("Treino -> %d Epoch" % (h + 1))
newError = trysave(val_loss, network, h, best_loss, printing)
if (newError == best_loss):
num_error_starvation += 1
else:
best_loss = newError
num_error_starvation = 0
elapsed_time = datetime.datetime.now() - start_time
epoch_time = datetime.datetime.now() - epoch_start
if (printing):
print("\tnum no changes %d\n\ttotal time: %s %s" %
(num_error_starvation, epoch_time, elapsed_time))
for i in range(0, len(labels)):
plt.plot(oldTrainLabels[i], 'r', label='Treino')
plt.plot(oldLabels[i], 'b', label='Teste')
plt.plot(oldValLabels[i], 'g', label='Teste')
plt.ylabel(labels[i])
plt.savefig(os.path.join(path_graphs, labels[i] + '.png'))
plt.clf()
h += 1
Stop = num_error_starvation >= num_epochs_without_change
return best_loss, h
def train(model):
x_train, y_train, x_valid, y_valid = load_data(dataset=args.dataset,
mode='train')
print('Data set Loaded')
num_train_batch = int(y_train.shape[0] / args.batch_size)
if not os.path.exists(args.checkpoint_path + args.dataset):
os.makedirs(args.checkpoint_path + args.dataset)
with tf.Session() as sess:
if args.restore_training:
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state(args.checkpoint_path +
args.dataset)
saver.restore(sess, ckpt.model_checkpoint_path)
print('Model Restored')
start_epoch = int(str(ckpt.model_checkpoint_path).split('-')[-1])
fd_train, fd_val, best_loss_val = load_and_save_to(
start_epoch, num_train_batch)
else:
saver = tf.train.Saver(tf.global_variables())
tf.global_variables_initializer().run()
print('All variables initialized')
fd_train, fd_val = save_to()
start_epoch = 0
best_loss_val = np.infty
print('Start Training')
acc_batch_all = loss_batch_all = np.array([])
train_writer = tf.summary.FileWriter(args.log_dir + args.dataset,
sess.graph)
for epoch in range(start_epoch, args.epoch):
print(
'_____________________________________________________________________________'
)
print('Training Epoch] #{}'.format(epoch + 1))
x_train, y_train = randomize(x_train, y_train)
for step in range(num_train_batch):
start = step * args.batch_size
end = (step + 1) * args.batch_size
global_step = epoch * num_train_batch + step
x_batch, y_batch = get_next_batch(x_train, y_train, start, end)
feed_dict_batch = {
model.X: x_batch,
model.Y: y_batch,
model.mask_with_labels: True
}
if not (global_step % args.tr_disp_sum):
_, acc_batch, loss_batch, summary_tr = sess.run(
[
model.train_op, model.accuracy, model.total_loss,
model.summary_now
],
feed_dict=feed_dict_batch)
train_writer.add_summary(summary_tr, global_step)
acc_batch_all = np.append(acc_batch_all, acc_batch)
loss_batch_all = np.append(loss_batch_all, loss_batch)
mean_acc = np.mean(acc_batch_all)
mean_loss = np.mean(loss_batch_all)
summary_tr = tf.Summary(value=[
tf.Summary.Value(tag='Accuracy', simple_value=mean_acc)
])
train_writer.add_summary(summary_tr, global_step)
summary_tr = tf.Summary(value=[
tf.Summary.Value(tag='Loss/total_loss',
simple_value=mean_loss)
])
train_writer.add_summary(summary_tr, global_step)
fd_train.write(
str(global_step) + ',' + str(mean_acc) + ',' +
str(mean_loss) + "\n")
fd_train.flush()
print(
" Step #{0}, training loss: {1:.4f}, training accuracy: {2:.01%}"
.format(global_step, mean_loss, mean_acc))
acc_batch_all = loss_batch_all = np.array([])
else:
_, acc_batch, loss_batch = sess.run(
[model.train_op, model.accuracy, model.total_loss],
feed_dict=feed_dict_batch)
acc_batch_all = np.append(acc_batch_all, acc_batch)
loss_batch_all = np.append(loss_batch_all, loss_batch)
# Run validation after each epoch
acc_val, loss_val, _ = evaluate(sess, model, x_valid, y_valid)
fd_val.write(
str(epoch + 1) + ',' + str(acc_val) + ',' + str(loss_val) +
'\n')
fd_val.flush()
print(
'-----------------------------------------------------------------------------'
)
print(
"Epoch #{0}, Validation loss: {1:.4f}, Validation accuracy: {2:.01%}{3}"
.format(epoch + 1, loss_val, acc_val,
"(improved)" if loss_val < best_loss_val else ""))
# And save the model if it improved:
if loss_val < best_loss_val:
saver.save(sess,
args.checkpoint_path + args.dataset +
'/model.tfmodel',
global_step=epoch + 1)
best_loss_val = loss_val
fd_train.close()
fd_val.close()
print "Hierarchial clustering..."
hierarchy = machine_learning.recursiveCluster(X[dAll], size=500)
Y = machine_learning.flatten(hierarchy, min=40)
X = X[Y >= 0] # Eliminating outliers
Y = Y[Y >= 0]
y_values = np.unique(Y)
for i in range(0, len(y_values)):
Y[Y == y_values[i]] = i
print "Done."
print "Visualizing..."
machine_learning.pca(X[dAll], Y)
machine_learning.hist(X[["time"]], Y)
print "Done."
print "Shifting and randomizing..."
shift = 10
X, Y = utils.shiftLabels(X, Y, shift)
X, Y = utils.randomize(X, Y)
print 'Done.'
print "Choosing best parameters for classifier..."
clf, clf_acc, test_acc = machine_learning.best_classifier(X[All], Y)
print "Done."
print "Classifier accuracy: ", clf_acc
print "Test data accuracy: ", test_acc
print "Classifier model: ", clf
utils.save(clf, 'SVM.spkl')
print "Classifier saved."
def validation(x_valid, y_valid, val_batch_size, num_classes, sess, model, epoch, start_time, w_plus):
loss_batch_all = np.array([])
acc_batch_all = y_pred_all = logits_all = np.zeros((0, num_classes))
model.is_train = False
x_valid, y_valid = randomize(x_valid, y_valid)
step_count = int(len(x_valid) / val_batch_size)
for step in range(step_count):
start = step * val_batch_size
end = (step + 1) * val_batch_size
x_batch, y_batch = get_next_batch(x_valid, y_valid, start, end)
feed_dict_val = {model.x: x_batch, model.y: y_batch, model.w_plus: w_plus}
acc_valid, loss_valid, y_pred, logits = sess.run(
[model.accuracy, model.loss, model.prediction, model.get_logits],
feed_dict=feed_dict_val)
acc_batch_all = np.concatenate((acc_batch_all, acc_valid.reshape([1, num_classes])))
y_pred_all = np.concatenate((y_pred_all, y_pred.reshape([val_batch_size, num_classes])))
logits_all = np.concatenate((logits_all, logits.reshape([val_batch_size, num_classes])))
loss_batch_all = np.append(loss_batch_all, loss_valid)
mean_acc = np.mean(acc_batch_all, axis=0)
mean_loss = np.mean(loss_batch_all)
num_examples = np.sum(y_valid, axis=0)
num_preds = np.sum(y_pred_all, axis=0)
epoch_time = time.time() - start_time
print('******************************************************************************'
'********************************************************')
print('--------------------------------------------------------Validation, Epoch: {}'
' -----------------------------------------------------------'.format(epoch + 1))
print("Atlc\tCrdmg\tEffus\tInflt\tMass\tNodle\tPnum\tPntrx\tConsd"
"\tEdma\tEmpys\tFbrss\tTkng\tHrna\t|Avg.\t|Loss\t|Run Time")
for accu in mean_acc:
print '{:.01%}\t'.format(accu),
print '|{0:.01%}\t|{1:0.02}\t|{2}'.format(np.mean(mean_acc), mean_loss, epoch_time)
for exm in num_examples:
print '{:}\t'.format(exm),
print("Count of pathalogies")
for pred in num_preds:
print '{:}\t'.format(pred),
print("Count of recognized pathalogies")
P = R = np.zeros((1, args.n_cls))
for cond in range(args.n_cls):
y_true = y_valid[:, cond]
y_pred = y_pred_all[:, cond]
P[0, cond], R[0, cond] = precision_recall(y_true, y_pred)
P = np.reshape(P, args.n_cls)
R = np.reshape(R, args.n_cls)
for p in P:
print '{:0.03}\t'.format(p),
print("Precision")
for r in R:
print '{:0.03}\t'.format(r),
print("Recall")
plot_precision_recall_curve(y_valid[:logits_all.shape[0], :], logits_all, epoch)
write_acc_loss_csv(mean_acc, mean_loss, epoch)
write_precision_recall_csv(P, R, epoch)
return mean_acc, mean_loss
@app.route("/assets/images/<filename>")
def template_images(filename):
return send_from_directory("templates/images", filename)
@app.route("/random")
def randomcoffee():
choose_random = random.choice(cache_images)
name = choose_random.split(".")
return send_file(
f"{config.imagefolder}/{choose_random}",
mimetype=f"image/{name[-1] if name[-1] != 'jpg' else 'jpeg'}",
attachment_filename=choose_random)
@app.route("/random.json")
def randomcoffeeJSON():
domain = config.domain
if config.localhost:
domain = f"http://localhost:{config.port}/"
return jsonify({"file": domain + random.choice(cache_images)})
if __name__ == '__main__':
utils.randomize(config.imagefolder, config.suffix)
app.run(port=config.port, debug=config.debug, extra_files=extra_files)
import PySimpleGUI as sg
from utils import shark_icon, pilot_icon, images
from utils import update_images, randomize
from utils import make_shark, make_pilotfish, position_pilotfish
direction, position = randomize()
shark_list = [make_shark(direction)]
pilotfish_list = [make_pilotfish(shark_list[0])]
while shark_list:
for shark in shark_list:
event, values = shark.read(timeout=15)
if event == sg.TIMEOUT_KEY:
shark_x, shark_y = shark.CurrentLocation()
last_shark_x = shark.metadata['last_shark_x']
last_shark_y = shark.metadata['last_shark_y']
if (shark_x, shark_y) != (last_shark_x, last_shark_y):
if shark_x > (last_shark_x + 10):
direction = 'right'
elif shark_x < (last_shark_x - 10):
direction = 'left'
pilot = pilotfish_list[shark_list.index(shark)]
update_images(shark, pilot, direction)
position_pilotfish(pilot, direction)
shark.metadata['last_shark_x'] = shark_x
shark.metadata['last_shark_y'] = shark_y
elif event == 'Add another pair':
direction, position = randomize()
next_shark_str = 'shark' + str(len(shark_list))
next_pilot_str = 'pilot' + str(len(shark_list))
from datetime import datetime
import re
import sys
import logging
from configuration import wappy
from json.decoder import JSONDecodeError
from utils import randomize, Periodic
from bastard import Bastard
TCP_TIMEOUT = 20.0
module_logger = logging.getLogger(__name__)
networkRPC = {
"jsonrpc": "2.0",
"id": randomize("POST"),
"method": "POST",
"params": {
"data": {
"name": "WappyName",
"meta": {
"id": wappy.conf.backend.network_id,
"type": "network",
"version": "2.0"
},
},
"url": "/network",
"meta": {
"send_time": datetime.utcnow().isoformat() + "Z"
}
}
