code: def ln_structured(
      module, name, amount, n, dim, importance_scores=None
  ):
      r"""Prune tensor by removing channels with the lowest L\ ``n``-norm along the specified dimension.
  
      Prunes tensor corresponding to parameter called ``name`` in ``module``
      by removing the specified ``amount`` of (currently unpruned) channels
      along the specified ``dim`` with the lowest L\ ``n``-norm.
      Modifies module in place (and also return the modified module)
      by:
  
      1) adding a named buffer called ``name+'_mask'`` corresponding to the
         binary mask applied to the parameter ``name`` by the pruning method.
      2) replacing the parameter ``name`` by its pruned version, while the
         original (unpruned) parameter is stored in a new parameter named
         ``name+'_orig'``.
  
      Args:
          module (nn.Module): module containing the tensor to prune
          name (str): parameter name within ``module`` on which pruning
                  will act.
          amount (int or float): quantity of parameters to prune.
              If ``float``, should be between 0.0 and 1.0 and represent the
              fraction of parameters to prune. If ``int``, it represents the
              absolute number of parameters to prune.
          n (int, float, inf, -inf, 'fro', 'nuc'): See documentation of valid
              entries for argument ``p`` in :func:`torch.norm`.
          dim (int): index of the dim along which we define channels to prune.
          importance_scores (torch.Tensor): tensor of importance scores (of same
              shape as module parameter) used to compute mask for pruning.
              The values in this tensor indicate the importance of the corresponding
              elements in the parameter being pruned.
              If unspecified or None, the module parameter will be used in its place.
  
      Returns:
          module (nn.Module): modified (i.e. pruned) version of the input module
  
      Examples:
          >>> from torch.nn.utils import prune
          >>> m = prune.ln_structured(
          ...     nn.Conv2d(5, 3, 2), 'weight', amount=0.3, dim=1, n=float('-inf')
          ... )
      """
      LnStructured.apply(
          module,
          name,
          amount,
          n,
          dim,
          importance_scores=importance_scores,
      )
      return module
  
imports: import numbers
  from abc import ABC, abstractmethod
  from collections.abc import Iterable
  from typing import Tuple
  import torch
label_desc: Use image node_id 5 for calling a global function with example usage: ln_structured(module, name, amount, n, dim, importance_scores) and returns: module