Upload folder using huggingface_hub

custom_generate/generate.py

@@ -83,7 +83,7 @@ def _dola_select_contrast(
     return logits
 
 def _dola_decoding(
-        self,
+        model,
         input_ids: torch.LongTensor,
         logits_processor: LogitsProcessorList,
         stopping_criteria: StoppingCriteriaList,
@@ -141,7 +141,7 @@ def _dola_decoding(
         if getattr(generation_config, "num_beams", 1) != 1:
             raise ValueError("DoLa generation needs num_beams == 1")
         
-        if self.config.is_encoder_decoder:
+        if model.config.is_encoder_decoder:
             raise ValueError("DoLa decoding is only available for decoder-only models.")
 
         if generation_config.repetition_penalty < 1.2:
@@ -150,13 +150,13 @@ def _dola_decoding(
                 "The recommended value for DoLa decoding is `repetition_penalty>=1.2`.",
             )
 
-        if getattr(self, "_is_stateful", False):
+        if getattr(model, "_is_stateful", False):
             # DoLa decoding was not designed for stateful models, and would require some changes
             raise ValueError(
-                f"DoLa decoding is not supported with stateful models, such as {self.__class__.__name__}"
+                f"DoLa decoding is not supported with stateful models, such as {model.__class__.__name__}"
             )
 
-        if self.config.is_encoder_decoder:
+        if model.config.is_encoder_decoder:
             raise ValueError("DoLa decoding is only available for decoder-only models.")
         
         # init values
@@ -179,17 +179,17 @@ def _dola_decoding(
         # keep track of which sequences are already finished
         batch_size, cur_length = input_ids.shape[:2]
         unfinished_sequences = torch.ones(batch_size, dtype=torch.long, device=input_ids.device)
-        model_kwargs = self._get_initial_cache_position(cur_length, input_ids.device, model_kwargs)
+        model_kwargs = model._get_initial_cache_position(cur_length, input_ids.device, model_kwargs)
 
         this_peer_finished = False
 
         # prepare layers for DoLa decoding
-        final_layer = self.config.get_text_config().num_hidden_layers
+        final_layer = model.config.get_text_config().num_hidden_layers
         # if the model has tied word embeddings, we skip the word embeddings (0-th) layer and start from the 2nd layer,
         # as the early exit from word embeddings will become identity function
         # if the model is really shallow (<=2 layers), we use the 1st layer if it's not the final layer and the 0-th
         # layer otherwise. Notice that DoLa does not help shallow models much.
-        if not self.config.tie_word_embeddings:
+        if not model.config.tie_word_embeddings:
             start_layer = 0
         elif final_layer > 2:
             start_layer = 2
@@ -223,16 +223,16 @@ def _dola_decoding(
         else:
             raise ValueError("dola_layers must be either 'low', 'high' or a list of integers.")
 
-        lm_head = self.get_output_embeddings()
+        lm_head = model.get_output_embeddings()
         if lm_head is None:
             raise ValueError("DoLa is not supported for models that don't have output embeddings.")
 
-        while self._has_unfinished_sequences(this_peer_finished, synced_gpus, device=input_ids.device):
+        while model._has_unfinished_sequences(this_peer_finished, synced_gpus, device=input_ids.device):
             # prepare model inputs
-            model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
+            model_inputs = model.prepare_inputs_for_generation(input_ids, **model_kwargs)
 
             # forward pass to get next token
-            outputs = self(
+            outputs = model(
                 **model_inputs,
                 return_dict=True,
                 output_attentions=output_attentions,
@@ -249,10 +249,10 @@ def _dola_decoding(
                 ).to(final_logits.device)
 
             # synced_gpus: don't waste resources running the code we don't need; kwargs must be updated before skipping
-            model_kwargs = self._update_model_kwargs_for_generation(
+            model_kwargs = model._update_model_kwargs_for_generation(
                 outputs,
                 model_kwargs,
-                is_encoder_decoder=self.config.is_encoder_decoder,
+                is_encoder_decoder=model.config.is_encoder_decoder,
             )
             if synced_gpus and this_peer_finished:
                 continue
@@ -272,15 +272,15 @@ def _dola_decoding(
                     raw_logits += (final_layer_next_token_logits,)
                 if output_attentions:
                     decoder_attentions += (
-                        (outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)
+                        (outputs.decoder_attentions,) if model.config.is_encoder_decoder else (outputs.attentions,)
                     )
-                    if self.config.is_encoder_decoder:
+                    if model.config.is_encoder_decoder:
                         cross_attentions += (outputs.cross_attentions,)
 
                 if output_hidden_states:
                     decoder_hidden_states += (
                         (outputs.decoder_hidden_states,)
-                        if self.config.is_encoder_decoder
+                        if model.config.is_encoder_decoder
                         else (outputs.hidden_states,)
                     )