I studied the example given by the tensor flow documentation 2 for the movielens dataset but then never explained how to handle boolean and array data types and how to create embedding for them.
So I have written some code but not able to understand where I am wrong
import numpy as np
from math import ceil

import tensorflow as tf
from tensorflow_datasets.core import download

import tensorflow_recommenders as tfrs
import tensorflow_datasets as tfds

tf.autograph.set_verbosity(10)
tf.get_logger().setLevel('CRITICAL')


class DCN(tfrs.Model):

    def __init__(self, use_cross_layer, deep_layer_sizes, datainfo, projection_dim=None):
        super().__init__()

        self.embedding_dimension = 32

        self._all_features = datainfo['all_features']
        self._embeddings = {}

        # Compute embeddings for string features.
        for feature_name in datainfo['str_features']:
            vocabulary = datainfo['vocabularies'][feature_name]
            self._embeddings[feature_name] = tf.keras.Sequential([
                tf.keras.layers.experimental.preprocessing.StringLookup(
                    vocabulary=vocabulary, mask_token=None),
                tf.keras.layers.Embedding(
                    len(vocabulary) + 1, self.embedding_dimension)
            ], name=feature_name)

        for feature_name in datainfo['int_lookup_feature']+datainfo['list_features']:
            vocabulary = datainfo['vocabularies'][feature_name]
            self._embeddings[feature_name] = tf.keras.Sequential([
                tf.keras.layers.experimental.preprocessing.IntegerLookup(
                    vocabulary=vocabulary, mask_token=None),
                tf.keras.layers.Embedding(
                    len(vocabulary) + 1, self.embedding_dimension)
            ], name=feature_name)

        for feature_name in datainfo['bool_features']:
            self._embeddings[feature_name] = tf.keras.Sequential([
                tf.keras.layers.Activation('relu'),
                tf.keras.layers.Dense(units=1)
            ], name=feature_name)

        if use_cross_layer:
            self._cross_layer = tfrs.layers.dcn.Cross(
                projection_dim=projection_dim,
                kernel_initializer="glorot_uniform")
        else:
            self._cross_layer = None

        self._deep_layers = [tf.keras.layers.Dense(layer_size, activation="relu")
                             for layer_size in deep_layer_sizes]

        self._logit_layer = tf.keras.layers.Dense(1)

        self.task = tfrs.tasks.Ranking(
            loss=tf.keras.losses.MeanSquaredError(),
            metrics=[tf.keras.metrics.RootMeanSquaredError("RMSE")]
        )

    def call(self, features):
        # Concatenate embeddings
        embeddings = []
        for feature_name in self._all_features:
            embedding_fn = self._embeddings.get(feature_name, None)
            if embedding_fn is not None:
                embeddings.append(embedding_fn(features[feature_name]))

        x = tf.concat(embeddings, axis=1)

        # Build Cross Network
        if self._cross_layer is not None:
            x = self._cross_layer(x)

        # Build Deep Network
        for deep_layer in self._deep_layers:
            x = deep_layer(x)

        return self._logit_layer(x)

    def compute_loss(self, features, training=False):
        labels = features.pop("user_rating")
        scores = self(features)
        return self.task(
            labels=labels,
            predictions=scores,
        )


def main():
    tf.random.set_seed(42)
    ds = tfds.load("movie_lens/100k-ratings", split="train")
    ds = ds.map(lambda x: {
        "movie_id": x["movie_id"],
        "user_id": x["user_id"],
        "user_rating": x["user_rating"],
        "user_gender": int(x["user_gender"]),
        "user_zip_code": x["user_zip_code"],
        "user_occupation_text": x["user_occupation_text"],
        "bucketized_user_age": int(x["bucketized_user_age"]),
        "movie_genres": x["movie_genres"],
    })
    dataLen = len(ds)
    trainLen = ceil(dataLen*0.8)
    testLen = dataLen - trainLen
    shuffled = ds.shuffle(100, reshuffle_each_iteration=False)

    str_features = ["movie_id", "user_id",
                    "user_zip_code", "user_occupation_text"]
    int_lookup_feature = ["bucketized_user_age"]
    list_features = ["movie_genres"]
    bool_features = ["user_gender"]

    all_features = str_features + \
        bool_features + list_features + int_lookup_feature
    vocabularies = {}
    dataValues = {}

    for feature_name in str_features+int_lookup_feature:
        vocab = shuffled.map(lambda x: x[feature_name])
        vocabularies[feature_name] = np.unique(
            [i.numpy() for i in list(vocab)]).tolist()

    for feature_name in list_features:
        vocab = shuffled.map(lambda x: x[feature_name])
        vocabularies[feature_name] = np.unique(
            np.concatenate(list(vocab))).tolist()

    datainfo = {
        'all_features': all_features,
        'str_features': str_features,
        'list_features': list_features,
        'int_lookup_feature': int_lookup_feature,
        'bool_features': bool_features,
        'vocabularies': vocabularies,
        'dataValues': dataValues
    }

    train = shuffled.take(trainLen)
    test = shuffled.skip(trainLen).take(testLen)

    cached_train = train.shuffle(100_000).batch(8192).cache()
    cached_test = test.batch(4096).cache()

    epochs = 8
    learning_rate = 0.01
    use_cross_layer = True
    deep_layer_sizes = [192, 192]
    projection_dim = None

    model = DCN(use_cross_layer=use_cross_layer,
                deep_layer_sizes=deep_layer_sizes,
                projection_dim=projection_dim,
                datainfo=datainfo)
    model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate))
    model.fit(cached_train, epochs=epochs, verbose=True)
    metrics = model.evaluate(cached_test, return_dict=True)

    print(metrics)


main()

It is giving me the wrong dimensions error in my layers but I could not figure out which layer.