class_docstr: The implementation of the prototypical verbalizer in `Prototypical Verbalizer for Prompt-based Few-shot Tuning <https://arxiv.org/pdf/2104.08691v1.pdf>`_ This class is inherited from the :obj:`Verbalizer` class.
  
  Args:
      tokenizer (:obj:`PreTrainedTokenizer`): The tokenizer of the current pre-trained model to point out the vocabulary.
      classes (:obj:`List[Any]`): The classes (or labels) of the current task.
      label_words (:obj:`Union[List[str], List[List[str]], Dict[List[str]]]`, optional): The label words that are projected by the labels.
      prefix (:obj:`str`, optional): The prefix string of the verbalizer (used in PLMs like RoBERTa, which is sensitive to prefix space)
      multi_token_handler (:obj:`str`, optional): The handling strategy for multiple tokens produced by the tokenizer.
      post_log_softmax (:obj:`bool`, optional): Whether to apply log softmax post processing on label_logits. Default to True.
      lr: (:obj:`float`, optional): The learning rate for prototypes.
      mid_dim: (:obj:`int`, optional): The dimension of prototype embeddings.
      epochs: (:obj:`int`, optional): The training epochs of prototypes.
      multi_verb (:obj:`str`, optional): `multi` to ensemble with manual verbalizers, `proto` to use only ProtoVerb.
code: def train_proto(self, model, dataloader, device):
      model.eval()
      embeds = [[] for _ in range(self.num_classes)]
      with torch.no_grad():
          for i, batch in enumerate(dataloader):
              batch = batch.to("cuda:{}".format(device)).to_dict()
              outputs = model.prompt_model(batch)
              hidden, _ = self.gather_outputs(outputs)
              outputs_at_mask = model.extract_at_mask(hidden, batch)
              for j in range(len(outputs_at_mask)):
                  label = batch["label"][j]
                  embeds[label].append(outputs_at_mask[j])
      embeds = [torch.stack(e) for e in embeds]
      embeds = torch.stack(embeds)
  
      instance_mean = embeds.mean(1)
      loss = 0.0
      for epoch in range(self.epochs):
          x = self.head(embeds)
          self.optimizer.zero_grad()
          loss = self.pcl_loss(x)
          loss.backward()
          self.optimizer.step()
      logger.info(
          "Total epoch: {}. ProtoVerb loss: {}".format(
              self.epochs, loss
          )
      )
      self.trained = True
  
imports: from inspect import Parameter
  import json
  from os import stat
  from transformers.file_utils import ModelOutput
  from transformers.tokenization_utils import PreTrainedTokenizer
  from transformers.utils.dummy_pt_objects import PreTrainedModel
  from yacs.config import CfgNode
  from openprompt.data_utils import InputFeatures
  import re
  from openprompt import Verbalizer
  from typing import *
  import torch
  import torch.nn
  import torch.nn.functional
  from openprompt.utils.logging import logger
  import copy
  from transformers.modeling_outputs import CausalLMOutputWithCrossAttentions, Seq2SeqLMOutput, MaskedLMOutput
  from transformers.models.t5 import T5ForConditionalGeneration
label_desc: Use image node_id 18 for calling the ProtoVerbalizer obj's underlying member method code with example usage: obj.train_proto(model, dataloader, device) without return types