code: def _get_type_vector(worlds: List[WikiTablesWorld],
                           num_entities: int,
                           tensor: torch.Tensor) -> Tuple[torch.LongTensor, Dict[int, int]]:
          
          entity_types = {}
          batch_types = []
          for batch_index, world in enumerate(worlds):
              types = []
              for entity_index, entity in enumerate(world.table_graph.entities):
                  # We need numbers to be first, then cells, then parts, then row, because our
                  # entities are going to be sorted.  We do a split by type and then a merge later,
                  # and it relies on this sorting.
                  if entity.startswith('fb:cell'):
                      entity_type = 1
                  elif entity.startswith('fb:part'):
                      entity_type = 2
                  elif entity.startswith('fb:row'):
                      entity_type = 3
                  else:
                      entity_type = 0
                  types.append(entity_type)
  
                  # For easier lookups later, we're actually using a _flattened_ version
                  # of (batch_index, entity_index) for the key, because this is how the
                  # linking scores are stored.
                  flattened_entity_index = batch_index * num_entities + entity_index
                  entity_types[flattened_entity_index] = entity_type
              padded = pad_sequence_to_length(types, num_entities, lambda: 0)
              batch_types.append(padded)
          return tensor.new_tensor(batch_types, dtype=torch.long), entity_types
docs: Produces a tensor with shape ``(batch_size, num_entities)`` that encodes each entity's
          type. In addition, a map from a flattened entity index to type is returned to combine
          entity type operations into one method.
  
          Parameters
          ----------
          worlds : ``List[WikiTablesWorld]``
          num_entities : ``int``
          tensor : ``torch.Tensor``
              Used for copying the constructed list onto the right device.
  
          Returns
          -------
          A ``torch.LongTensor`` with shape ``(batch_size, num_entities)``.
          entity_types : ``Dict[int, int]``
              This is a mapping from ((batch_index * num_entities) + entity_index) to entity type id.