class_docstr: Scenario for the entity data imputation task.
  
  This scenario supports the Restaurant and Buy datasets from
  https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=9458712. We process the datasets
  as explained in the paper: remove all rows with NaN values and manually select 10% of the rows
  to serve as a test set. A categorical column from this set will be imputed. 20% of the remaining data
  is validation data.
  
  Entity data imputation is a core preprocessing step in structured data ETL pipelines. The task
  is as follows. Given a structured relation A with possible incomplete/NaN call values,
  determine what value should be used to fill in the cell. This task has traditionally relied
  on relational dependencies (e.g., if city = 'San Francisco' then state = 'CA') to infer missing
  values or some ML model trained to learn dependencies between cell values.
  
  An example is
  
      Input: title: adobe creative suite cs3 design premium upsell [ mac ] | price: 1599.0 | manufacturer:
  
  Reference [CORRECT]: adobe
  
  The above example highlights the model will need to reason over input titles and possibly external
  knowledge (e.g. that creative suite is from adobe) to generate the answer.
code: def get_instances(self) -> List[Instance]:
      data_path = Path(self.output_path) / "data" / self.dataset
      data_path.parent.mkdir(parents=True, exist_ok=True)
      ensure_file_downloaded(
          source_url=self.datasets_paths[self.dataset],
          target_path=str(data_path),
          unpack=True,
      )
      # Read in structured table
      table = self.read_tables(data_path)
      # Get train, valid, test splits
      train, valid, test = self.get_splits(table)
      col_to_impute = self.datasets_impute_col[self.dataset]
      columns_for_serialize = [
          c for c in train.columns if c != col_to_impute
      ]
      all_splits = {
          TRAIN_SPLIT: train,
          VALID_SPLIT: valid,
          TEST_SPLIT: test,
      }
      # Read all the instances
      instances: List[Instance] = []
  
      for split, example_df in all_splits.items():
          hlog(f"Processing {split} with {example_df.shape[0]} rows")
          for _, row in example_df.iterrows():
              res: str = self.serialize_row(row, columns_for_serialize)
              input: str = f"{res}. {col_to_impute}?"
              label = str(row[col_to_impute])
              instance = Instance(
                  Input(text=input),
                  references=[
                      Reference(Output(text=label), tags=[CORRECT_TAG])
                  ],
                  split=split,
              )
              instances.append(instance)
  
      return instances
  
file_path: H2O/h2o_hf/helm/src/helm/benchmark/scenarios/entity_data_imputation_scenario.py
imports: from io import StringIO
  import pandas
  from pathlib import Path
  from typing import List, Tuple
  from helm.common.hierarchical_logger import hlog
  from helm.common.general import ensure_file_downloaded
  from .scenario import Scenario, Instance, Reference, TRAIN_SPLIT, VALID_SPLIT, TEST_SPLIT, CORRECT_TAG, Input, Output
label_desc: Use image node_id 5 for calling the EntityDataImputationScenario obj's underlying member method code with example usage: obj.get_instances() and returns: instances