def test(): test_images, test_ids = dataset.read_test_set(conf.test_path2, conf.img_size) # image1 = np.frombuffer(data, np.uint8) # image1 = image1.astype('float32') # image1 = image1 / 255 start_times = time.time() image1 = test_images[0] image1 = image1.reshape(conf.img_size_flat) feed_dict = {"x:0": [image1]} values = session.run(final_tensor, feed_dict=feed_dict) maxValue = session.run(tf.argmax(values, dimension=1)) percentege = session.run(final_tensor, feed_dict=feed_dict) print(percentege) print('\nPrediction: ', conf.classes[maxValue[0]]) # print('Real: ', test_ids[i].split('-', 1)[0]) end_times = time.time() time_difs = end_times - start_times print("Time: " + str(round(time_difs))) return (conf.classes[maxValue[0]])
def prepare_cifar_10_data_for_conv_net(): # Prepare input data classes = ['dogs', 'cats'] num_classes = len(classes) # 20% of the data will automatically be used for validation validation_size = 0.0 img_size = 128 num_channels = 3 train_path = dataPath + '/cifar-10_data/train/' test_path = dataPath + '/cifar-10_data/test/' # We shall load all the training and validation images and labels into memory using openCV and use that during training data = dataset.read_train_sets(train_path, img_size, classes, validation_size=0) test_images, test_ids = dataset.read_test_set(test_path, img_size) # print("Size of:") # print("- Training-set:\t\t{}".format(len(data.train.images))) # print("- Test-set:\t\t{}".format(len(test_images))) # print("- Validation-set:\t{}".format(len(data.valid.labels))) return [data.train.images, data.train.labels, test_images, test_ids, data]
# validation split validation_size = .2 # how long to wait after validation loss stops improving before terminating training early_stopping = None # use None if you don't want to implement early stoping train_path='training_data' test_path='testing_data' data = dataset.read_train_sets(train_path, img_size, classes, validation_size=validation_size) test_images, test_ids = dataset.read_test_set(test_path, img_size,classes) print("Size of:") print("- Training-set:\t\t{}".format(len(data.train.labels))) print("- Test-set:\t\t{}".format(len(test_images))) print("- Validation-set:\t{}".format(len(data.valid.labels))) def new_weights(shape): return tf.Variable(tf.truncated_normal(shape, stddev=0.05)) def new_biases(length): return tf.Variable(tf.constant(0.05, shape=[length]))
import datetime import pandas as pd import random #===================== import dataset import config as conf import plot as pl import printStatus as prSt #===================== import csv data = dataset.read_train_sets(conf.train_path, conf.img_size, conf.classes, validation_size=conf.validation_size) test_images, test_ids = dataset.read_test_set(conf.test_path, conf.img_size) print("Size of:") print("- Training-set:\t\t{}".format(len(data.train.labels))) print("- Test-set:\t\t{}".format(len(test_images))) print("- Validation-set:\t{}".format(len(data.valid.labels))) # Get some random images and their labels from the train set. images, cls_true = data.train.images, data.train.cls # Plot the images and labels using our helper-function above. #pl.plot_images(images=images, cls_true=cls_true) graph = tf.Graph()
def output_mouth(age,gender): # Convolutional Layer 1. filter_size1 = 3 num_filters1 = 32 # Convolutional Layer 2. filter_size2 = 3 num_filters2 = 32 # Convolutional Layer 3. filter_size3 = 3 num_filters3 = 64 # Fully-connected layer. fc_size = 128 # Number of neurons in fully-connected layer. # Number of color channels for the images: 1 channel for gray-scale. num_channels = 3 # image dimensions (only squares for now) img_size = 128 # Size of image when flattened to a single dimension img_size_flat = img_size * img_size * num_channels # Tuple with height and width of images used to reshape arrays. img_shape = (img_size, img_size) # class info classes = ['thick','thin'] num_classes = len(classes) # batch size batch_size = 32 # validation split validation_size = .16 # how long to wait after validation loss stops improving before terminating training early_stopping = None # use None if you don't want to implement early stoping checkpoint_dir = "models/Mouth/" input_path = 'input/mouth' input_images, input_ids = dataset.read_test_set(input_path, img_size) def plot_images(images, cls_true, cls_pred=None): if len(images) == 0: print("no images to show") return else: random_indices = random.sample(range(len(images)), min(len(images), 9)) images, cls_true = zip(*[(images[i], cls_true[i]) for i in random_indices]) # Create figure with 3x3 sub-plots. fig, axes = plt.subplots(3, 3) fig.subplots_adjust(hspace=0.3, wspace=0.3) for i, ax in enumerate(axes.flat): # Plot image. ax.imshow(images[i].reshape(img_size, img_size, num_channels)) # Show true and predicted classes. if cls_pred is None: xlabel = "True: {0}".format(cls_true[i]) else: xlabel = "True: {0}, Pred: {1}".format(cls_true[i], cls_pred[i]) # Show the classes as the label on the x-axis. ax.set_xlabel(xlabel) # Remove ticks from the plot. ax.set_xticks([]) ax.set_yticks([]) # Ensure the plot is shown correctly with multiple plots # in a single Notebook cell. plt.show() def new_weights(shape): return tf.Variable(tf.truncated_normal(shape, stddev=0.05)) def new_biases(length): return tf.Variable(tf.constant(0.05, shape=[length])) def new_conv_layer(input, # The previous layer. num_input_channels, # Num. channels in prev. layer. filter_size, # Width and height of each filter. num_filters, # Number of filters. use_pooling=True): # Use 2x2 max-pooling. # Shape of the filter-weights for the convolution. # This format is determined by the TensorFlow API. shape = [filter_size, filter_size, num_input_channels, num_filters] # Create new weights aka. filters with the given shape. weights = new_weights(shape=shape) # Create new biases, one for each filter. biases = new_biases(length=num_filters) # Create the TensorFlow operation for convolution. # Note the strides are set to 1 in all dimensions. # The first and last stride must always be 1, # because the first is for the image-number and # the last is for the input-channel. # But e.g. strides=[1, 2, 2, 1] would mean that the filter # is moved 2 pixels across the x- and y-axis of the image. # The padding is set to 'SAME' which means the input image # is padded with zeroes so the size of the output is the same. layer = tf.nn.conv2d(input=input, filter=weights, strides=[1, 1, 1, 1], padding='SAME') # Add the biases to the results of the convolution. # A bias-value is added to each filter-channel. layer += biases # Use pooling to down-sample the image resolution? if use_pooling: # This is 2x2 max-pooling, which means that we # consider 2x2 windows and select the largest value # in each window. Then we move 2 pixels to the next window. layer = tf.nn.max_pool(value=layer, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') # Rectified Linear Unit (ReLU). # It calculates max(x, 0) for each input pixel x. # This adds some non-linearity to the formula and allows us # to learn more complicated functions. layer = tf.nn.relu(layer) # Note that ReLU is normally executed before the pooling, # but since relu(max_pool(x)) == max_pool(relu(x)) we can # save 75% of the relu-operations by max-pooling first. # We return both the resulting layer and the filter-weights # because we will plot the weights later. return layer, weights def flatten_layer(layer): # Get the shape of the input layer. layer_shape = layer.get_shape() # The shape of the input layer is assumed to be: # layer_shape == [num_images, img_height, img_width, num_channels] # The number of features is: img_height * img_width * num_channels # We can use a function from TensorFlow to calculate this. num_features = layer_shape[1:4].num_elements() # Reshape the layer to [num_images, num_features]. # Note that we just set the size of the second dimension # to num_features and the size of the first dimension to -1 # which means the size in that dimension is calculated # so the total size of the tensor is unchanged from the reshaping. layer_flat = tf.reshape(layer, [-1, num_features]) # The shape of the flattened layer is now: # [num_images, img_height * img_width * num_channels] # Return both the flattened layer and the number of features. return layer_flat, num_features def new_fc_layer(input, # The previous layer. num_inputs, # Num. inputs from prev. layer. num_outputs, # Num. outputs. use_relu=True): # Use Rectified Linear Unit (ReLU)? # Create new weights and biases. weights = new_weights(shape=[num_inputs, num_outputs]) biases = new_biases(length=num_outputs) # Calculate the layer as the matrix multiplication of # the input and weights, and then add the bias-values. layer = tf.matmul(input, weights) + biases # Use ReLU? if use_relu: layer = tf.nn.relu(layer) return layer x = tf.placeholder(tf.float32, shape=[None, img_size_flat], name='x') x_image = tf.reshape(x, [-1, img_size, img_size, num_channels]) y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true') y_true_cls = tf.argmax(y_true, dimension=1) layer_conv1, weights_conv1 = \ new_conv_layer(input=x_image, num_input_channels=num_channels, filter_size=filter_size1, num_filters=num_filters1, use_pooling=True) layer_conv2, weights_conv2 = \ new_conv_layer(input=layer_conv1, num_input_channels=num_filters1, filter_size=filter_size2, num_filters=num_filters2, use_pooling=True) layer_conv3, weights_conv3 = \ new_conv_layer(input=layer_conv2, num_input_channels=num_filters2, filter_size=filter_size3, num_filters=num_filters3, use_pooling=True) layer_flat, num_features = flatten_layer(layer_conv3) layer_fc1 = new_fc_layer(input=layer_flat, num_inputs=num_features, num_outputs=fc_size, use_relu=True) layer_fc2 = new_fc_layer(input=layer_fc1, num_inputs=fc_size, num_outputs=num_classes, use_relu=False) y_pred = tf.nn.softmax(layer_fc2) y_pred_cls = tf.argmax(y_pred, dimension=1) cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=layer_fc2, labels=y_true) cost = tf.reduce_mean(cross_entropy) optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cost) correct_prediction = tf.equal(y_pred_cls, y_true_cls) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) session = tf.Session() new_saver = tf.train.import_meta_graph('models/Mouth/my-model.meta') new_saver.restore(session, tf.train.latest_checkpoint('models/Mouth')) all_vars = tf.get_collection('vars') session.run(tf.global_variables_initializer()) train_batch_size = batch_size total_iterations = 0 def optimize(num_iterations): # Ensure we update the global variable rather than a local copy. global total_iterations # Start-time used for printing time-usage below. start_time = time.time() best_val_loss = float("inf") patience = 0 for i in range(total_iterations, total_iterations + num_iterations): # Get a batch of training examples. # x_batch now holds a batch of images and # y_true_batch are the true labels for those images. x_batch, y_true_batch, _, cls_batch = data.train.next_batch(train_batch_size) x_valid_batch, y_valid_batch, _, valid_cls_batch = data.valid.next_batch(train_batch_size) # Convert shape from [num examples, rows, columns, depth] # to [num examples, flattened image shape] x_batch = x_batch.reshape(train_batch_size, img_size_flat) x_valid_batch = x_valid_batch.reshape(train_batch_size, img_size_flat) # Put the batch into a dict with the proper names # for placeholder variables in the TensorFlow graph. feed_dict_train = {x: x_batch, y_true: y_true_batch} feed_dict_validate = {x: x_valid_batch, y_true: y_valid_batch} # Run the optimizer using this batch of training data. # TensorFlow assigns the variables in feed_dict_train # to the placeholder variables and then runs the optimizer. session.run(optimizer, feed_dict=feed_dict_train) # Print status at end of each epoch (defined as full pass through training dataset). if i % int(data.train.num_examples / batch_size) == 0: val_loss = session.run(cost, feed_dict=feed_dict_validate) epoch = int(i / int(data.train.num_examples / batch_size)) print_progress(epoch, feed_dict_train, feed_dict_validate, val_loss) if early_stopping: if val_loss < best_val_loss: best_val_loss = val_loss patience = 0 else: patience += 1 if patience == early_stopping: break # Update the total number of iterations performed. total_iterations += num_iterations # Ending time. end_time = time.time() # Difference between start and end-times. time_dif = end_time - start_time # Print the time-usage. print("Time elapsed: " + str(timedelta(seconds=int(round(time_dif))))) def plot_example_errors(cls_pred, correct): # cls_pred is an array of the predicted class-number for # all images in the test-set. # correct is a boolean array whether the predicted class # is equal to the true class for each image in the test-set. # Negate the boolean array. incorrect = (correct == False) # Get the images from the test-set that have been # incorrectly classified. images = data.valid.images[incorrect] # Get the predicted classes for those images. cls_pred = cls_pred[incorrect] # Get the true classes for those images. cls_true = data.valid.cls[incorrect] # Plot the first 9 images. plot_images(images=images[0:9], cls_true=cls_true[0:9], cls_pred=cls_pred[0:9]) def plot_confusion_matrix(cls_pred): # cls_pred is an array of the predicted class-number for # all images in the test-set. # Get the true classifications for the test-set. cls_true = data.valid.cls # Get the confusion matrix using sklearn. cm = confusion_matrix(y_true=cls_true, y_pred=cls_pred) # Print the confusion matrix as text. print(cm) # Plot the confusion matrix as an image. plt.matshow(cm) # Make various adjustments to the plot. plt.colorbar() tick_marks = np.arange(num_classes) plt.xticks(tick_marks, range(num_classes)) plt.yticks(tick_marks, range(num_classes)) plt.xlabel('Predicted') plt.ylabel('True') # Ensure the plot is shown correctly with multiple plots # in a single Notebook cell. plt.show() def print_validation_accuracy(show_example_errors=False, show_confusion_matrix=False): # Number of images in the test-set. num_test = len(data.valid.images) # Allocate an array for the predicted classes which # will be calculated in batches and filled into this array. cls_pred = np.zeros(shape=num_test, dtype=np.int) # Now calculate the predicted classes for the batches. # We will just iterate through all the batches. # There might be a more clever and Pythonic way of doing this. # The starting index for the next batch is denoted i. i = 0 while i < num_test: # The ending index for the next batch is denoted j. j = min(i + batch_size, num_test) # Get the images from the test-set between index i and j. images = data.valid.images[i:j, :].reshape(batch_size, img_size_flat) # Get the associated labels. labels = data.valid.labels[i:j, :] # Create a feed-dict with these images and labels. feed_dict = {x: images, y_true: labels} # Calculate the predicted class using TensorFlow. cls_pred[i:j] = session.run(y_pred_cls, feed_dict=feed_dict) # Set the start-index for the next batch to the # end-index of the current batch. i = j cls_true = np.array(data.valid.cls) cls_pred = np.array([classes[x] for x in cls_pred]) # Create a boolean array whether each image is correctly classified. correct = (cls_true == cls_pred) # Calculate the number of correctly classified images. # When summing a boolean array, False means 0 and True means 1. correct_sum = correct.sum() # Classification accuracy is the number of correctly classified # images divided by the total number of images in the test-set. acc = float(correct_sum) / num_test # Print the accuracy. msg = "Accuracy on Test-Set: {0:.1%} ({1} / {2})" print(msg.format(acc, correct_sum, num_test)) # Plot some examples of mis-classifications, if desired. if show_example_errors: print("Example errors:") plot_example_errors(cls_pred=cls_pred, correct=correct) # Plot the confusion matrix, if desired. if show_confusion_matrix: print("Confusion Matrix:") plot_confusion_matrix(cls_pred=cls_pred) def plot_conv_weights(weights, input_channel=0): # Assume weights are TensorFlow ops for 4-dim variables # e.g. weights_conv1 or weights_conv2. # Retrieve the values of the weight-variables from TensorFlow. # A feed-dict is not necessary because nothing is calculated. w = session.run(weights) # Get the lowest and highest values for the weights. # This is used to correct the colour intensity across # the images so they can be compared with each other. w_min = np.min(w) w_max = np.max(w) # Number of filters used in the conv. layer. num_filters = w.shape[3] # Number of grids to plot. # Rounded-up, square-root of the number of filters. num_grids = math.ceil(math.sqrt(num_filters)) # Create figure with a grid of sub-plots. fig, axes = plt.subplots(int(num_grids), int(num_grids)) # Plot all the filter-weights. for i, ax in enumerate(axes.flat): # Only plot the valid filter-weights. if i < num_filters: # Get the weights for the i'th filter of the input channel. # See new_conv_layer() for details on the format # of this 4-dim tensor. img = w[:, :, input_channel, i] # Plot image. ax.imshow(img, vmin=w_min, vmax=w_max, interpolation='nearest', cmap='seismic') # Remove ticks from the plot. ax.set_xticks([]) ax.set_yticks([]) # Ensure the plot is shown correctly with multiple plots # in a single Notebook cell. plt.show() def plot_conv_layer(layer, image): # Assume layer is a TensorFlow op that outputs a 4-dim tensor # which is the output of a convolutional layer, # e.g. layer_conv1 or layer_conv2. image = image.reshape(img_size_flat) # Create a feed-dict containing just one image. # Note that we don't need to feed y_true because it is # not used in this calculation. feed_dict = {x: [image]} # Calculate and retrieve the output values of the layer # when inputting that image. values = session.run(layer, feed_dict=feed_dict) # Number of filters used in the conv. layer. num_filters = values.shape[3] # Number of grids to plot. # Rounded-up, square-root of the number of filters. num_grids = math.ceil(math.sqrt(num_filters)) # Create figure with a grid of sub-plots. fig, axes = plt.subplots(int(num_grids), int(num_grids)) # Plot the output images of all the filters. for i, ax in enumerate(axes.flat): # Only plot the images for valid filters. if i < num_filters: # Get the output image of using the i'th filter. # See new_conv_layer() for details on the format # of this 4-dim tensor. img = values[0, :, :, i] # Plot image. ax.imshow(img, interpolation='nearest', cmap='binary') # Remove ticks from the plot. ax.set_xticks([]) ax.set_yticks([]) # Ensure the plot is shown correctly with multiple plots # in a single Notebook cell. plt.show() def write_predictions(ims, ids): ims = ims.reshape(ims.shape[0], img_size_flat) preds = session.run(y_pred, feed_dict={x: ims}) result = pd.DataFrame(preds, columns=classes) result.loc[:, 'id'] = pd.Series(ids, index=result.index) pred_file = 'Test_mouth.csv' result.to_csv(pred_file, index=False) write_predictions(input_images, input_ids) with open('Test_mouth.csv') as csvfile: readCSV = csv.reader(csvfile, delimiter=',') thick = [] thin = [] for row in readCSV: date = row[0] color1 = row[1] thick.append(date) thin.append(color1) value_data = [] value_data.append(thick[1]) value_data.append(thin[1]) class_data = [] class_data.append(thick[0]) class_data.append(thin[0]) print(class_data) m = max(thick[1], thin[1]) if m == thick[1]: v = 0 if m == thin[1]: v = 1 class_choose = class_data[v] location = "output/mouths/" name = str(gender + "_" + age + "_" + class_choose + ".png") where_mouth = str(location + name) print(where_mouth) from shutil import copyfile copyfile(where_mouth, 'cartoon_feature/mouth/mouth.png') session.close()
def main(): data = dataset.read_train_sets(train_path, img_size, classes, validation_size=validation_size) test_images, test_ids = dataset.read_test_set(test_path, img_size) print("Size of:") print("- Training-set:\t\t{}".format(len(data.train.labels))) print("- Test-set:\t\t{}".format(len(test_images))) print("- Validation-set:\t{}".format(len(data.valid.labels))) # Get some random images and their labels from the train set. images, cls_true = data.train.images, data.train.cls # Plot the images and labels using our helper-function above. plot_images(images=images, cls_true=cls_true) x = tf.placeholder(tf.float32, shape=[None, img_size_flat], name='x') x_image = tf.reshape(x, [-1, img_size, img_size, num_channels]) layer_conv1, weights_conv1 = new_conv_layer(input=x_image, num_input_channels=num_channels, filter_size=filter_size1, num_filters=num_filters1, use_pooling=True) # Check the shape of the tensor that will be output by the convolutional layer. It is (?, x, x, 16) # which means that there is an arbitrary number of images (this is the ?), each image is x pixels wide and # x pixels high, and there are 16 different channels, one channel for each of the filters. print(layer_conv1) y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true') y_true_cls = tf.argmax(y_true, dimension=1) layer_conv2, weights_conv2 = new_conv_layer(input=layer_conv1, num_input_channels=num_filters1, filter_size=filter_size2, num_filters=num_filters2, use_pooling=True) print(layer_conv2) layer_conv3, weights_conv3 = new_conv_layer(input=layer_conv2, num_input_channels=num_filters2, filter_size=filter_size3, num_filters=num_filters3, use_pooling=True) print(layer_conv3) layer_flat, num_features = flatten_layer(layer_conv3) print(layer_flat) print(num_features) layer_fc1 = new_fc_layer(input=layer_flat, num_inputs=num_features, num_outputs=fc_size, use_relu=True) print(layer_fc1) layer_fc2 = new_fc_layer(input=layer_fc1, num_inputs=fc_size, num_outputs=num_classes, use_relu=False) print(layer_fc2) y_pred = tf.nn.softmax(layer_fc2) y_pred_cls = tf.argmax(y_pred, dimension=1) cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=layer_fc2, labels=y_true) cost = tf.reduce_mean(cross_entropy) optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cost) correct_prediction = tf.equal(y_pred_cls, y_true_cls) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) session = tf.Session() session.run(tf.global_variables_initializer()) batch_size = 2 train_batch_size = batch_size #optimize(num_iterations=1) optimize(num_iterations = 1, data=data, train_batch_size=train_batch_size, x=x, y_true=y_true, session=session, optimizer=optimizer, cost=cost, accuracy=accuracy) #print_validation_accuracy(x) print_validation_accuracy(x, y_true, y_pred_cls, session, data, show_example_errors=False, show_confusion_matrix=False) total_iterations = 0 #optimize(num_iterations=100) # We already performed 1 iteration above. optimize(num_iterations=100, data=data, train_batch_size=train_batch_size, x=x, y_true=y_true, session=session, optimizer=optimizer, cost=cost, accuracy=accuracy) #print_validation_accuracy(x, show_example_errors=True) print_validation_accuracy(x, y_true, y_pred_cls, session, data, show_example_errors=True, show_confusion_matrix=False) #optimize(num_iterations=900) # We performed 100 iterations above. optimize(num_iterations=100, data=data, train_batch_size=train_batch_size, x=x, y_true=y_true, session=session, optimizer=optimizer, cost=cost, accuracy=accuracy) #print_validation_accuracy(x, show_example_errors=True) print_validation_accuracy(x, y_true, y_pred_cls, session, data, show_example_errors=True, show_confusion_matrix=False) #optimize(num_iterations=9000) # We performed 1000 iterations above. #print_validation_accuracy(show_example_errors=True, # show_confusion_matrix=True) image1 = test_images[0] plot_image(image1) # Plot another example image from the test-set. image2 = test_images[13] plot_image(image2) # ### Convolution Layer 1 # Now plot the filter-weights for the first convolutional layer. # Note that positive weights are red and negative weights are blue. plot_conv_weights(weights=weights_conv1, session=session) # Applying each of these convolutional filters to the first input image gives the following output images, # which are then used as input to the second convolutional layer. Note that these images are down-sampled to about # half the resolution of the original input image. plot_conv_layer(layer=layer_conv1, image=image1, session=session, x=x) # The following images are the results of applying the convolutional filters to the second image. plot_conv_layer(layer=layer_conv1, image=image2, session=session, x=x) # ### Convolution Layer 2 # Now plot the filter-weights for the second convolutional layer. # There are 16 output channels from the first conv-layer, which means there are 16 input channels to the second # conv-layer. The second conv-layer has a set of filter-weights for each of its input channels. # We start by plotting the filter-weigths for the first channel. plot_conv_weights(weights=weights_conv2, session=session,input_channel=0) # There are 16 input channels to the second convolutional layer, so we can make another 15 plots of filter-weights # like this. We just make one more with the filter-weights for the second channel. plot_conv_weights(weights=weights_conv2, session=session, input_channel=1) # It can be difficult to understand and keep track of how these filters are applied because of the high dimensionality. # # Applying these convolutional filters to the images that were ouput from the first conv-layer gives the following images. # # Note that these are down-sampled yet again to half the resolution of the images from the first conv-layer. plot_conv_layer(layer=layer_conv2, image=image1, session=session, x=x) # And these are the results of applying the filter-weights to the second image. plot_conv_layer(layer=layer_conv2, image=image2, session=session, x=x) session.close()
def main(_): step = tf.placeholder(tf.int32) tst=tf.placeholder(tf.bool) classes = ['1','2'] train_set=dataset.read_train_set(TRAIN_PATH,IMAGE_SIZE,classes) # validation_set=dataset.read_validation_set(VALIDATION_PATH,IMAGE_SIZE,classes) x=tf.placeholder(tf.float32,shape=[None,IMAGE_SIZE,IMAGE_SIZE,NUM_CHANNELS],name='input_x') y_=tf.placeholder(tf.float32,shape=[None,2],name='truelabel_y_') y_conv,keep_prob,update_moving_averages=forward(x,tst,step) with tf.name_scope('loss'): cross_entropy=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_,logits=y_conv)) tf.add_to_collection('losses',cross_entropy) losses=tf.add_n(tf.get_collection('losses')) tf.summary.scalar('loss',losses) with tf.name_scope('Adam_optimizer'): lr = 0.0001 + tf.train.exponential_decay(0.003, step, 2000, 1 / math.e) train_step=tf.train.AdamOptimizer(lr).minimize(losses) with tf.name_scope('accuracy'): y_pred=tf.argmax(tf.nn.softmax(y_conv),1) y_true=tf.argmax(y_,1) cross_prediction=tf.equal(y_pred,y_true) accuracy=tf.reduce_mean(tf.cast(cross_prediction,tf.float32)) tf.summary.scalar('accuracy',accuracy) merged=tf.summary.merge_all() with tf.Session() as sess: summary_writer_train=tf.summary.FileWriter(r'log_train',sess.graph) # summary_writer_val=tf.summary.FileWriter(r'log_val',sess.graph) sess.run(tf.global_variables_initializer()) for i in range(TRAIN_STEP): train_images,train_labels,_,_=train_set.next_batch(BATCH_SIZE) if i%1==0: feed_dict_train0={x:train_images,y_:train_labels,keep_prob:1,step:i,tst:False} summary_train,train_accuracy=sess.run([merged,accuracy],feed_dict=feed_dict_train0) summary_writer_train.add_summary(summary_train, i) # val_images,val_labels,_,_=validation_set.next_batch(BATCH_SIZE) # feed_dict_val={x: val_images, y_: val_labels,keep_prob:1,step:i,tst:False} # summary_val,val_accuracy=sess.run([merged,accuracy], feed_dict=feed_dict_val) # summary_writer_val.add_summary(summary_val,i) print('on Step %d:Training accuracy' %i, train_accuracy*100) # if i%1000==0: # # # y_pred_cls,y_true_cls=sess.run([y_pred,y_true],feed_dict=feed_dict_val) # draw_confusion_matrix(y_pred_cls,y_true_cls) feed_dict_train={x:train_images,y_:train_labels,keep_prob:0.5,step:i,tst:False} sess.run(train_step,feed_dict=feed_dict_train) test_set=dataset.read_test_set(TEST_PATH,IMAGE_SIZE,classes) test_images,test_labels,_,_=test_set.next_batch(60) feed_dict_test={x:test_images,y_:test_labels,keep_prob:1,step:i,tst:False} y_pred_cls,y_true_cls,test_accuracy=sess.run([y_pred,y_true,accuracy],feed_dict=feed_dict_test) draw_confusion_matrix(y_pred_cls,y_true_cls) print('Test accuracy=%.1ff%%'%(test_accuracy*100)) summary_writer_train.close()
def save_to_file(file_name, contents): fh = open(file_name, 'w') fh.write(contents) fh.close() if __name__ == '__main__': # the test image directory to be predicted test_img_dir = sys.argv[1] # the output file where it records the prediction results output_addr = sys.argv[2] test_imgs, test_img_names = dataset.read_test_set(test_img_dir, img_size) output_str = '' i = 0 for img_name in test_img_names: j = 1 predict_class = [] is_qualified = True unqualified_indexes = [] while j <= 3: test_image = test_imgs[i] predict_rst = sample_prediction(test_image) predict_class.append(predict_rst) if predict_rst == 'Unqualified': unqualified_indexes.append(j) if is_qualified: