code: def compute_class_weight(class_weight, classes, y):
      """Estimate class weights for unbalanced datasets.
  
      Parameters
      ----------
      class_weight : dict, 'balanced' or None
          If 'balanced', class weights will be given by
          ``n_samples / (n_classes * np.bincount(y))``.
          If a dictionary is given, keys are classes and values
          are corresponding class weights.
          If None is given, the class weights will be uniform.
  
      classes : ndarray
          Array of the classes occurring in the data, as given by
          ``np.unique(y_org)`` with ``y_org`` the original class labels.
  
      y : array-like, shape (n_samples,)
          Array of original class labels per sample;
  
      Returns
      -------
      class_weight_vect : ndarray, shape (n_classes,)
          Array with class_weight_vect[i] the weight for i-th class
  
      References
      ----------
      The "balanced" heuristic is inspired by
      Logistic Regression in Rare Events Data, King, Zen, 2001.
      """
      # Import error caused by circular imports.
      from ..preprocessing import LabelEncoder
  
      if set(y) - set(classes):
          raise ValueError(
              "classes should include all valid labels that can "
              "be in y"
          )
      if class_weight is None or len(class_weight) == 0:
          # uniform class weights
          weight = np.ones(
              classes.shape[0], dtype=np.float64, order="C"
          )
      elif class_weight in ["auto", "balanced"]:
          # Find the weight of each class as present in y.
          le = LabelEncoder()
          y_ind = le.fit_transform(y)
          if not all(np.in1d(classes, le.classes_)):
              raise ValueError(
                  "classes should have valid labels that are in y"
              )
  
          # inversely proportional to the number of samples in the class
          if class_weight == "auto":
              recip_freq = 1.0 / bincount(y_ind)
              weight = recip_freq[le.transform(classes)] / np.mean(
                  recip_freq
              )
              warnings.warn(
                  "The class_weight='auto' heuristic is deprecated in"
                  " 0.17 in favor of a new heuristic "
                  "class_weight='balanced'. 'auto' will be removed in"
                  " 0.19",
                  DeprecationWarning,
              )
          else:
              recip_freq = len(y) / (
                  len(le.classes_) * bincount(y_ind).astype(np.float64)
              )
              weight = recip_freq[le.transform(classes)]
      else:
          # user-defined dictionary
          weight = np.ones(
              classes.shape[0], dtype=np.float64, order="C"
          )
          if not isinstance(class_weight, dict):
              raise ValueError(
                  "class_weight must be dict, 'balanced', or None,"
                  " got: %r" % class_weight
              )
          for c in class_weight:
              i = np.searchsorted(classes, c)
              if i >= len(classes) or classes[i] != c:
                  raise ValueError("Class label %d not present." % c)
              else:
                  weight[i] = class_weight[c]
  
      return weight
  
imports: import warnings
  import numpy
  from ..externals import six
  from ..utils.fixes import in1d
  from .fixes import bincount
label_desc: Use image node_id 1 for calling a global function with example usage: compute_class_weight(class_weight, classes, y) and returns: weight