code: def compute_sample_weight(class_weight, y, *, indices=None):
      """Estimate sample weights by class for unbalanced datasets.
  
      Parameters
      ----------
      class_weight : dict, list of dicts, "balanced", or None
          Weights associated with classes in the form `{class_label: weight}`.
          If not given, all classes are supposed to have weight one. For
          multi-output problems, a list of dicts can be provided in the same
          order as the columns of y.
  
          Note that for multioutput (including multilabel) weights should be
          defined for each class of every column in its own dict. For example,
          for four-class multilabel classification weights should be
          `[{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}]` instead of
          `[{1:1}, {2:5}, {3:1}, {4:1}]`.
  
          The `"balanced"` mode uses the values of y to automatically adjust
          weights inversely proportional to class frequencies in the input data:
          `n_samples / (n_classes * np.bincount(y))`.
  
          For multi-output, the weights of each column of y will be multiplied.
  
      y : {array-like, sparse matrix} of shape (n_samples,) or (n_samples, n_outputs)
          Array of original class labels per sample.
  
      indices : array-like of shape (n_subsample,), default=None
          Array of indices to be used in a subsample. Can be of length less than
          `n_samples` in the case of a subsample, or equal to `n_samples` in the
          case of a bootstrap subsample with repeated indices. If `None`, the
          sample weight will be calculated over the full sample. Only `"balanced"`
          is supported for `class_weight` if this is provided.
  
      Returns
      -------
      sample_weight_vect : ndarray of shape (n_samples,)
          Array with sample weights as applied to the original `y`.
  
      Examples
      --------
      >>> from sklearn.utils.class_weight import compute_sample_weight
      >>> y = [1, 1, 1, 1, 0, 0]
      >>> compute_sample_weight(class_weight="balanced", y=y)
      array([0.75, 0.75, 0.75, 0.75, 1.5 , 1.5 ])
      """
  
      # Ensure y is 2D. Sparse matrices are already 2D.
      if not sparse.issparse(y):
          y = np.atleast_1d(y)
          if y.ndim == 1:
              y = np.reshape(y, (-1, 1))
      n_outputs = y.shape[1]
  
      if indices is not None and class_weight != "balanced":
          raise ValueError(
              "The only valid class_weight for subsampling is 'balanced'. "
              f"Given {class_weight}."
          )
      elif n_outputs > 1:
          if class_weight is None or isinstance(class_weight, dict):
              raise ValueError(
                  "For multi-output, class_weight should be a list of dicts, or the "
                  "string 'balanced'."
              )
          elif (
              isinstance(class_weight, list)
              and len(class_weight) != n_outputs
          ):
              raise ValueError(
                  "For multi-output, number of elements in class_weight should match "
                  f"number of outputs. Got {len(class_weight)} element(s) while having "
                  f"{n_outputs} outputs."
              )
  
      expanded_class_weight = []
      for k in range(n_outputs):
          if sparse.issparse(y):
              # Ok to densify a single column at a time
              y_full = y[:, [k]].toarray().flatten()
          else:
              y_full = y[:, k]
          classes_full = np.unique(y_full)
          classes_missing = None
  
          if class_weight == "balanced" or n_outputs == 1:
              class_weight_k = class_weight
          else:
              class_weight_k = class_weight[k]
  
          if indices is not None:
              # Get class weights for the subsample, covering all classes in
              # case some labels that were present in the original data are
              # missing from the sample.
              y_subsample = y_full[indices]
              classes_subsample = np.unique(y_subsample)
  
              weight_k = np.take(
                  compute_class_weight(
                      class_weight_k,
                      classes=classes_subsample,
                      y=y_subsample,
                  ),
                  np.searchsorted(classes_subsample, classes_full),
                  mode="clip",
              )
  
              classes_missing = set(classes_full) - set(
                  classes_subsample
              )
          else:
              weight_k = compute_class_weight(
                  class_weight_k, classes=classes_full, y=y_full
              )
  
          weight_k = weight_k[np.searchsorted(classes_full, y_full)]
  
          if classes_missing:
              # Make missing classes' weight zero
              weight_k[np.isin(y_full, list(classes_missing))] = 0.0
  
          expanded_class_weight.append(weight_k)
  
      expanded_class_weight = np.prod(
          expanded_class_weight, axis=0, dtype=np.float64
      )
  
      return expanded_class_weight
  
imports: import numpy
  from scipy import sparse
  from ._param_validation import StrOptions, validate_params
label_desc: Use image node_id 2 for calling a global function with example usage: compute_sample_weight(class_weight, y) and returns: expanded_class_weight