def __init__(self):
self.root = tkinter.Tk()
self.root.geometry("500x420")
self.root.resizable(False, False)
self.root.title('Kinship Verification')
super().__init__()
net.train_network()
self.first_frame()
self.root.mainloop()
def main():
args, device = get_config()
# load in the inputs and outputs I built in matlab (before realising I really want to train this in pytorch)
lookup, inputs, words = setup_inputs(args)
attributes = setup_outputs(args, lookup)
# define train and test sets using our Dataset-inherited class
dataset = {
'index': list(range(args.n_unique)),
'input_item': inputs[0],
'input_context': inputs[1],
'label': attributes,
'words': words,
'domains': inputs[2]
}
trainset = net.CreateDataset(dataset)
testset = net.CreateDataset(
dataset
) # HRS note that, for now, train and test are same dataset. As in Rogers/McClelland
# train and test network
model, id = net.train_network(args, device, trainset, testset)
args.id = id
# analyse trained network hidden activations
analyse_network(args, trainset, testset, lookup)
def main():
args, device = get_config()
# load in the inputs and outputs I built in matlab (before realising I really want to train this in pytorch)
lookup, inputs = setup_inputs(args)
outputs = setup_outputs(args, lookup)
# define train and test sets using our Dataset-inherited class
dataset = {
'index': list(range(args.n_unique)),
'input_features': inputs,
'label': outputs
}
trainset = net.CreateDataset(dataset)
testset = net.CreateDataset(
dataset
) # HRS note that, for now, train and test are same dataset. As in Rogers/McClelland
# embed()
# train and test network
model, id, json_path = net.train_network(args, device, trainset, testset)
args.id = id
# analyse trained network hidden activations
analyse_network(args, trainset, testset, lookup)
# plot training record and save it
plot_learning_curve(args, json_path)
def initialize_network(self):
self.batch_size = 1
self.X = tf.placeholder(dtype=tf.float32,
shape=(self.batch_size, 224, 384, 8))
self.predict_flow5, self.predict_flow2 = network.train_network(self.X)
def initialize_network(self,lbl=False): self.batch_size = 1 self.X = tf.placeholder(dtype=tf.float32, shape=(self.batch_size, 160, 256, 8)) self.Y = tf.placeholder(dtype=tf.float32, shape=(self.batch_size, 160, 256, 2)) self.predict_flow2 = network.train_network(self.X) self.predict_flow2 = self.predict_flow2[0] if FLAGS.PARSING_MID == True: self.lossee = tf.sqrt(tf.reduce_mean(tf.square(tf.subtract(self.Y, self.predict_flow2)))) else: self.lossee = None
import network as Network
Network = Network.Network()
num_nodes = 100
input_probability = 0.3
reservoir_probability = 0.3
classifier = "log"
Network.T = sum(len_segments_train)
Network.n_min = 1
Network.K = 3
Network.N = num_nodes
Network.setup_network(train_data, num_nodes, input_probability, reservoir_probability, num_groups, num_segments_train)
Network.train_network(num_groups, classifier, num_segments_train, len_segments_train, labels_train, num_nodes)
Network.mean_test_matrix = np.zeros([Network.N, num_segments_test])
Network.test_network(test_data, num_segments_test, len_segments_test, num_nodes, num_groups, sum(len_segments_test))
if classifier == 'log':
print(f'Performance using {classifier} : {Network.regressor.score(Network.mean_test_matrix.T,labels_test.T)}')
prediction = Network.regressor.predict(Network.mean_test_matrix.T)
#%% Cell 10: Plot confusion matrix.
from sklearn.metrics import plot_confusion_matrix
fig, ax = plt.subplots(figsize = (12,9))
disp = plot_confusion_matrix(Network.regressor, Network.mean_test_matrix.T, labels_test.T, normalize='true', ax=ax)
disp.ax_.set_title("Confusion matrix")
import network
if __name__ == '__main__':
network.train_network('weights.h5')
[predict_flow_forward_ref1, predict_flow_backward_ref1]
}
X = tf.placeholder(dtype=tf.float32, shape=(1, 2, 224, 384, 8))
Y = tf.placeholder(dtype=tf.float32, shape=(1, 2, 224, 384, 3))
X_forward, Y_forward = X[:, 0, :, :, :], Y[:, 0, :, :, :]
X_backward, Y_backward = X[:, 1, :, :, :], Y[:, 1, :, :, :]
X_forward, Y_forward = further_resize_imgs_lbls(X_forward, Y_forward)
X_backward, Y_backward = further_resize_imgs_lbls(X_backward, Y_backward)
concatenated_FB_images = tf.concat([X_forward, X_backward], axis=0)
predict_flows = network.train_network(concatenated_FB_images)
flows_dict = get_predict_flow_forward_backward(predict_flows)
################ epe loss #######################
total_loss = tf.sqrt(
tf.reduce_mean(
tf.square(tf.subtract(Y_forward, flows_dict['predict_flow'][0]))))
# sess.run(test_iterator.initializer)
test_image_batch, test_label_batch, filename1, filename2 = test_iterator.get_next(
)[0]
summaies = []
########################
# Define the network parameters
########################
Network.T = d.training_data.shape[1] #Number of training time steps
Network.n_min = 2540 #Number time steps dismissed
Network.K = 128 #Input layer size
Network.N = num_nodes #Reservoir layer size
Network.u = d.training_data
Network.y_teach = d.training_results
Network.setup_network(d, num_nodes, input_probability, reservoir_probability,
d.data.shape[-1])
Network.train_network(d.data.shape[-1], classifier, d.num_columns,
d.num_trials_train, d.train_labels, Network.N)
Network.mean_test_matrix = np.zeros(
[Network.N, d.num_trials_test, d.data.shape[-1]])
Network.test_network(d.test_data,
d.num_columns,
d.num_trials_test,
Network.N,
d.data.shape[-1],
t_autonom=d.test_data.shape[1])
if classifier == 'lin':
print(
f'Performance for {test_name} using {classifier} : {d.accuracy_lin(Network.regressor.predict(Network.mean_test_matrix.T),d.test_labels)}'
)
default="vgg13",
type=str)
ap.add_argument('--hidden_units',
type=int,
dest="hidden_units",
action="store",
default=120)
pa = ap.parse_args()
where = pa.data_dir
path = pa.save_dir
lr = pa.learning_rate
structure = pa.arch
dropout = pa.dropout
hidden_layer1 = pa.hidden_units
power = pa.gpu
epochs = pa.epochs
trainloader, v_loader, testloader, train_data = network.load_data(where)
model, optimizer, criterion = network.nn_network(structure, dropout,
hidden_layer1, lr, power)
network.train_network(model, optimizer, criterion, trainloader, v_loader,
epochs, 20, power)
network.save_checkpoint(model, train_data, path, structure, hidden_layer1,
dropout, lr)
print("All Set and Done. The Model is trained")
# validate the data directory
if not os.path.isdir(args.data_dir):
print(args.data_dir, 'is not a valid data directory.')
exit()
# create data loader
data = data.create_data_loaders(args.data_dir)
# create the network
hidden_units = [4000, 1000, 200]
if len(args.hidden_units) > 0:
hidden_units = args.hidden_units[0]
model = network.create_network(args.arch, hidden_units)
# train the network
device = 'cuda' if args.gpu else 'cpu'
network.train_network(model,
data['train'],
data['valid'],
args.epochs,
device,
fake=args.fake)
# save the checkpoint
checkpoint_filename = 'checkpoint_' + args.arch + '_' + time.strftime(
"%Y-%m-%dT%H-%M-%S")
checkpoint_path = args.save_dir + '/' + checkpoint_filename
network.save_checkpoint(model, checkpoint_path)
print("Network written to", checkpoint_path)
warped_img = sess.run(warped_img)
warped_img = np.squeeze(warped_img)
# Image.fromarray(np.uint8(img2_orig)).show()
Image.fromarray(np.uint8(warped_img)).show()
print(loss)
def load_model_ckpt(sess, filename):
saver = tf.train.Saver()
saver.restore(sess, tf.train.latest_checkpoint(filename))
input_size = (384, 224)
sess = tf.InteractiveSession()
X = tf.placeholder(dtype=tf.float32, shape=(1, 224, 384, 8))
Y = tf.placeholder(dtype=tf.float32, shape=(1, 224, 384, 2))
predict_flows = network.train_network(X)
predict_flow2 = predict_flows[0]
# Y = further_resize_lbls(Y)
predict_flow2 = predict_flow2[:, :, :, 0:2]
loss_result = lhpl.endpoint_loss(Y, predict_flow2, 1)
# loss_result = tf.sqrt(tf.reduce_mean(tf.square(tf.subtract(Y, predict_flow2))))
load_model_ckpt(sess, FLAGS.CKPT_FOLDER)
perform_testing()
from keras.layers.normalization import BatchNormalization
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
if __name__ == "__main__":
time1 = time.time()
data_path = "dataset/train_sales_data.csv"
#################### ######################
mode = "train" # train test docker
print("#################work mode", mode, "#######################")
if mode == "train":
# 数据预处理
#(trainX, trainY) = proprocess.generate_train_seq(train_images_folder_path, train_track_folder_path)
load_data = proprocess.DataSets
trainX, trainY, validX, validY = load_data.load_passenger_car(
data_path)
model = network.build_network()
history = network.train_network(trainX,
trainY,
validX,
validY,
model,
epochs=1000)
network.plt_result(history, "output", "history.png")
elif mode == "test":
network.helloworld()
else:
print("mode error!")
time2 = time.time()
print('time use:' + str(time2 - time1) + 's')
#create model using --arch argument with vgg19 as default
model = utility.torch_model(args.arch)
for param in model.parameters():
param.requires_grad = False
#params are now frozen so that we do not backprop thru them again
#calculate input size into the network classifier
input_size = utility.get_input_size(model, args.arch)
model.classifier = network.Network(input_size,
args.output_size, [args.hidden_units],
drop_p=0.35)
#define the loss function and the optimization parameters
criterion = nn.NLLLoss(
) #want nllloss because we do the logsoftmax as our output activation
optimizer = optim.SGD(model.classifier.parameters(), lr=args.learning_rate)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=4, gamma=0.1)
#train model
network.train_network(model, trainloader, validloader, args.epochs, 32,
criterion, optimizer, scheduler, args.gpu)
#test model
test_accuracy, test_loss = network.check_accuracy_loss(model, testloader,
criterion, args.gpu)
print("\n ---\n Test Accuracy: {:.2f} %".format(test_accuracy * 100),
"Test Loss: {}".format(test_loss))
#save network to checkpoint
utility.save_checkpoint(model, train_data, optimizer, args.save_dir, args.arch)
file_ext = ".npy" # numpy bitmap arrays
classes = ["circle", "square", "hexagon"] # classes to train network on
# load data
x, y = ld.load(classes=classes,
data_dir=data_dir,
file_ext=file_ext,
samples=10,
reload_data=False)
x_train, y_train, x_test, y_test = ld.divide_into_sets(input=x,
response=y,
ratio=0.2)
# train network
yolo = net.build_network(y=y_train,
batch=6,
version=1,
input_size=(448, 448, 3),
output_size=392)
yolo = net.train_network(network=yolo,
x=x_train,
y=y_train,
batch=6,
iterations=5)
performance_metrics = net.test_network(network=yolo, x=x_test, y=y_test)
print(performance_metrics)
# test to see if the network can correctly generate the output for an example
res = yolo.predict(x_test[5].reshape(1, 448, 448, 3))
print(res)
