What are the uses of layers in keras/Tensorflow

Convolution neural network has 4 main steps: Convolution, Pooling, Flatten, and Full connection.

Conv2D(), Conv3D(), etc. is for Feature extraction (It's a Convolution Layer).

Pooling layers (MaxPool2D(), AvgPool2D(), etc) is for Feature extraction as well (It has different operation though).

Flattening layers (Flatten() ) are to convert the extracted feature map into Vector before being fed into the Fully connection layers (The Dense layers).

Dense layers are for Fully connected step in Computer vision that acts as Classifier (The Neural network classify each extracted features from the Convolution layers.)

There are also optimization layers such as Dropout(), BatchNormalization(), etc.

For more information, just open the keras documentation. If you want to start learning Convolution neural network, this article may help.

A layer in an Artificial Neural Network is a bunch of nodes bound together at a specific depth in a Neural Network. Keras is a high level API used over NN modules like TensorFlow or CNTK in order to simplify tasks. A Keras layer comprises 3 main parts:

1. Input Layer - Which contains the raw data
2. Hidden layer - Where the nodes of a layer learn some aspects about the raw data which is input. It's similar to levels of abstraction to form a Neural network.
3. Output Layer - Consists of a single output which is mostly a single node and can be subjected to classification.

Keras, as a whole consists of many different types of layers. A Convolutional layer creates a kernel which is convoluted with the input over a single temporal space to derive a group of outputs. Pooling layers provide sampling of the feature maps by simplifying features in a map into patches. Max Pooling and Average Pooling are commonly used methods in a Pool layer.

Other commonly used layers in Keras are Embedding layers, Noise layers and Core layers. A single NN layer can represent only a Linearly seperable method. Most prediction problems are complicated and more than just one layer is required. This is where Multi Layer concept is required.

I think i clear your doubts and for any other queries you can see on https://www.tensorflow.org/api_docs/python/tf/keras

Neural networks are a great tool nowadays to automate classification problems. However when it comes to computer vision the amount of input data is too great to be handled efficiently by simple neural networks.

To reduce the network workload, your data needs to be preprocessed and certain features need to be identified. To find features in images we can use certain filters (like sobel edge detection), which will highlight the essential features needed for classification. Again the amount of filters required to classify one image is too great, and thus the selection of those filters needs to be automated.

That's where the convolutional layer comes in.

We use a convolutional layer to generate multiple random (at first) filters that will highlight certain features in an image. While the network is training those filters are optimized to do a better job at highlighting features.

In Tensorflow we use Conv2D() to add one of those layers. An example of parameters is : Conv2D(64, 3, activation='relu'). 64 denotes the number of filters used, 3 denotes the size of the filters (in this case 3x3) and activation='relu' denotes the activation function

After the convolutional layer we use a pooling layer to further highlight the features produced by the previous convolutional layer. In Tensorflow this is usually done with MaxPooling2D() which takes the filtered image and applies a 2x2 (by default) layer every 2 pixels. The filter applied by MaxPooling is basically looking for the maximum value in that 2x2 area and adds it in a new image.

We can use this set of convolutional layer and pooling layers multiple times to make the image easier for the network to work with.

After we are done with those layers, we need to pass the output to a conventional (Dense) neural network.

To do that, we first need to flatten the image data from a 2D Tensor(Matrix) to a 1D Tensor(Vector). This is done by calling the Flatten() method.

Finally we need to add our Dense layers which are used to train on the flattened data. We do this by calling Dense(). An example of parameters is Dense(64, activation='relu') where 64 is the number of nodes we are using.

Here is an example CNN structure I used recently:

# Build model
model = tf.keras.models.Sequential()

# Convolution and pooling layers
model.add(tf.keras.layers.Conv2D(64, 3, activation='relu', input_shape=(IMG_SIZE, IMG_SIZE, 1))) # Input layer
model.add(tf.keras.layers.MaxPooling2D())
model.add(tf.keras.layers.Conv2D(64, 3, activation='relu'))
model.add(tf.keras.layers.MaxPooling2D())

# Flattened layers
model.add(tf.keras.layers.Flatten())
# Dense layers
model.add(tf.keras.layers.Dense(64, activation='relu')) 
model.add(tf.keras.layers.Dense(2, activation='softmax')) # Output layer

Of course this worked for a certain classification problem and the number of layers and method parameters differ depending on the problem.

The Youtube channel The Coding Train has a very helpful video explaining the Convolutional and Pooling layer.