Exercise $01$

Instructions: Implement the Siamese function below. You should be using all the functions explained below.

To implement this model, you will be using TensorFlow. Concretely, you will be using the following functions.

tf$.$keras.models.Sequential: groups a linear stack of layers into a tf$.$keras.Model.

You can pass in the layers as arguments to Serial, separated by commas, or simply instantiate the Sequentialmodel and use the add method to add layers.

For example: Sequential$($Embeddings$(...),$ AveragePooling$1$D$(...),$ Dense$(...),$ Softmax$(...))$ or

model $=$ Sequential$()$ model.add$($Embeddings$(...))$ model.add$($AveragePooling$1$D$(...))$ model.add$($Dense$(...))$ model.add$($Softmax$(...))$

tf$.$keras.layers.Embedding : Maps positive integers into vectors of fixed size. It will have shape $($vocabulary length X dimension of output vectors$).$ The dimension of output vectors $($called d$\_$featurein the model$)$ is the number of elements in the word embedding.

Embedding$($input$\_$dim, output$\_$dim$).$

input$\_$dim is the number of unique words in the given vocabulary.

output$\_$dim is the number of elements in the word embedding $($some choices for a word embedding size range from $150$ to $300,$ for example$).$

tf$.$keras.layers.LSTM : The LSTM layer. The number of units should be specified and should match the number of elements in the word embedding.

LSTM$($units$)$ Builds an LSTM layer of n$\_$units.

tf$.$keras.layers.GlobalAveragePooling$1$D : Computes global average pooling, which essentially takes the mean across a desired axis. GlobalAveragePooling$1$D uses one tensor axis to form groups of values and replaces each group with the mean value of that group.

GlobalAveragePooling$1$D$()$ takes the mean.

tf$.$keras.layers.Lambda: Layer with no weights that applies the function f$,$ which should be specified using a lambda syntax. You will use this layer to apply normalization with the function

tfmath.l$2\_$normalize$($x$)$

tf$.$keras.layers.Input: it is used to instantiate a Keras tensor. Remember to set correctly the dimension and type of the input, which are batches of questions. For this, keep in mind that each question is a single string.

Input$($input$\_$shape,dtype$=$None,...$)$

input$\_$shape: Shape tuple $($not including the batch axis$)$

dtype: $($optional$)$ data type of the input

tf$.$keras.layers.Concatenate: Layer that concatenates a list of inputs. This layer will concatenate the normalized outputs of each LSTM into a single output for the model.

Concatenate$()$

# GRADED FUNCTION: Siamese

def Siamese$($text$\_$vectorizer, vocab$\_$size$=36224,$ d$\_$feature$=128)$:

$"""$Returns a Siamese model.

Args:

text$\_$vectorizer $($TextVectorization$)$: TextVectorization instance, already adapted to your training data.

vocab$\_$size $($int$,$ optional$)$: Length of the vocabulary. Defaults to $56400.$

d$\_$model $($int$,$ optional$)$: Depth of the model. Defaults to $128.$

Returns:

tf$.$model.Model: A Siamese model.

$"""$

### START CODE HERE ###

branch $=$ tf$.$keras.models.Sequential$($name$=$'sequential'$)$

# Add the text$\_$vectorizer layer. This is the text$\_$vectorizer you instantiated and trained before

branch.add$($None$)$

# Add the Embedding layer. Remember to call it 'embedding' using the parameter $`$name$`$

branch.add$($None$)$

# Add the LSTM layer, recall from W$2$ that you want to the LSTM layer to return sequences, ot just one value.

# Remember to call it $\text{'}$LSTM$\text{'}$ using the parameter $`$name$`$

branch.add$($None$)$

# Add the GlobalAveragePooling$1$D layer. Remember to call it 'mean' using the parameter $`$name$`$

branch.add$($None$)$

# Add the normalizing layer using the Lambda function. Remember to call it 'out' using the parameter $`$name$`$

branch.add$($None$)$

# Define both inputs. Remember to call then 'input$\_1\text{'}$ and 'input$\_2\text{'}$ using the $`$name$`$ parameter.

# Be mindful of the data type and size

input$1=$ tf$.$keras.layers.Input$($None$,$ dtype$=$None, name$=$'input$\_1\text{'})$

input$2=$ tf$.$keras.layers.Input$($None$,$ dtype$=$None, name$=$'input$\_2\text{'})$

# Define the output of each branch of your Siamese network. Remember that both branches have the same coefficients,

# but they each receive different inputs.

branch$1=$ None

branch$2=$ None

# Define the Concatenate layer. You should concatenate columns, you can fix this using the $`$axis$`$parameter$.$

# This layer is applied over the outputs of each branch of the Siamese network

conc $=$ tf$.$keras.layers.Concatenate$($axis$=$None, name$=$'conc$\_1\_2\text{'})([$None$,$ None$])$

### END CODE HERE ###

return tf$.$keras.models.Model$($inputs$=[$input$1,$ input$2],$ outputs$=$conc, name$=$"SiameseModel"$)$