Upload 3 files

config.json

@@ -6,9 +6,9 @@
   "attention_bias": false,
   "attention_dropout": 0.0,
   "auto_map": {
-    "AutoConfig": "cfli/MiniCPM-2B-reranker--configuration_minicpm_reranker.MiniCPMConfig",
-    "LayerWiseMiniCPMModel": "cfli/MiniCPM-2B-reranker--modeling_minicpm.MiniCPMModel",
-    "LayerWiseMiniCPMForCausalLM": "cfli/MiniCPM-2B-reranker--modeling_minicpm.MiniCPMForCausalLM"
+    "AutoConfig": "cfli/MiniCPM-2B-reranker--configuration_minicpm_reranker.LayerWiseMiniCPMConfig",
+    "LayerWiseMiniCPMModel": "cfli/MiniCPM-2B-reranker--modeling_minicpm.LayerWiseMiniCPMModel",
+    "LayerWiseMiniCPMForCausalLM": "cfli/MiniCPM-2B-reranker--modeling_minicpm.LayerWiseMiniCPMForCausalLM"
   },
   "bos_token_id": 1,
   "dim_model_base": 256,

configuration_minicpm_reranker.py

@@ -28,7 +28,7 @@ logger = logging.get_logger(__name__)
 MINICPM_PRETRAINED_CONFIG_ARCHIVE_MAP = {}
 
 
-class MiniCPMConfig(PretrainedConfig):
+class LayerWiseMiniCPMConfig(PretrainedConfig):
     r"""
     This is the configuration class to store the configuration of a [`MiniCPMModel`]. It is used to instantiate an MiniCPM
     model according to the specified arguments, defining the model architecture. Instantiating a configuration with the

modeling_minicpm.py

@@ -1491,126 +1491,4 @@ class LayerWiseMiniCPMForCausalLM(MiniCPMPreTrainedModel):
         if len(matches) > 0:
             response = matches[0]
         history.append({"role": "assistant", "content": response})
-        return response, history
-
-
-@add_start_docstrings(
-    """
-    The MiniCPM Model transformer with a sequence classification head on top (linear layer).
-
-    [`MiniCPMForSequenceClassification`] uses the last token in order to do the classification, as other causal models
-    (e.g. GPT-2) do.
-
-    Since it does classification on the last token, it requires to know the position of the last token. If a
-    `pad_token_id` is defined in the configuration, it finds the last token that is not a padding token in each row. If
-    no `pad_token_id` is defined, it simply takes the last value in each row of the batch. Since it cannot guess the
-    padding tokens when `inputs_embeds` are passed instead of `input_ids`, it does the same (take the last value in
-    each row of the batch).
-    """,
-    MINICPM_START_DOCSTRING,
-)
-class MiniCPMForSequenceClassification(MiniCPMPreTrainedModel):
-    def __init__(self, config):
-        super().__init__(config)
-        self.num_labels = config.num_labels
-        self.model = MiniCPMModel(config)
-        self.score = nn.Linear(config.hidden_size, self.num_labels, bias=False)
-
-        # Initialize weights and apply final processing
-        self.post_init()
-
-    def get_input_embeddings(self):
-        return self.model.embed_tokens
-
-    def set_input_embeddings(self, value):
-        self.model.embed_tokens = value
-
-    @add_start_docstrings_to_model_forward(MINICPM_INPUTS_DOCSTRING)
-    def forward(
-            self,
-            input_ids: torch.LongTensor = None,
-            attention_mask: Optional[torch.Tensor] = None,
-            position_ids: Optional[torch.LongTensor] = None,
-            past_key_values: Optional[List[torch.FloatTensor]] = None,
-            inputs_embeds: Optional[torch.FloatTensor] = None,
-            labels: Optional[torch.LongTensor] = None,
-            use_cache: Optional[bool] = None,
-            output_attentions: Optional[bool] = None,
-            output_hidden_states: Optional[bool] = None,
-            return_dict: Optional[bool] = None,
-    ) -> Union[Tuple, SequenceClassifierOutputWithPast]:
-        r"""
-        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
-            Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
-            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
-            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
-        """
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        transformer_outputs = self.model(
-            input_ids,
-            attention_mask=attention_mask,
-            position_ids=position_ids,
-            past_key_values=past_key_values,
-            inputs_embeds=inputs_embeds,
-            use_cache=use_cache,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-        )
-        hidden_states = transformer_outputs[0]
-        logits = self.score(hidden_states)
-
-        if input_ids is not None:
-            batch_size = input_ids.shape[0]
-        else:
-            batch_size = inputs_embeds.shape[0]
-
-        if self.config.pad_token_id is None and batch_size != 1:
-            raise ValueError("Cannot handle batch sizes > 1 if no padding token is defined.")
-        if self.config.pad_token_id is None:
-            sequence_lengths = -1
-        else:
-            if input_ids is not None:
-                sequence_lengths = (torch.eq(input_ids, self.config.pad_token_id).int().argmax(-1) - 1).to(
-                    logits.device
-                )
-            else:
-                sequence_lengths = -1
-
-        pooled_logits = logits[torch.arange(batch_size, device=logits.device), sequence_lengths]
-
-        loss = None
-        if labels is not None:
-            labels = labels.to(logits.device)
-            if self.config.problem_type is None:
-                if self.num_labels == 1:
-                    self.config.problem_type = "regression"
-                elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
-                    self.config.problem_type = "single_label_classification"
-                else:
-                    self.config.problem_type = "multi_label_classification"
-
-            if self.config.problem_type == "regression":
-                loss_fct = MSELoss()
-                if self.num_labels == 1:
-                    loss = loss_fct(pooled_logits.squeeze(), labels.squeeze())
-                else:
-                    loss = loss_fct(pooled_logits, labels)
-            elif self.config.problem_type == "single_label_classification":
-                loss_fct = CrossEntropyLoss()
-                loss = loss_fct(pooled_logits.view(-1, self.num_labels), labels.view(-1))
-            elif self.config.problem_type == "multi_label_classification":
-                loss_fct = BCEWithLogitsLoss()
-                loss = loss_fct(pooled_logits, labels)
-        if not return_dict:
-            output = (pooled_logits,) + transformer_outputs[1:]
-            return ((loss,) + output) if loss is not None else output
-
-        return SequenceClassifierOutputWithPast(
-            loss=loss,
-            logits=pooled_logits,
-            past_key_values=transformer_outputs.past_key_values,
-            hidden_states=transformer_outputs.hidden_states,
-            attentions=transformer_outputs.attentions,
-        )
+        return response, history