def test_task2(root_path): ''' :param root_path: root path of test data, e.g. ./dataset/task2/test/0/ :return results: a dict of classification results results = {'audio_0000.pkl': 23, ‘audio_0001’: 11, ...} This means audio 'audio_0000.pkl' is matched to video 'video_0023' and ‘audio_0001’ is matched to 'video_0011'. ''' results = dict() os.chdir(os.path.split(os.path.realpath(__file__))[0]) audio_transforms = transforms.Compose([transforms.ToTensor()]) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') label_list = [9, 2, 3, 8, 7, 6, 5, 0, 4, 1] audio_model = ResNet.resnet18(num_classes=10) audio_model = audio_model.to(device) audio_model = torch.nn.DataParallel(audio_model) audio_model.load_state_dict(torch.load('./model/resnet18.pth')) audio_model.eval() audio_class_features = [] video_class_features = [] audio_motion_features = [] video_motion_features = [] Files = list(filter(lambda x: x.endswith(".pkl"), os.listdir(root_path))) Files.sort() for sample in Files: audio_path = root_path + '/' + sample data = np.load(audio_path, allow_pickle=True)['audio'] for i in range(4): S = librosa.resample(data[:, i], orig_sr=44100, target_sr=11000) S = np.abs(librosa.stft(S[5650:-5650], n_fft=510, hop_length=128)) S = np.log10(S + 0.0000001) S = np.clip(S, -5, 5) S -= np.min(S) S = 255 * (S / np.max(S)) if S.shape[-1] < 256: S = np.pad(S, ((0, 0), (int(np.ceil((256 - S.shape[-1]) / 2)), int(np.floor( (256 - S.shape[-1]) / 2))))) if S.shape[-1] > 256: S = S[:, int(np.ceil((S.shape[-1] - 256) / 2)):-int(np.floor((S.shape[-1] - 256) / 2))] if i == 0: feature = np.uint8(S)[:, :, np.newaxis] else: feature = np.concatenate( (np.uint8(S)[:, :, np.newaxis], feature), axis=-1) X = audio_transforms(feature) X = X.to(device) class_feature_t = torch.softmax(audio_model(X.unsqueeze(0)), dim=-1).squeeze(0) class_feature = np.zeros(10) for i in range(10): class_feature[label_list[i]] = class_feature_t[i] threshold = 0.35 label_list2 = [1, 2, 0, 3] label = [0] * 4 for i in range(4): if np.max(data[:, i]) > threshold: label[label_list2[i]] = 1 audio_class_features.append(class_feature) audio_motion_features.append(label) net = AlexNet() net.load_state_dict(torch.load('./model/alexnet.pt')) k = 0 while os.path.exists(root_path + '/video_' + str('%04d' % k)): video_class_feature, video_move_feature = get_video_feature( net, root_path + '/video_' + str('%04d' % k)) video_class_features.append(video_class_feature) video_motion_features.append(video_move_feature) k = k + 1 indices = pairing(audio_class_features, audio_motion_features, video_class_features, video_motion_features, -100) j = 0 for sample in Files: results[sample] = indices[j][1] j = j + 1 return results
def stupid_characterness_score(image, character): # send the image to the alexnet to compute the score for each class. # once you have it, use the character to find the score and return # use the evaluate alexnet thing here """ Configuration settings """ # get the _id of the character in the list #print character try: _id = string.ascii_lowercase.index(character) #print _id except: _id = range(10).index(int(character)) + 26 #print _id label = _id # evaluating params batch_size = 1 # Network params num_classes = 36 image = np.float32(image) - np.float32(VGG_MEAN) image = np.expand_dims(image, axis=0) # generate one hot variable #one_hot = tf.one_hot(label, num_classes) one_hot = np.zeros((num_classes)) one_hot[label] = 1 one_hot = np.expand_dims(one_hot, axis=0) one_hot = np.float32(one_hot) # placeholder for graph inputs x = tf.placeholder(tf.float32, [batch_size, 227, 227, 3]) y = tf.placeholder(tf.float32, [None, num_classes]) keep_prob = tf.placeholder(tf.float32) # Initialize model model = AlexNet(x, keep_prob, num_classes, []) # Link variable to model output score = tf.nn.softmax(model.fc8) #initialize store model saver = tf.train.Saver #''' with tf.Session() as sess: saver = tf.train.import_meta_graph( '/home/ray/finetune_alexnet_with_tensorflow/tmp/finetune_alexnet/chkpt/model_epoch20.ckpt.meta' ) saver.restore( sess, '/home/ray/finetune_alexnet_with_tensorflow/tmp/finetune_alexnet/chkpt/model_epoch20.ckpt' ) sess.run(tf.global_variables_initializer()) #graph = tf.get_default_graph() print("Model restored.") print('Initialized') #print image.shape, type(image), image.dtype #print one_hot.shape, type(one_hot), one_hot.dtype #print one_hot score_out = sess.run(score, feed_dict={ x: image, y: one_hot, keep_prob: 1. }) #''' tf.reset_default_graph() return score_out[0, label]
import time import tensorflow as tf import numpy as np import pandas as pd from scipy.misc import imread from alexnet import AlexNet sign_names = pd.read_csv('signnames.csv') nb_classes = 43 x = tf.placeholder(tf.float32, (None, 32, 32, 3)) resized = tf.image.resize_images(x, (227, 227)) # NOTE: By setting `feature_extract` to `True` we return # the second to last layer. fc7 = AlexNet(resized, feature_extract=True) # TODO: Define a new fully connected layer followed by a softmax activation to classify # the traffic signs. Assign the result of the softmax activation to `probs` below. # HINT: Look at the final layer definition in alexnet.py to get an idea of what this # should look like. shape = (fc7.get_shape().as_list()[-1], nb_classes ) # use this shape for the weight matrix # fc8, 43 fc8W = tf.Variable(tf.truncated_normal(shape, stddev=1e-2)) fc8b = tf.Variable(tf.zeros(nb_classes)) logits = tf.matmul(fc7, fc8W) + fc8b probs = tf.nn.softmax(logits) init = tf.global_variables_initializer() sess = tf.Session() sess.run(init)
passing them to AlexNet. """ import time import tensorflow as tf import numpy as np from scipy.misc import imread from caffe_classes import class_names from alexnet import AlexNet x = tf.placeholder(tf.float32, (None, 32, 32, 3)) # TODO: Resize the images so they can be fed into AlexNet. # HINT: Use `tf.image.resize_images` to resize the images resized = tf.image.resize_images (x, [227, 227]) assert resized is not Ellipsis, "resized needs to modify the placeholder image size to (227,227)" probs = AlexNet(resized) init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # Read Images im1 = imread("construction.jpg").astype(np.float32) im1 = im1 - np.mean(im1) im2 = imread("stop.jpg").astype(np.float32) im2 = im2 - np.mean(im2) # Run Inference t = time.time() output = sess.run(probs, feed_dict={x: [im1, im2]})
shape=(None, args.img_size, args.img_size, 3)) input_labels = tf.placeholder(dtype=tf.float32, shape=(None, None), name='train_labels') input_vectors = tf.placeholder(dtype=tf.float32, shape=(None, dim_vector), name='seen_word_vector') batch_input_labels = tf.placeholder(dtype=tf.float32, shape=(None, sementic_batch_size), name='batch_train_labels') semantic_embedding = tf.placeholder(dtype=tf.float32, shape=(nb_labels_seen, args.delen), name='semantic_embedding') model = AlexNet(input_image, dropout_rate, args.hash_bits, args.nb_labels_seen, skip_layer, args.weights_path) hash_layer = model.fc8 visual_fc1 = fc(hash_layer, args.hash_bits, args.delen, 'visual_fc1', relu=False) c_matrix1 = tf.matmul(visual_fc1, semantic_embedding, transpose_a=False, transpose_b=True) regularizer_loss = tf.reduce_mean( tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)) visual_rank_loss = ranking_loss(c_matrix1, input_labels) + regularizer_loss
wandb.init(project='homework1-cc7221', entity='p137') wandb.run.name = wandb.run.name + args.tag # model selection if args.model == 'resnet': model = ResNet50(img_channel=3, num_classes=19) # model = torch.hub.load('pytorch/vision:v0.9.0', 'resnet50', pretrained=False) elif args.model == 'resnet_torch': model = torch.hub.load('pytorch/vision:v0.9.0', 'resnet50', pretrained=False) elif args.model == 'resnext': model = resnext50(img_channel=3, num_classes=19) elif args.model == 'alexnet': model = AlexNet(num_classes=19) else: raise ValueError("This utility can't train that kind of model.") logging.info("Setting dataset") torch.cuda.empty_cache() train_dataset = TrainImageDataset( args.data, 224, 224, ) optimizer = torch.optim.Adam(model.parameters(), args.lr) # scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1) criterion = nn.CrossEntropyLoss() config = wandb.config
def get_activations(layer_num, base_model, mode='summation', folder='/home/z840/ALISURE/Data/VOC2012/ILSVRC2012_img_val'): """ 返回矩阵 activations[i][j] 是 summed/maxed 过得 image[i] at filter[j] 矩阵保存到 .csv 文件, 之后'find_strongest_images'会使用 :param layer_num: Specifies layer, whose filters' activations are returned :param base_model: Pass alexnet_model :param mode: either 'summation' or 'maximum' :param folder: Specify folder that contains validation images """ assert mode in ('summation', 'maximum'), "Mode has to be either 'summation' or 'maximum'" print('Working on layer {}\n'.format(layer_num)) filters = AlexNet.channels[layer_num] activation_matrix_filename = 'data/Strongest_Activation_Layer{}.csv'.format(layer_num) # 初始化激活矩阵, Filter and image numbers start with 1!! activations = np.full((AlexNet.val_set_size + 1, filters + 1), fill_value=0.0, dtype=np.float32) # Create Model up to layer_num model = AlexNet(layer_num, base_model) # For timing timesteps = [time.time()] save_interval = 10000 time_interval = 1000 for img_id in range(1, AlexNet.val_set_size + 1): # Convert image_id to file location id_str = str(img_id) while len(id_str) < 5: id_str = '0' + id_str img_name = folder + '/ILSVRC2012_val_000' + id_str + '.JPEG' # 获得对应层的特征图 activation_img = model.predict(img_name) # Make sure that dimensions 2 and 3 are spacial (Image is square) assert activation_img.shape[2] == activation_img.shape[3], "Index ordering incorrect" # 降维 if mode == 'summation': assert activation_img.shape[2] == activation_img.shape[3], "Index ordering incorrect" activation_img = activation_img.sum(3) activation_img = activation_img.sum(2) if mode == 'maximum': activation_img = np.nanmax(activation_img, axis=3) activation_img = np.nanmax(activation_img, axis=2) # Remove batch size dimension assert activation_img.shape[0] == 1 activation_img = activation_img.sum(0) # 使得激活图从1开始 activation_img = np.insert(activation_img, 0, 0.0) # activation_image现在存储filter(下标从1开始) # 每个filter通过maximum/summed 处理 # 拷贝激活值到图片 activations[img_id] = activation_img[:] # Print progress if img_id % time_interval == 0: timesteps.append(time.time()) last_interval = timesteps[-1] - timesteps[-2] total_execution = timesteps[-1] - timesteps[0] expected_remaining_time = total_execution / img_id * (AlexNet.val_set_size - img_id) print("Current image ID: {}".format(img_id)) print("The last 100 images took {0:.2f} s.".format(100 * last_interval / time_interval)) print("The average time per 100 images so far is {0:.2f} s".format(100 * total_execution / img_id)) print("Total execution time so far: {0:.2f} min".format(total_execution / 60)) print("The extrapolated remaining time is {0:.2f} min".format(expected_remaining_time / 60)) print('\n') # save if img_id % save_interval == 0: print("Results for first {} images saved\n".format(img_id)) try: os.remove(activation_matrix_filename) except OSError: pass np.savetxt(activation_matrix_filename, activations, delimiter=',') np.savetxt(activation_matrix_filename, activations, delimiter=',')
def main(): """ Configuration Part. """ # Path to the textfiles for the trainings and validation set train_file = './train.txt' val_file = './val.txt' # Learning params learning_rate = 0.01 num_epochs = 100 batch_size = 10 # Network params dropout_rate = 0.5 num_classes = 2 train_layers = ['fc8', 'fc7', 'fc6'] # How often we want to write the tf.summary data to disk display_step = 20 # Path for tf.summary.FileWriter and to store model checkpoints filewriter_path = "./tmp/tensorboard" checkpoint_path = "./tmp/checkpoints" """ Main Part of the finetuning Script. """ # Create parent path if it doesn't exist if not os.path.isdir(checkpoint_path): os.mkdir(checkpoint_path) # Place data loading and preprocessing on the cpu with tf.device('/cpu:0'): tr_data = ImageDataGenerator(train_file, mode='training', batch_size=batch_size, num_classes=num_classes, shuffle=True) val_data = ImageDataGenerator(val_file, mode='inference', batch_size=batch_size, num_classes=num_classes, shuffle=False) # create an reinitializable iterator given the dataset structure iterator = Iterator.from_structure(tr_data.data.output_types, tr_data.data.output_shapes) next_batch = iterator.get_next() # Ops for initializing the two different iterators training_init_op = iterator.make_initializer(tr_data.data) validation_init_op = iterator.make_initializer(val_data.data) # TF placeholder for graph input and output x = tf.placeholder(tf.float32, [None, 227, 227, 3]) y = tf.placeholder(tf.float32, [None, num_classes]) keep_prob = tf.placeholder(tf.float32) # Initialize model model = AlexNet(x, keep_prob, num_classes, train_layers) # Link variable to model output score = model.fc8 pred = tf.nn.softmax(score) # List of trainable variables of the layers we want to train var_list = [ v for v in tf.trainable_variables() if v.name.split('/')[0] in train_layers ] # Op for calculating the loss with tf.name_scope("cross_ent"): loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=score, labels=y)) # Train op with tf.name_scope("train"): # Get gradients of all trainable variables gradients = tf.gradients(loss, var_list) gradients = list(zip(gradients, var_list)) # Create optimizer and apply gradient descent to the trainable variables # optimizer = tf.train.GradientDescentOptimizer(learning_rate) optimizer = tf.train.AdamOptimizer(learning_rate) train_op = optimizer.apply_gradients(grads_and_vars=gradients) # Add gradients to summary for gradient, var in gradients: tf.summary.histogram(var.name + '/gradient', gradient) # Add the variables we train to the summary for var in var_list: tf.summary.histogram(var.name, var) # Add the loss to summary tf.summary.scalar('cross_entropy', loss) # Evaluation op: Accuracy of the model with tf.name_scope("accuracy"): correct_pred = tf.equal(tf.argmax(score, 1), tf.argmax(y, 1)) accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) # Add the accuracy to the summary tf.summary.scalar('accuracy', accuracy) # Merge all summaries together merged_summary = tf.summary.merge_all() # Initialize the FileWriter writer = tf.summary.FileWriter(filewriter_path) # Initialize an saver for store model checkpoints saver = tf.train.Saver() # Get the number of training/validation steps per epoch train_batches_per_epoch = int(np.floor(tr_data.data_size / batch_size)) val_batches_per_epoch = int(np.floor(val_data.data_size / batch_size)) # Start Tensorflow session with tf.Session() as sess: print("# isTrain : ", args.istrain) if not args.istrain: ckpt = tf.train.get_checkpoint_state(checkpoint_path) if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path): print("Reading model parameters from %s" % ckpt.model_checkpoint_path) saver.restore(sess, ckpt.model_checkpoint_path) else: print("checkpoint path isn't correct") return file = tf.read_file(args.input_path) decoded_img = tf.image.decode_jpeg(file, channels=3) resized_img = tf.image.resize_images(decoded_img, [227, 227]) resized_img = tf.reshape(resized_img, [1, 227, 227, 3]) print("# decoded img : ", decoded_img.eval().shape) pred_ = sess.run(pred, feed_dict={ x: resized_img.eval(), y: [[1, 0]], keep_prob: np.array(1.0) }) print("P(man|data) : ", pred_[0][0]) print("P(woman|data) : ", pred_[0][1]) img = decoded_img.eval() plt.imshow(img) plt.show() if args.visualize: w1, w2, w3, w4, w5 = sess.run(model.weight, feed_dict={ x: resized_img.eval(), y: [[1, 0]], keep_prob: np.array(1.0) }) print("W1 : ", w1.shape) visualize(w1[:, :, 0, :25]) print("W2 : ", w2.shape) visualize(w2[:, :, 0, :25]) print("W3 : ", w3.shape) visualize(w3[:, :, 0, :25]) print("W4 : ", w4.shape) visualize(w4[:, :, 0, :25]) print("W5 : ", w5.shape) visualize(w5[:, :, 0, :25]) f1, f2, f3, f4, f5 = sess.run(model.fm, { x: resized_img.eval(), y: [[1, 0]], keep_prob: np.array(1.0) }) print("F1 : ", f1.shape) visualize(f1[0][:, :, :25]) print("F2 : ", f2.shape) visualize(f2[0][:, :, :25]) print("F3 : ", f3.shape) visualize(f3[0][:, :, :25]) print("F4 : ", f4.shape) visualize(f4[0][:, :, :25]) print("F5 : ", f5.shape) visualize(f5[0][:, :, :25]) return else: # Initialize all variables sess.run(tf.global_variables_initializer()) # Add the model graph to TensorBoard writer.add_graph(sess.graph) # Load the pretrained weights into the non-trainable layer model.load_initial_weights(sess) print("{} Start training...".format(datetime.now())) print("{} Open Tensorboard at --logdir {}".format( datetime.now(), filewriter_path)) # Loop over number of epochs for epoch in range(num_epochs): print("{} Epoch number: {}".format(datetime.now(), epoch + 1)) # Initialize iterator with the training dataset sess.run(training_init_op) train_acc = 0. train_count = 0. for step in range(train_batches_per_epoch): # get next batch of data img_batch, label_batch = sess.run(next_batch) # And run the training op acc, _ = sess.run([accuracy, train_op], feed_dict={ x: img_batch, y: label_batch, keep_prob: dropout_rate }) train_acc += acc train_count += 1 # Generate summary with the current batch of data and write to file # if step % display_step == 0: # s = sess.run(merged_summary, feed_dict={x: img_batch, # y: label_batch, # keep_prob: 1.}) # # writer.add_summary(s, epoch*train_batches_per_epoch + step) train_acc /= train_count print("{} Train Accuracy = {:.4f}".format(datetime.now(), train_acc)) # Validate the model on the entire validation set print("{} Start validation".format(datetime.now())) sess.run(validation_init_op) test_acc = 0. test_count = 0 for ind in range(val_batches_per_epoch): img_batch, label_batch = sess.run(next_batch) acc = sess.run(accuracy, feed_dict={ x: img_batch, y: label_batch, keep_prob: 1. }) test_acc += acc test_count += 1 if epoch is 2 and ind is 0: fm = sess.run(model.fm, feed_dict={ x: img_batch, y: label_batch, keep_prob: 1. }) weight = sess.run(model.weight, feed_dict={ x: img_batch, y: label_batch, keep_prob: 1. }) # print("fm0 : ", np.array(fm[0]).shape) # print("fm1 : ", np.array(fm[1]).shape) # print("fm2 : ", np.array(fm[2]).shape) # print("fm3 : ", np.array(fm[3]).shape) # print("fm4 : ", np.array(fm[4]).shape) # # print("weight0 : ", np.array(weight[0]).shape) # print("weight1 : ", np.array(weight[1]).shape) # print("weight2 : ", np.array(weight[2]).shape) # print("weight3 : ", np.array(weight[3]).shape) # print("weight4 : ", np.array(weight[4]).shape) test_acc /= test_count print("{} Validation Accuracy = {:.4f}".format( datetime.now(), test_acc)) print("{} Saving checkpoint of model...".format(datetime.now())) # save checkpoint of the model checkpoint_name = os.path.join( checkpoint_path, 'model_epoch' + str(epoch + 1) + '.ckpt') save_path = saver.save(sess, checkpoint_name) print("{} Model checkpoint saved at {}".format( datetime.now(), checkpoint_name))
def get_activations(layer_num, base_model, mode='summation', folder='ILSVRC2012_img_val'): """ Returns a matrix s.t. activations[i][j] is the summed/maxed activation of image[i] at filter[j] for a given layer This matrix of activations is saved as a .csv file and will later be used by 'find_strongest_images' :param layer_num: Specifies layer, whose filters' activations are returned :param base_model: Pass alexnet_model :param mode: either 'summation' or 'maximum' :param folder: Specify folder that contains validation images """ assert mode in ('summation', 'maximum'), "Mode has to be either 'summation' or 'maximum'" print('Working on layer {}\n'.format(layer_num)) filters = AlexNet.channels[layer_num] activation_matrix_filename = 'Data/Strongest_Activation_Layer{}.csv'.format(layer_num) # Init array to save activations, Filter and image numbers start with 1!! activations = np.full((AlexNet.val_set_size + 1, filters + 1), fill_value=0.0, dtype=np.float32) # Create Model up to layer_num model = AlexNet(layer_num, base_model) # For timing timesteps = [time.time()] save_interval = 10000 time_interval = 1000 for img_id in range(1, AlexNet.val_set_size + 1): # Convert image_id to file location id_str = str(img_id) while len(id_str) < 5: id_str = '0' + id_str img_name = folder + '/ILSVRC2012_val_000' + id_str + '.JPEG' # Get activations for shortened model activation_img = model.predict(img_name) # Make sure that dimensions 2 and 3 are spacial (Image is square) assert activation_img.shape[2] == activation_img.shape[3], "Index ordering incorrect" if mode == 'summing': # Sum over spacial dimension to get activation for given filter and given image assert activation_img.shape[2] == activation_img.shape[3], "Index ordering incorrect" activation_img = activation_img.sum(3) activation_img = activation_img.sum(2) if mode == 'maximum': # Find maximum activation for each filter for a given image activation_img = np.nanmax(activation_img, axis=3) activation_img = np.nanmax(activation_img, axis=2) # Remove batch size dimension assert activation_img.shape[0] == 1 activation_img = activation_img.sum(0) # Make activations 1-based indexing activation_img = np.insert(activation_img, 0, 0.0) # activation_image is now a vector of length equal to number of filters (plus one for one-based indexing) # each entry corresponds to the maximum/summed activation of each filter for a given image form validation set # Copy activation results for image to matrix activations[img_id] = activation_img[:] # Print progress if img_id % time_interval == 0: timesteps.append(time.time()) last_interval = timesteps[-1] - timesteps[-2] total_execution = timesteps[-1] - timesteps[0] expected_remaining_time = total_execution / img_id * (AlexNet.val_set_size - img_id) print("Current image ID: {}".format(img_id)) print("The last 100 images took {0:.2f} s.".format(100 * last_interval / time_interval)) print("The average time per 100 images so far is {0:.2f} s".format(100 * total_execution / img_id)) print("Total execution time so far: {0:.2f} min".format(total_execution / 60)) print("The extrapolated remaining time is {0:.2f} min".format(expected_remaining_time / 60)) print('\n') # Update output file if img_id % save_interval == 0: print("Results for first {} images saved\n".format(img_id)) try: os.remove(activation_matrix_filename) except OSError: pass np.savetxt(activation_matrix_filename, activations, delimiter=',') np.savetxt(activation_matrix_filename, activations, delimiter=',')
if args.enable_lat: real_model_path = args.model_path + "lat_param.pkl" print('loading the LAT model') else: real_model_path = args.model_path + "naive_param.pkl" print('loading the naive model') ''' if args.test_flag: args.enable_lat = False ''' # switch models if args.model == 'alexnet': cnn = AlexNet(enable_lat=args.enable_lat, epsilon=args.epsilon, pro_num=args.pro_num, batch_size=args.batchsize, num_classes=200, if_dropout=args.dropout) elif args.model == 'resnet': cnn = ResNet18(enable_lat=args.enable_lat, epsilon=args.epsilon, pro_num=args.pro_num, batch_size=args.batchsize, num_classes=200, if_dropout=args.dropout) #cnn.apply(conv_init) elif args.model == 'alexnetBN': cnn = AlexNetBN(enable_lat=args.enable_lat, epsilon=args.epsilon, pro_num=args.pro_num, batch_size=args.batchsize,
# y_diff[layer].append(box_borders[-1][3] - box_borders[-1][2]) projections.append(projection) superposed_projections = np.maximum.reduce(projections) # superposed_projections = sum(projections) assert superposed_projections.shape == projections[0].shape DeconvOutput(superposed_projections).save_as( save_to_folder, '{}_activations.JPEG'.format(img_id)) original_image = preprocess_image_batch(path) original_image = draw_bounding_box(original_image, box_borders) DeconvOutput(original_image).save_as(save_to_folder, '{}.JPEG'.format(img_id)) if __name__ == '__main__': deconv_base_model = Deconvolution(AlexNet().model) # for _ in range(15): # #project_top_layer_filters(deconv_base_model=deconv_base_model) # #project_multiple_layer_filters(deconv_base_model=deconv_base_model) # project_multiple_layer_filters(deconv_base_model=deconv_base_model) for img_id in (14913, 31634, 48518, 37498, 2254): project_multiple_layer_filters(img_id=img_id, deconv_base_model=deconv_base_model) for img_id in (31977, ): project_top_layer_filters(img_id=img_id, deconv_base_model=deconv_base_model) pass # visualize_top_images(layer=5, f=4, constrast=13)
import torch from torch.nn.functional import softmax from alexnet import AlexNet from utils import cifar10_loader, device, cifar10_classes torch.random.manual_seed(128) batch_size = 1 testloader = cifar10_loader(train=False, batch_size=batch_size) net = AlexNet() net.load_state_dict(torch.load("model/model.h5")) net.eval() correct = 0 total = 0 def run(): global correct, total with torch.no_grad(): for data in testloader: images, labels = data inputs, labels = images.to(device), labels.to(device) outputs = net(inputs) _, predicted = torch.topk(outputs.data, 5) #print(predicted) indexes = predicted.numpy()[0].tolist() #print(indexes) #print(softmax(outputs).numpy()[0][indexes]) #print([cifar10_classes[i] for i in indexes])
# Pick the class with the highest confidence for each image class_indices = np.argmax(probs, axis=1) # Display the results print('\n{:20} {:30} {}'.format('Image', 'Classified As', 'Confidence')) print('-' * 70) for img_idx, image_path in enumerate(image_paths): img_name = osp.basename(image_path) class_name = class_labels[class_indices[img_idx]] confidence = round(probs[img_idx, class_indices[img_idx]] * 100, 2) print('{:20} {:30} {} %'.format(img_name, class_name, confidence)) spec = DataSpec() input_node = tf.placeholder(tf.float32, [None, 227, 227, 3]) net = AlexNet({"data": input_node}) # image = (imread(r"tank_1.jpg")[:, :, :3]).astype(np.float32) # image -= np.mean(image) # image = imresize(image, (227, 227, 3)) image_paths = [r"tank_1.jpg"] image_producer = dataset.ImageProducer(image_paths=image_paths, data_spec=spec) with tf.Session() as sess: # Start the image processing workers coordinator = tf.train.Coordinator() threads = image_producer.start(session=sess, coordinator=coordinator) # Load the converted parameters print('Loading the model') net.load(r"../AlexNet.npy", sess, encoding="latin1")
torch.backends.cudnn.benchmark = True SAVE_PATH = './cp_large.bin' logger = Logger('./largecnnlogs') lossfunction = nn.MSELoss() dataset = Rand_num() sampler = RandomSampler(dataset) loader = DataLoader(dataset, batch_size=20, sampler=sampler, shuffle=False, num_workers=1, drop_last=True) net = AlexNet(3) #net.load_state_dict(torch.load(SAVE_PATH)) net.cuda() optimizer = optim.Adam(net.parameters(), lr=0.001) for epoch in range(10000): for i, data in enumerate(loader, 0): net.zero_grad() video, labels = data video = video.view(-1, 3, 227, 227) labels = labels.view(-1, 3) labels = torch.squeeze(Variable(labels.float().cuda())) video = torch.squeeze(Variable((video.float() / 256).cuda())) net.train() outputs = net.forward(video) loss = lossfunction(outputs, labels) loss.backward()
imgs2 = [] for i in img1: imgs1.append(cv2.imread(i)) for i in img2: imgs2.append(cv2.imread(i)) #print(imgs1[0]) from alexnet import AlexNet from caffe_classes import class_names #placeholder for input and dropout rate x = tf.placeholder(tf.float32, [1, 227, 227, 3]) keep_prob = tf.placeholder(tf.float32) #create model with default config ( == no skip_layer and 1000 units in the last layer) model = AlexNet(x, keep_prob, 5749, ['fc8']) #define activation of last layer as score score = model.fc7 #f7=model.fc7; saver=tf.train.Saver(); #create op to calculate softmax softmax = score # tf.nn.softmax(score) res=[] with tf.Session() as sess: # Initialize all variables #sess.run(tf.global_variables_initializer())
def main(_): #convert jpg image(s) into iamge representations using alexnet: filenames = [ os.path.join(image_dir, f) for f in [ 'overly-attached-girlfriend.jpg', 'high-expectations-asian-father.jpg', 'foul-bachelor-frog.jpg', 'stoner-stanley.jpg', 'y-u-no.jpg', 'willy-wonka.jpg', 'futurama-fry.jpg', 'success-kid.jpg', 'one-does-not-simply.jpg', 'bad-luck-brian.jpg', 'first-world-problems.jpg', 'philosoraptor.jpg', 'what-if-i-told-you.jpg', 'TutorPP.jpg' ] ] print(filenames) tf.logging.info("Running caption generation on %d files matching %s", len(filenames), FLAGS.input_files) #mean of imagenet dataset in BGR imagenet_mean = np.array([104., 117., 124.], dtype=np.float32) #placeholder for input and dropout rate x_Alex = tf.placeholder(tf.float32, [1, 227, 227, 3]) keep_prob_Alex = tf.placeholder(tf.float32) #create model with default config ( == no skip_layer and 1000 units in the last layer) modelAlex = AlexNet(x_Alex, keep_prob_Alex, 1000, [], ['fc7', 'fc8'], 512) #maybe need to put fc8 in skip_layers #define activation of last layer as score score = modelAlex.fc6 meme_embeddings = [] with tf.Session() as sess: # Initialize all variables sess.run(tf.global_variables_initializer()) # Load the pretrained weights into the model modelAlex.load_initial_weights(sess) for i, meme in enumerate(filenames): img = Image.open(meme) try: img.thumbnail((227, 227), Image.ANTIALIAS) #img = img.resize((227,227)) #use img.thumbnail for square images, img.resize for non square assert np.shape(img) == (227, 227, 3) except AssertionError: img = img.resize((227, 227)) print('sizing error') # Subtract the ImageNet mean img = img - imagenet_mean #should probably change this # Reshape as needed to feed into model img = img.reshape((1, 227, 227, 3)) meme_vector = sess.run(score, feed_dict={ x_Alex: img, keep_prob_Alex: 1 }) #[1,4096] meme_vector = np.reshape(meme_vector, [4096]) assert np.shape(meme_vector) == (4096, ) #now have np embeddings to feed for inference meme_embeddings.append(meme_vector) with open('Captions.txt', 'r') as f: data_captions = f.readlines() data_captions = [s.lower() for s in data_captions] # Build the inference graph. g = tf.Graph() with g.as_default(): model = inference_wrapper.InferenceWrapper() restore_fn = model.build_graph_from_config(configuration.ModelConfig(), FLAGS.checkpoint_path) g.finalize() # Create the vocabulary. vocab = vocabulary.Vocabulary(FLAGS.vocab_file) #filenames = [] #for file_pattern in FLAGS.input_files.split(","): #filenames.extend(tf.gfile.Glob(file_pattern)) #tf.logging.info("Running caption generation on %d files matching %s", #len(filenames), FLAGS.input_files) with tf.Session(graph=g) as sess: # Load the model from checkpoint. restore_fn(sess) # Prepare the caption generator. Here we are implicitly using the default # beam search parameters. See caption_generator.py for a description of the # available beam search parameters. generator = caption_generator.CaptionGenerator(model, vocab) num_in_data_total = 0 num_captions = 0 for i, meme in enumerate(meme_embeddings): #with tf.gfile.GFile(filename, "rb") as f: #image = f.read() captions = generator.beam_search(sess, meme) print("Captions for image %s:" % os.path.basename(filenames[i])) num_in_data = 0 for i, caption in enumerate(captions): # Ignore begin and end words. sentence = [ vocab.id_to_word(w) for w in caption.sentence[1:-1] ] sentence = " ".join(sentence) in_data = 0 if b_any(sentence in capt for capt in data_captions): in_data = 1 num_in_data += 1 num_in_data_total += 1 num_captions += 1 else: num_captions += 1 print(" %d) %s (p=%f) [in data = %d]" % (i, sentence, math.exp(caption.logprob), in_data)) print("number of captions in data = %d" % (num_in_data)) print("(total number of captions in data = %d) percent in data = %f" % (num_in_data_total, (num_in_data_total / num_captions)))
def main(): """build, train, and test an implementation of the alexnet CNN model in keras. This model is trained and tested on the CIFAR-100 dataset """ # parse arguments args = parse_arguments() save_dir = os.path.join(os.getcwd(), args['d']) if not os.path.isdir(save_dir): os.makedirs(save_dir) model_path = os.path.join(save_dir, args['n']) epochs = int(args['e']) predict_flag = args['p'] show_flag = args['f'] cifar10_label = [ 'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck' ] # build and train the model if predict_flag == True: if show_flag == True: print(filter) alexnet = AlexNet(10) model = alexnet.build_model(class_count=10) model.load_weights(model_path) print("load complete") (x_train, y_train), (x_test, y_test) = load_dataset() batch_generator = generator_ramdom_one(10, 112, 112, x_test, y_test) test_x, test_y = next(batch_generator) layer = "conv2d_2" show_filter(model, test_x, layer) else: alexnet = AlexNet(10) model = alexnet.build_model(class_count=10) model.load_weights(model_path) print("load complete") (x_train, y_train), (x_test, y_test) = load_dataset() batch_generator = generator_ramdom_one(10, 112, 112, x_test, y_test) test_x, test_y = next(batch_generator) print(cifar10_label[np.argmax(test_y)]) result = model.predict(test_x) print(cifar10_label[np.argmax(result)]) test_img_x = test_x[0, ::-1].copy() plt.imshow(test_img_x / 255, interpolation='nearest') plt.title(cifar10_label[np.argmax(test_y)] + "/" + cifar10_label[np.argmax(result)]) plt.show() else: alexnet = AlexNet(10) model = alexnet.build_model(class_count=10) print(model.summary()) train_model(model, class_count=10, epochs=epochs) # test the model evaluate(model, class_count=10) # save the trained model model.save(model_path) print("Alexnet model saved to: %s" % model_path)
os.path.join(image_dir, f) for f in os.listdir(image_dir) if f.endswith('.JPEG') ] # load all images imgs = [] for f in img_files: imgs.append(cv2.imread(f)) # placeholder for input and dropout rate x = tf.placeholder(tf.float32, [None, 227, 227, 3]) keep_prob = tf.placeholder(tf.float32) # create model with default config ( == no skip_layer and 1000 units in the last layer) model = AlexNet(x, keep_prob, 1000, [], weights_path="./weights/bvlc_alexnet.npy") # define activation of last layer as score score = model.fc8 # create op to calculate softmax softmax = tf.nn.softmax(score) with tf.Session() as sess: # Initialize all variables sess.run(tf.global_variables_initializer()) # Load the pretrained weights into the model model.load_initial_weights(sess)
# Find maximum activation for each filter for a given image activation_img = np.nanmax(activation_img, axis=3) activation_img = np.nanmax(activation_img, axis=2) # Remove batch size dimension assert activation_img.shape[0] == 1 activation_img = activation_img.sum(0) # Make activations 1-based indexing activation_img = np.insert(activation_img, 0, 0.0) # activation_image is now a vector of length equal to number of filters (plus one for one-based indexing) # each entry corresponds to the maximum/summed activation of each filter for a given image top_filters = activation_img.argsort()[-top:] return list(top_filters) if __name__ == '__main__': # 获得网络 base_model = AlexNet().model # Get activations and copy maximally activating images to folder # This takes a while! (~4h on my Surface i5) for i in (5,): # 4, 3, 2, 1 # 为数据集创建一个filter张特征图表示, 也就是创建(number, filter)数据,然后存入文件,number表示数据集 # get_activations(i, base_model, mode='summation') start = time.time() # 从数据集中选择对每个filter响应最大图片拷贝到目录下 find_strongest_image(i) print("Copied images in {} s\n".format(time.time() - start))
with open(training_file, mode='rb') as f: train = pickle.load(f) with open(validation_file, mode='rb') as f: valid = pickle.load(f) with open(testing_file, mode='rb') as f: test = pickle.load(f) X_train, y_train = train['features'], train['labels'] X_valid, y_valid = valid['features'], valid['labels'] X_test, y_test = test['features'], test['labels'] # TODO: Split data into training and validation sets. # TODO: Define placeholders and resize operation. # TODO: pass placeholder as first argument to `AlexNet`. fc7 = AlexNet(..., feature_extract=True) # NOTE: `tf.stop_gradient` prevents the gradient from flowing backwards # past this point, keeping the weights before and up to `fc7` frozen. # This also makes training faster, less work to do! fc7 = tf.stop_gradient(fc7) # TODO: Add the final layer for traffic sign classification. # TODO: Define loss, training, accuracy operations. # HINT: Look back at your traffic signs project solution, you may # be able to reuse some the code. # TODO: Train and evaluate the feature extraction model.
# create an reinitializable iterator given the dataset structure iterator = Iterator.from_structure(test_data.data.output_types, test_data.data.output_shapes) next_batch = iterator.get_next() # Ops for initializing the two different iterators testing_init_op = iterator.make_initializer(test_data.data) # TF placeholder for graph input and output x = tf.placeholder(tf.float32, [batch_size, 227, 227, 3]) y = tf.placeholder(tf.float32, [batch_size, num_classes]) keep_prob = tf.placeholder(tf.float32) # Initialize model model = AlexNet(x, keep_prob, num_classes, []) # Link variable to model output score = model.fc8 softmax = tf.nn.softmax(score) # Initialize an saver for store model checkpoints saver = tf.train.Saver() labels = indexToLabel() f = open('word_predictions.txt', 'wb') # Start Tensorflow session with tf.Session() as sess: saver = tf.train.import_meta_graph(
#cv2.waitKey(0) #plot images #fig = plt.figure(figsize=(15,6)) #for i, img in enumerate(imgs): # fig.add_subplot(1,41,i+1) # plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) # plt.show() # plt.axis('off') #placeholder for input and dropout rate x = tf.placeholder(tf.float32, [1, 227, 227, 3]) keep_prob = tf.placeholder(tf.float32) #create model with default config ( == no skip_layer and 1000 units in the last layer) model = AlexNet(x, keep_prob, 3, []) #define activation of last layer as score score = model.fc8 #create op to calculate softmax softmax = tf.nn.softmax(score) with tf.Session() as sess: # Initialize all variables sess.run(tf.global_variables_initializer()) # Load the pretrained weights into the model model.load_initial_weights(sess)
# Modify the original ipython code into the lines of code in Python array1 = os.listdir( '/home/mike/Documents/Alexnet_Callback/content/train/ships') array2 = os.listdir( '/home/mike/Documents/Alexnet_Callback/content/train/bikes') array3 = os.listdir( '/home/mike/Documents/Alexnet_Callback/content/validation/ships') array4 = os.listdir( '/home/mike/Documents/Alexnet_Callback/content/validation/bikes') # Add the print function to show the results of images ended with jpg print(array1, array2, array3, array4) # Call the alexnet model in alexnet.py model = AlexNet((227, 227, 3), num_classes) # Compile the model model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='categorical_crossentropy', metrics=['accuracy']) # It will output the AlexNet model after executing the command model.summary() # Designate the directories for training, validation and model saved. train_dir = '/home/mike/Documents/Alexnet_Callback/content/train' valid_dir = '/home/mike/Documents/Alexnet_Callback/content/validation' model_dir = '/home/mike/Documents/Alexnet_Callback/content/my_model.h5' # Assign both the image and the diretory generators
with open(validation_file, mode='rb') as f: valid = pickle.load(f) with open(testing_file, mode='rb') as f: test = pickle.load(f) X_train, y_train = train['features'], train['labels'] X_validation, y_validation = valid['features'], valid['labels'] X_test, y_test = test['features'], test['labels'] # TODO: Define placeholders and resize operation. X_train_resized = tf.image.resize_images(X_train, (227, 227)) X_validation_resized = tf.image.resize_images(X_validation, (227, 227)) X_test_resized = tf.image.resize_images(X_test, (227, 227)) # TODO: pass placeholder as first argument to `AlexNet`. fc7 = AlexNet(X_train_resized, feature_extract=True) # NOTE: `tf.stop_gradient` prevents the gradient from flowing backwards # past this point, keeping the weights before and up to `fc7` frozen. # This also makes training faster, less work to do! fc7 = tf.stop_gradient(fc7) # TODO: Add the final layer for traffic sign classification. shape = (fc7.get_shape().as_list()[-1], nb_classes ) # use this shape for the weight matrix fc8W = tf.Variable(tf.truncated_normal(shape, stddev=0.01)) fc8b = tf.Variable(tf.zeros(nb_classes)) logits = tf.matmul(fc7, fc8W) + fc8b probs = tf.nn.softmax(logits) # TODO: Define loss, training, accuracy operations. # HINT: Look back at your traffic signs project solution, you may
from alexnet import AlexNet height, width, channel, num_class = 227, 227, 3, 2 dataset_path = 'G:\\dataset\\kaggle\dog-vs-cat\\dogs-vs-cats-redux-kernels-edition\\train' alexNet = AlexNet(height, width, channel, num_class, dataset_path) alexNet.train()
from alexnet import AlexNet from image_loader import load_images files = sys.argv[1:] imgs = load_images(files) m, h, w, _ = imgs.shape # load the saved tensorflow model and evaluate a list of paths to PNG files (must be 150x150) num_classes = 1 X = tf.placeholder(tf.float32, shape=(m, h, w, 1)) Y = tf.placeholder(tf.float32, shape=(m, num_classes)) dropout = tf.placeholder(tf.float32) model = AlexNet(X, dropout, num_classes) predictions = model.logits > 0 saver = tf.train.Saver() with tf.Session() as sess: saver.restore(sess, "./tensorflow-ckpt/model.ckpt") logits = sess.run(model.logits, feed_dict={X: imgs, dropout: 0}) _, y_h, y_w, __ = logits.shape width_between = (w - 150) / y_w height_between = (h - 150) / y_h for m, res in enumerate(logits): fig, ax = plt.subplots(1, figsize=(8.5, 11)) ax.imshow(np.squeeze(imgs[m]), cmap="gray") for i, row in enumerate(res):
# create an reinitializable iterator given the dataset structure iterator = Iterator.from_structure(tr_data.data.output_types, tr_data.data.output_shapes) next_batch = iterator.get_next() # Ops for initializing the two different iterators training_init_op = iterator.make_initializer(tr_data.data) validation_init_op = iterator.make_initializer(val_data.data) # TF placeholder for graph input and output x = tf.placeholder(tf.float32, [batch_size, 227, 227, 3]) y = tf.placeholder(tf.float32, [batch_size, num_classes]) keep_prob = tf.placeholder(tf.float32) # Initialize model model = AlexNet(x, keep_prob, num_classes, train_layers) # Link variable to model output score = model.fc8 # List of trainable variables of the layers we want to train var_list = [v for v in tf.trainable_variables() if v.name.split('/')[0] in train_layers] # Op for calculating the loss with tf.name_scope("cross_ent"): loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=score, labels=y)) # Train op with tf.name_scope("train"): # Get gradients of all trainable variables
image_dir=os.path.join(current,'images') img_files=[os.path.join(image_dir,f)for f in os.listdir(image_dir) if f.endswith('.jpeg')] imgs=[] for f in img_files: imgs.append(cv2.imread(f)) fig=plt.figure(figsize=(15,6)) # for i,img in enumerate(imgs): # fig.add_subplot(1,3,i+1) # # plt.imshow(cv2.cvtColor(img,cv2.COLOR_BGR2GRB)) # plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) # plt.axis('off') # plt.show() x=tf.placeholder(tf.float32,[1,227,227,3]) keep_prob=tf.placeholder(tf.float32) model=AlexNet(x,keep_prob,1000,[]) score=model.fc8 softmax=tf.nn.softmax(score) config = tf.ConfigProto() config.gpu_options.per_process_gpu_memory_fraction = 0.5 config.gpu_options.allow_growth = True config.gpu_options.allocator_type = 'BFC' with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) model.load_initial_weights(sess) fig2=plt.figure(figsize=(15,6)) for i,image in enumerate(imgs): # cv2.imshow(str(i),image) img=cv2.resize(image.astype(np.float32),(227,227)) img-=imagenet_mean img=img.reshape((1,227,227,3))
with tf.variable_scope(name) as scope: weights = tf.get_variable('weights', shape=[num_in, num_out], trainable=True) biases = tf.get_variable('biases', [num_out], trainable=True) act = tf.nn.xw_plus_b(x, weights, biases, name=scope.name) return act with tf.Session() as sess: if FLAGS.use_alexnet: if FLAGS.use_logistic == True: clf = linear_model.LogisticRegression() input_x = tf.placeholder(tf.float32, [None, 227, 227, 3]) model = AlexNet(input_x, 1, 1000, []) tf.global_variables_initializer().run() model.load_initial_weights(sess) train_dict = readTrainSet() train_set = loadTrainSet(train_dict) test_set = loadTestNp() train_epoch = np.zeros((50, 227, 227, 3)) train_epoch_label = np.zeros((50, )) for i in range(10): for c in range(50): train_epoch[c] = train_set[c + 1][i + 1] train_epoch_label[c] = c + 1 _fc = sess.run([model.fc7], feed_dict={input_x: train_epoch})[0]
def main(): # tensors features = tf.placeholder(tf.float32, (None, 32, 32, 3)) resized = tf.image.resize_images(features, (227, 227)) labels = tf.placeholder(tf.int32, (None)) labels_one_hot = tf.one_hot(labels, nb_classes) # TODO: make this function work above # train_op, acc_op, loss_op = AlexNetFeatureExtractor(resized, labels) # feature extraction from AlexNet fc7 = AlexNet(resized, feature_extract=True) fc7 = tf.stop_gradient(fc7) shape = (fc7.get_shape().as_list()[-1], nb_classes) fc8W = tf.Variable(tf.truncated_normal(shape, mean, stddev)) fc8b = tf.Variable(tf.zeros(nb_classes)) logits = tf.nn.xw_plus_b(fc7, fc8W, fc8b) # probs = tf.nn.softmax(logits) preds = tf.argmax(logits, axis=1) trues = tf.argmax(labels_one_hot, axis=1) acc_op = tf.reduce_mean(tf.cast(tf.equal(preds, trues), tf.float32)) cross_entropy = tf.nn.softmax_cross_entropy_with_logits( logits, labels_one_hot) loss_op = tf.reduce_mean(cross_entropy) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) train_op = optimizer.minimize(loss_op, var_list=[fc8W, fc8b]) init_op = tf.global_variables_initializer() # load the data X, y = load_data() # split the data into train and val X_train, X_val, y_train, y_val = \ train_test_split(X, y, test_size=0.25, random_state=0) def evaluate(sess, X_eval, y_eval): nb_samples = X_eval.shape[0] total_loss = 0 total_acc = 0 for start_i in range(0, nb_samples, batch_size): end_i = start_i + batch_size X_eval_batch = X_eval[start_i:end_i] y_eval_batch = y_eval[start_i:end_i] loss, accuracy = \ sess.run([loss_op, acc_op], feed_dict={features: X_eval_batch, labels: y_eval_batch}) total_loss += (loss * X_eval_batch.shape[0]) total_loss += (accuracy * X_eval_batch.shape[0]) return total_loss / nb_samples, total_acc / nb_samples with tf.Session() as sess: sess.run(init_op) nb_samples = len(X_train) # TODO: write more concisely if possible for epoch_i in range(epochs): print('Epoch {}'.format(epoch_i + 1)) X_train, y_train = shuffle(X_train, y_train) t0 = time.time() for start_i in range(0, nb_samples, batch_size): end_i = start_i + batch_size X_batch = X_train[start_i:end_i] y_batch = y_train[start_i:end_i] sess.run(train_op, feed_dict={ features: X_batch, labels: y_batch }) val_loss, val_acc = evaluate(sess, X_val, y_val) # show loss and accuracy for each epoch print('Time {:.3f} seconds'.format(epoch_i, time.time() - t0)) print('Validation Loss = ', val_loss) print('Validation Accuracy = ', val_acc)