docs: def _init_params(self):
          """Initialize the learned params
  
          - \mu is the primary learned parameter, where each row corresponds to
          the probability of a clique C emitting a specific combination of labels,
          conditioned on different values of Y (for each column); that is:
  
              self.mu[i*self.k + j, y] = P(\lambda_i = j | Y = y)
  
          and similarly for higher-order cliques.
          - Z is the inverse form version of \mu.
          """
          train_config = self.config["train_config"]
  
          # Initialize mu so as to break basic reflective symmetry
          # Note that we are given either a single or per-LF initial precision
          # value, prec_i = P(Y=y|\lf=y), and use:
          #   mu_init = P(\lf=y|Y=y) = P(\lf=y) * prec_i / P(Y=y)
  
          # Handle single or per-LF values
          if isinstance(train_config["prec_init"], (int, float)):
              prec_init = train_config["prec_init"] * torch.ones(self.m)
          else:
              prec_init = torch.from_numpy(train_config["prec_init"])
              if prec_init.shape[0] != self.m:
                  raise ValueError(f"prec_init must have shape {self.m}.")
  
          # Get the per-value labeling propensities
          # Note that self.O must have been computed already!
          lps = torch.diag(self.O).numpy()
  
          # TODO: Update for higher-order cliques!
          self.mu_init = torch.zeros(self.d, self.k)
          for i in range(self.m):
              for y in range(self.k):
                  idx = i * self.k + y
                  mu_init = torch.clamp(lps[idx] * prec_init[i] / self.p[y], 0, 1)
                  self.mu_init[idx, y] += mu_init
  
          # Initialize randomly based on self.mu_init
          self.mu = nn.Parameter(self.mu_init.clone() * np.random.random()).float()
  
          if self.inv_form:
              self.Z = nn.Parameter(torch.randn(self.d, self.k)).float()
  
          # Build the mask over O^{-1}
          # TODO: Put this elsewhere?
          self._build_mask()