'str' object has no attribute '_keras_mask' error when using tf.keras.Sequential

I solved this problem by fixing the following areas of my code

1. Converting wine_train to a Tensorflow format

When I posted this question I had already tried running tf.data.Dataset.from_tensor_slices on my pandas dataframe. However it will not work. Instead convert the dataframe to a dictionary as so: wine_features_dict = {name: np.array(value) for name, value in wine_train.items()} and then everything runs smoothly.

1. Tensorflow is very sensitive to missing or NaN values.

I thought I got everything but just dropping all rows with any missing data seemed to get rid of the error. If it's happening to you make sure that there is no missing data and all your data is either integer or string.

Edited 13 Oct 2021:

Adding the full solution below - as requested

We want to convert data into a tf dictionary

wine_features_dict = {name: np.array(value) for name, value in wine_train.items()}

import itertools

def slices(features):
  for i in itertools.count():
    # For each feature take index `i`
    example = {name:values[i] for name, values in features.items()}
    yield example

for example in slices(wine_features_dict):
  for name, value in example.items():
    print(f"{name:19s}: {value}")
  break

create features_ds

features_ds = tf.data.Dataset.from_tensor_slices(wine_features_dict)

for example in features_ds:
  for name, value in example.items():
    print(f"{name:19s}: {value}")
  break

which yields

country            : b'Portugal'
description        : b"This is ripe and fruity, a wine that is smooth while still structured. Firm tannins are filled out with juicy red berry fruits and freshened with acidity. It's  already drinkable, although it will certainly be better from 2016."
points             : 87.0
price              : 15.0
province           : b'Douro'
title              : b'Quinta dos Avidagos 2011 Avidagos Red (Douro)'
variety            : b'Portuguese Red'
winery             : b'Quinta dos Avidagos'
designation_replace: b'Avidagos'
user_id            : b'15'
price_isna         : False
price_imputed      : 15.0
wine_id            : 1

Preprocessing and other stuff

Between this and the actual model definition there are a bunch of things too lengthy for a SlackOverflow post. Essentially we are going to create embeddings for categorical variables and normalize or discretize continuous features. I added timestamps that I also had to preprocess. Word embeddings for text and then combine them

wine titles, user_ids -> vocabularies -> embeddings

price, price imputed -> normalize or discretize (bucket) -> embed buckets

words -> tokenization (splitting into constituent words or word-pieces), followed by vocabulary learning, followed by an embedding.

timestamps -> bucket based on max and min -> embed buckets

Next I explicitly defined the training inputs

inputs = {}

for name, column in wine_train.items():
  dtype = column.dtype
  if dtype == object:
    dtype = tf.string
  else:
    dtype = tf.float32

  inputs[name] = tf.keras.Input(shape=(1,), name=name, dtype=dtype)

and then the model

class UserModel(tf.keras.Model):
  
  def __init__(self, use_timestamps=False, use_country_origin=False):
    super().__init__()

    self._use_timestamps = use_timestamps
    self._use_country_origin = use_country_origin

    self.user_embedding = tf.keras.Sequential([
        tf.keras.layers.experimental.preprocessing.StringLookup(
            vocabulary=unique_user_ids, mask_token=None),
        tf.keras.layers.Embedding(len(unique_user_ids) + 1, 32),
    ])   

    '''
    # Can also do this if user_id_lookup is defined 
    self.user_embedding = tf.keras.Sequential([
        user_id_lookup,
        tf.keras.layers.Embedding(user_id_lookup.vocab_size(), 32),
    ])
    '''
    if use_country_origin:
      self.country_embedding = tf.keras.Sequential([
          tf.keras.layers.experimental.preprocessing.StringLookup(
              vocabulary=unique_countries, mask_token=None),
          tf.keras.layers.Embedding(len(unique_countries) + 1, 32),                                                   
      ])      
    
    if use_timestamps:
      self.timestamp_embedding = tf.keras.Sequential([
        tf.keras.layers.experimental.preprocessing.Discretization(timestamp_buckets.tolist()),
        tf.keras.layers.Embedding(len(timestamp_buckets) + 2, 32)
      ])
      self.normalized_timestamp = tf.keras.layers.experimental.preprocessing.Normalization()

      self.normalized_timestamp.adapt(timestamps)
    
    
  def call(self, inputs):

    # If timestamps not active just do the user_id embedding

    if not self._use_timestamps:
      
      # Ignore country of origin if is not enabled 
      if not self._use_country_origin:
        return self.user_embedding(inputs['user_id'])
      
      return tf.concat([
        self.user_embedding(inputs["user_id"]),
        self.country_embedding(inputs["country"]),                        
      ], axis=1)

    # Take the input dictionary, pass it through each input layer,
    # and concatenate the result.
    if not self._use_country_origin:
      return tf.concat([
          self.user_embedding(inputs["user_id"]),
          self.timestamp_embedding(inputs["timestamp"]),
          self.normalized_timestamp(inputs["timestamp"]),           
      ], axis=1)

    return tf.concat([        
        self.user_embedding(inputs["user_id"]),
        self.timestamp_embedding(inputs["timestamp"]),
        self.normalized_timestamp(inputs["timestamp"]),
        self.country_embedding(inputs["country"]),
    ], axis=1)
    

we can call it as well

user_model = UserModel()

# Delete quotes if timestamps are available 
'''user_model.normalized_timestamp.adapt(
    ratings.map(lambda x: x["timestamp"]).batch(128))
'''
for row in features_ds.batch(1).take(1):
  print(f"Computed representations: {user_model(row)[0, :3]}")