class_docstr: Creates a one-hot encoding (OHE) for categorical data. One-hot encoding represents categorical information as a vector where each individual dimension corresponds to a category. A category has a 1:1 mapping between dimension indicated by a "1" in that position. For example, imagine 3 categories, :math:`A`, :math:`B`, and :math:`C`; these can be represented as follows:
  
  .. math::
  
     A &= [1, 0, 0] \
     B &= [0, 1, 0] \
     C &= [0, 0, 1]
  
  The OHE encoder operates in 2 modes:
      (1) "use_unknown=True": Makes an :math:`N+1` length vector for :math:`N` categories, the first index always corresponds to the unknown category.
  
      (2) "use_unknown=False": Makes an :math:`N` length vector for :math:`N` categories, where an empty vector of 0s indicates an unknown/missing category.
  
  An encoder can represent a feature column or target column; in this case it represents a target, `is_target` is `True`, and `target_weights`. The `target_weights` parameter enables users to specify how heavily each class should be weighted within a mixer - useful in imbalanced classes.
  
  By default, `dataprep_ml.StatisticalAnalysis` phase will provide `target_weights` as the relative fraction of each class in the data which is important for imbalanced populations; for example, suppose there is a 80/05/15 imbalanced representation across 3 different classes - `target_weights` will be a vector as such::
  
  target_weights = {"class1": 0.8, "class2": 0.05, "class3": 0.15}
  
  Users should note that models will be presented with the inverse of the target weights, `inv_target_weights`, which will perform the 1/target_value_per_class operation. **This means large values will result in small weights for the model**.
docstr: Prepares the OHE Encoder by creating a dictionary mapping.
  
  Unknown categories must be explicitly handled as python `None` types.
docstr_tok: ["Prepares","the","OHE","Encoder","by","creating","a","dictionary","mapping",".","Unknown","categories","must","be","explicitly","handled","as","python","`","None","`","types","."]
code: def prepare(self, priming_data: Iterable[str]):
      """
      Prepares the OHE Encoder by creating a dictionary mapping.
  
      Unknown categories must be explicitly handled as python `None` types.
      """  # noqa
      if self.is_prepared:
          raise Exception(
              'You can only call "prepare" once for a given encoder.'
          )
  
      unq_cats = np.unique(
          [i for i in priming_data if i is not None]
      ).tolist()
  
      if self.use_unknown:
          log.debug("Encoding UNKNOWN categories as index 0")
          self.map = {
              cat: indx + 1 for indx, cat in enumerate(unq_cats)
          }
          self.map.update({_UNCOMMON_WORD: 0})
          self.rev_map = {indx: cat for cat, indx in self.map.items()}
      else:
          log.debug("Encoding UNKNOWN categories as vector of all 0s")
          self.map = {cat: indx for indx, cat in enumerate(unq_cats)}
          self.rev_map = {indx: cat for cat, indx in self.map.items()}
  
      # Set the length of output
      self.output_size = len(self.map)
  
      # For target-only, report on relative weights of classes
      # Each dimension of the inv_target_weights respects `map`
      if self.is_target:
          # Equally wt. all classes
          self.index_weights = torch.ones(size=(self.output_size,))
  
          # If imbalanced detected, weight by inverse
          if self.target_weights is not None:
              # Check target weights properly specified
              if (
                  sum(
                      [
                          np.isclose(i, 0)
                          for i in self.target_weights.values()
                      ]
                  )
                  > 0
              ):
                  raise ValueError("Target weights cannot be 0")
  
              for cat in self.map.keys():
                  if cat != _UNCOMMON_WORD:
                      self.index_weights[
                          self.map[cat]
                      ] = self.target_weights[cat]
  
              # If using an unknown category, set to smallest possible value
              if self.use_unknown:
                  self.target_weights[_UNCOMMON_WORD] = np.min(
                      list(self.target_weights.values())
                  )
                  self.index_weights[0] = self.target_weights[
                      _UNCOMMON_WORD
                  ]
  
      self.is_prepared = True
  
file_path: lightwood/lightwood/encoder/categorical/onehot.py
imports: from copy import deepcopy
  from typing import Dict, List, Iterable, Tuple
  import torch
  import numpy
  from scipy.special import softmax
  from lightwood.helpers.log import log
  from lightwood.encoder.base import BaseEncoder
  from lightwood.helpers.constants import _UNCOMMON_WORD
label_desc: Use image node_id 2 for calling the OneHotEncoder obj's underlying member method code with example usage: obj.prepare(priming_data) without return types