human
I am working on the file "CarND-Traffic-Sign-Classifier-P2/Traffic_Sign_ClassifierCIfar10.ipynb".
The first task is:
9. Model Architecture

| Layer         |     Description                               |  Input            |  Output                     |
|:-------------:|:---------------------------------------------:|:-----------------:|:---------------------------:| 
| Input         | 32x32x1 Grayscale image                       | Image             | Convolution 1               |
| Convolution 1 | 1x1 stride, valid padding, outputs 28x28x100  | Input             | RELU                        |
| RELU 1        |                                               | Convolution 1     | Max Pooling 1               |
| Max pooling 1 | 2x2 stride,  outputs 14x14x100                | RELU 1            | Convolution 2, Max Pooling 3|
| Convolution 2 | 1x1 stride, valid padding, outputs 10x10x200  | Max pooling 1     | RELU 2                      |
| RELU 2        |                                               | Convolution 2     | Max pooling 2               |
| Max pooling 2 | 2x2 stride,  outputs 5x5x200                  | RELU 2            | Flatten 2                   |
| Max pooling 3 | 2x2 stride,  outputs 7x7x100                  | Max pooling 1     | Flatten 1                   |
| Flatten 1     | Input = 7x7x100, Output = 4900                | Max pooling 3     | Concatenate 1               |
| Flatten 2     | Input = 5x5x200, Output = 5000                | Max pooling 2     | Concatenate 1               |
| Concatenate 1 | Input1 = 4900, Input1 = 5000, Output = 9900   | Max pooling 2 and 3 |Fully connected            |
| Fully connected | Fully Connected. Input = 9900, Output = 100 | Concatenate 1     | Dropout                     |
| Dropout       | Keep prob = 0.75                           | Fully connected   | Softmax                     |
| Softmax       | Fully Connected. Input = 100, Output = 43     | Dropout           | Probabilities               |
Can you write Python program for it?
assistant
#Here is the Python program you requested.

import tensorflow as tf

from tensorflow.contrib.layers import flatten

def model(x, keep_prob):    
    # Arguments used for tf.truncated_normal, randomly defines variables for the weights and biases for each layer
    mu = 0
    sigma = 0.1
    
    # Network Parameters
    n_classes = 10  # MNIST total classes (0-9 digits)
    filter_size = 5
    

    # Store layers weight & bias
    weights = {
        'wc1' : tf.Variable(tf.truncated_normal([filter_size, filter_size, 1, 100], mean = mu, stddev = sigma)),
        'wc2' : tf.Variable(tf.truncated_normal([filter_size, filter_size, 100, 200], mean = mu, stddev = sigma)),
        'wfc1': tf.Variable(tf.truncated_normal([9900, 100], mean = mu, stddev = sigma)),
        'out' : tf.Variable(tf.truncated_normal([100, n_classes], mean = mu, stddev = sigma))}

    biases = {
        'bc1' : tf.Variable(tf.zeros([100])),
        'bc2' : tf.Variable(tf.zeros([200])),
        'bfc1': tf.Variable(tf.zeros([100])),
        'out' : tf.Variable(tf.zeros([n_classes]))}

    def conv2d(x, W, b, strides=1., padding='SAME'):
        x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding=padding)
        x = tf.nn.bias_add(x, b)
        return tf.nn.relu(x)

    def maxpool2d(x, k=2, padding='SAME'):
        return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding=padding)

    # Layer 1: Convolution 1 - 32*32*1 to 28*28*100
    conv1 = conv2d(x, weights['wc1'], biases['bc1'], padding='VALID')
    # Max Pool - 28*28*100 to 14*14*100
    conv1 = maxpool2d(conv1, k=2)

    # Layer 2: Convolution 2 - 14*14*100 to 10*10*200
    conv2 = conv2d(conv1, weights['wc2'], biases['bc2'], padding='VALID')
    # Max Pool - 10*10*200 to 5*5*200
    conv2 = maxpool2d(conv2, k=2)
    
    #Fork second max pool - 14*14*100 to 7*7*100
    conv1 = maxpool2d(conv1, k=2)
    
    #Flatten conv1. Input = 7*7*100, Output = 4900
    conv1 = tf.contrib.layers.flatten(conv1)

    # Flatten conv2. Input = 5x5x200. Output = 5000.
    conv2 = tf.contrib.layers.flatten(conv2)
 ...