code: def process_unlabeled(path, trained_model, ignore_columns=None):
      """Creates a dataset object for an unlabeled dataset.
  
      Args:
          path (string):
              The full path to the unlabeled data file (not just the directory).
          trained_model (:class:`~deepmatcher.MatchingModel`):
              The trained model. The model is aware of the configuration of the training
              data on which it was trained, and so this method reuses the same
              configuration for the unlabeled data.
          ignore_columns (list):
              A list of columns to ignore in the unlabeled CSV file.
      """
      with io.open(path, encoding="utf8") as f:
          header = next(unicode_csv_reader(f))
  
      train_info = trained_model.meta
      if ignore_columns is None:
          ignore_columns = train_info.ignore_columns
      column_naming = dict(train_info.column_naming)
      column_naming["label"] = None
  
      fields = _make_fields(
          header,
          column_naming["id"],
          column_naming["label"],
          ignore_columns,
          train_info.lowercase,
          train_info.tokenize,
          train_info.include_lengths,
      )
  
      begin = timer()
      dataset_args = {"fields": fields, "column_naming": column_naming}
      dataset = MatchingDataset(path=path, **dataset_args)
  
      # Make sure we have the same attributes.
      assert set(dataset.all_text_fields) == set(
          train_info.all_text_fields
      )
  
      after_load = timer()
      logger.info("Data load time: {}s".format(after_load - begin))
  
      reverse_fields_dict = dict((pair[1], pair[0]) for pair in fields)
      for field, name in reverse_fields_dict.items():
          if field is not None and field.use_vocab:
              # Copy over vocab from original train data.
              field.vocab = copy.deepcopy(train_info.vocabs[name])
              # Then extend the vocab.
              field.extend_vocab(
                  dataset,
                  vectors=train_info.embeddings,
                  cache=train_info.embeddings_cache,
              )
  
      dataset.vocabs = {
          name: dataset.fields[name].vocab
          for name in train_info.all_text_fields
      }
  
      after_vocab = timer()
      logger.info(
          "Vocab update time: {}s".format(after_vocab - after_load)
      )
  
      return dataset
  
file_path: deepmatcher/deepmatcher/data/process.py
imports: import copy
  import io
  import logging
  import os
  from timeit import default_timer
  import six
  from torchtext.utils import unicode_csv_reader
  from .dataset import MatchingDataset
  from .field import MatchingField
label_desc: Use image node_id 5 for calling a global function with example usage: process_unlabeled(path, trained_model, ignore_columns) and returns: dataset