Adding projects and CNNs

Author: swaathi

.DS_Store

@@ -0,0 +1,104 @@
+import tensorflow as tf
+import numpy as np
+from conf import *
+from cifar10 import *
+
+# Working of our algorithm is as follows:
+# Conv1_layer -> Conv2_layer -> Flatten_layer -> FullyConnected_layer -> FullyConnected_layer(With 10 Classes)
+
+# Reading the data
+image_data, image_cls, img_one_hot_cls = (load_training_data())
+
+image_data_flat = image_data.reshape([-1,3072])
+
+# Function for defining weights
+def new_weights(shape):
+	return tf.Variable(tf.truncated_normal(shape, stddev=0.05))
+
+# Function for defining biases
+def new_bias(length):
+	return tf.Variable(tf.constant(0.5, shape=[length]))
+
+# Function to create the convolution layer with/without max-pooling
+def new_conv_layer(input, num_input_channels, filter_size, num_filters, use_pooling=True):
+	shape = [filter_size, filter_size, num_input_channels, num_filters]
+	weights = new_weights(shape = shape)
+	biases = new_bias(length = num_filters)
+
+	# tf.nn.conv2d needs a 4D input
+	layer = tf.nn.conv2d(input = input, filter= weights, strides=[1,1,1,1], padding='SAME')
+	layer += biases
+	if use_pooling:
+		layer = tf.nn.max_pool(value = layer, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
+	# relu activation function converts all negatives to zero
+	layer = tf.nn.relu(layer)
+	return layer, weights
+
+# After all convolutions, we need to flatten the layer
+def flatten_layer(layer):
+	layer_shape = layer.get_shape()
+	num_features = layer_shape[1:4].num_elements()
+	layer_flat = tf.reshape(layer, [-1, num_features])
+	return layer_flat, num_features
+
+# Fully connected layer
+def new_fc_layer(input, num_inputs, num_outputs, use_relu=True):
+	weights = new_weights(shape=[num_inputs, num_outputs])
+	biases = new_bias(length= num_outputs)
+	layer = tf.matmul(input, weights) + biases
+	if use_relu:
+		layer = tf.nn.relu(layer)
+	return layer
+
+
+# The placeholder to hold the X and Y values while training
+x = tf.placeholder(tf.float32, shape=[None, img_size_flat], name='x')
+y_true = tf.placeholder(tf.float32, shape=[None, 10], name='y_true')
+
+x_image = tf.reshape(x, [-1, img_size, img_size, num_channels])
+y_true_cls = tf.argmax(y_true, dimension=1)
+
+# The beginning of the process
+layer_conv1, weights_conv1 = new_conv_layer(input = x_image, num_input_channels= num_channels, filter_size = filter1_size, num_filters = number_of_filter1, use_pooling=True)
+layer_conv2, weights_conv2 = new_conv_layer(input = layer_conv1, num_input_channels= number_of_filter1, filter_size = filter2_size, num_filters = number_of_filter2, use_pooling=True)
+layer_flat, num_features = flatten_layer(layer_conv2)
+layer_fc1 = new_fc_layer(layer_flat, num_features, fc_size, True)
+layer_fc2 = new_fc_layer(layer_fc1, fc_size, num_classes, False)
+
+# Finally Softmax function
+y_pred = tf.nn.softmax(layer_fc2)
+y_pred_cls = tf.argmax(y_pred, dimension=1)
+
+# Cost function calculation and optimization function
+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)
+
+# Checking for the right predictions
+correct_prediction = tf.equal(y_pred_cls, y_true_cls)
+accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
+
+# TF Session initiation
+session = tf.Session()
+session.run(tf.global_variables_initializer())
+
+# The trainer function to iterate the training process to learn further
+def optimize(num_iterations):
+	x_batch, y_true_batch = image_data_flat, img_one_hot_cls
+	feed_dict_train = {x: x_batch[:500], y_true: y_true_batch[:500]}
+	feed_dict_test = {x: x_batch[500:1000], y_true: y_true_batch[500:1000]}
+	for i in range(num_iterations):
+		session.run(optimizer, feed_dict=feed_dict_train)
+		# Print status every 10 iterations.
+		if i % 10 == 0:
+		# Calculate the accuracy on the training-set.
+			acc = session.run(accuracy, feed_dict=feed_dict_test)
+
+		# Message for printing.
+			print "Step ",i+1,': ', acc*100
+
+optimize(STEPS)
+
+# test_data = image_data[1115].reshape([1,3072])
+# print image_cls[1115]
+# print session.run(y_pred_cls, {x: test_data})

softmax_classification.py renamed to classification/softmax_classification.py

@@ -0,0 +1,259 @@
+########################################################################
+#
+# Functions for downloading the CIFAR-10 data-set from the internet
+# and loading it into memory.
+#
+# Implemented in Python 3.5
+#
+# Usage:
+# 1) Set the variable data_path with the desired storage path.
+# 2) Call maybe_download_and_extract() to download the data-set
+#    if it is not already located in the given data_path.
+# 3) Call load_class_names() to get an array of the class-names.
+# 4) Call load_training_data() and load_test_data() to get
+#    the images, class-numbers and one-hot encoded class-labels
+#    for the training-set and test-set.
+# 5) Use the returned data in your own program.
+#
+# Format:
+# The images for the training- and test-sets are returned as 4-dim numpy
+# arrays each with the shape: [image_number, height, width, channel]
+# where the individual pixels are floats between 0.0 and 1.0.
+#
+########################################################################
+#
+# This file is part of the TensorFlow Tutorials available at:
+#
+# https://github.com/Hvass-Labs/TensorFlow-Tutorials
+#
+# Published under the MIT License. See the file LICENSE for details.
+#
+# Copyright 2016 by Magnus Erik Hvass Pedersen
+#
+########################################################################
+
+import numpy as np
+import pickle
+import os
+import download
+
+########################################################################
+
+# Directory where you want to download and save the data-set.
+# Set this before you start calling any of the functions below.
+data_path = "data/cifar10/"
+
+# URL for the data-set on the internet.
+data_url = "https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz"
+
+########################################################################
+# Various constants for the size of the images.
+# Use these constants in your own program.
+
+# Width and height of each image.
+img_size = 32
+
+# Number of channels in each image, 3 channels: Red, Green, Blue.
+num_channels = 3
+
+# Length of an image when flattened to a 1-dim array.
+img_size_flat = img_size * img_size * num_channels
+
+# Number of classes.
+num_classes = 10
+
+########################################################################
+# Various constants used to allocate arrays of the correct size.
+
+# Number of files for the training-set.
+_num_files_train = 1
+
+# Number of images for each batch-file in the training-set.
+_images_per_file = 10000
+
+# Total number of images in the training-set.
+# This is used to pre-allocate arrays for efficiency.
+_num_images_train = _num_files_train * _images_per_file
+
+########################################################################
+# Private functions for downloading, unpacking and loading data-files.
+
+
+def _get_file_path(filename=""):
+    """
+    Return the full path of a data-file for the data-set.
+
+    If filename=="" then return the directory of the files.
+    """
+
+    return os.path.join(data_path, filename)
+
+
+def one_hot_encoded(class_numbers, num_classes=None):
+    """
+    Generate the One-Hot encoded class-labels from an array of integers.
+
+    For example, if class_number=2 and num_classes=4 then
+    the one-hot encoded label is the float array: [0. 0. 1. 0.]
+
+    :param class_numbers:
+        Array of integers with class-numbers.
+        Assume the integers are from zero to num_classes-1 inclusive.
+
+    :param num_classes:
+        Number of classes. If None then use max(cls)-1.
+
+    :return:
+        2-dim array of shape: [len(cls), num_classes]
+    """
+
+    # Find the number of classes if None is provided.
+    if num_classes is None:
+        num_classes = np.max(class_numbers) - 1
+
+    return np.eye(num_classes, dtype=float)[class_numbers]
+
+
+def _unpickle(filename):
+    """
+    Unpickle the given file and return the data.
+
+    Note that the appropriate dir-name is prepended the filename.
+    """
+
+    # Create full path for the file.
+    file_path = _get_file_path(filename)
+
+    print("Loading data: " + file_path)
+
+    with open(file_path, mode='rb') as file:
+        # In Python 3.X it is important to set the encoding,
+        # otherwise an exception is raised here.
+        data = pickle.load(file)
+
+    return data
+
+
+def _convert_images(raw):
+    """
+    Convert images from the CIFAR-10 format and
+    return a 4-dim array with shape: [image_number, height, width, channel]
+    where the pixels are floats between 0.0 and 1.0.
+    """
+
+    # Convert the raw images from the data-files to floating-points.
+    raw_float = np.array(raw, dtype=float) / 255.0
+
+    # Reshape the array to 4-dimensions.
+    images = raw_float.reshape([-1, num_channels, img_size, img_size])
+
+    # Reorder the indices of the array.
+    images = images.transpose([0, 2, 3, 1])
+
+    return images
+
+
+def _load_data(filename):
+    """
+    Load a pickled data-file from the CIFAR-10 data-set
+    and return the converted images (see above) and the class-number
+    for each image.
+    """
+
+    # Load the pickled data-file.
+    data = _unpickle(filename)
+
+    # Get the raw images.
+    raw_images = data[b'data']
+
+    # Get the class-numbers for each image. Convert to numpy-array.
+    cls = np.array(data[b'labels'])
+
+    # Convert the images.
+    images = _convert_images(raw_images)
+
+    return images, cls
+
+
+########################################################################
+# Public functions that you may call to download the data-set from
+# the internet and load the data into memory.
+
+
+def maybe_download_and_extract():
+    """
+    Download and extract the CIFAR-10 data-set if it doesn't already exist
+    in data_path (set this variable first to the desired path).
+    """
+
+    download.maybe_download_and_extract(url=data_url, download_dir=data_path)
+
+
+def load_class_names():
+    """
+    Load the names for the classes in the CIFAR-10 data-set.
+
+    Returns a list with the names. Example: names[3] is the name
+    associated with class-number 3.
+    """
+
+    # Load the class-names from the pickled file.
+    raw = _unpickle(filename="batches.meta")[b'label_names']
+
+    # Convert from binary strings.
+    names = [x.decode('utf-8') for x in raw]
+
+    return names
+
+
+def load_training_data():
+    """
+    Load all the training-data for the CIFAR-10 data-set.
+
+    The data-set is split into 5 data-files which are merged here.
+
+    Returns the images, class-numbers and one-hot encoded class-labels.
+    """
+
+    # Pre-allocate the arrays for the images and class-numbers for efficiency.
+    images = np.zeros(shape=[_num_images_train, img_size, img_size, num_channels], dtype=float)
+    cls = np.zeros(shape=[_num_images_train], dtype=int)
+
+    # Begin-index for the current batch.
+    begin = 0
+
+    # For each data-file.
+    for i in range(_num_files_train):
+        # Load the images and class-numbers from the data-file.
+        images_batch, cls_batch = _load_data(filename="data_batch_" + str(i + 1))
+
+        # Number of images in this batch.
+        num_images = len(images_batch)
+
+        # End-index for the current batch.
+        end = begin + num_images
+
+        # Store the images into the array.
+        images[begin:end, :] = images_batch
+
+        # Store the class-numbers into the array.
+        cls[begin:end] = cls_batch
+
+        # The begin-index for the next batch is the current end-index.
+        begin = end
+
+    return images, cls, one_hot_encoded(class_numbers=cls, num_classes=num_classes)
+
+
+def load_test_data():
+    """
+    Load all the test-data for the CIFAR-10 data-set.
+
+    Returns the images, class-numbers and one-hot encoded class-labels.
+    """
+
+    images, cls = _load_data(filename="test_batch")
+
+    return images, cls, one_hot_encoded(class_numbers=cls, num_classes=num_classes)
+
+########################################################################

softmax_train.txt renamed to classification/softmax_train.txt

@@ -0,0 +1,13 @@
+# Convolutional Layer 1
+filter1_size = 5
+number_of_filter1 = 16
+
+# Convolutional Layer 2
+filter2_size = 5
+number_of_filter2 = 36
+
+# Fully Connected Layer 
+fc_size = 128
+
+# No of training steps
+STEPS = 100

convolution_networks/.DS_Store

@@ -0,0 +1,2 @@
+
+data_url = "https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz"