


"""simple docstring"""







from __future__ import absolute_import, division, print_function, unicode_literals

from torch import nn
from torch.nn import CrossEntropyLoss, MSELoss

from transformers import RobertaConfig
from transformers.file_utils import add_start_docstrings, add_start_docstrings_to_model_forward
from transformers.models.roberta.modeling_roberta import (
    ROBERTA_INPUTS_DOCSTRING,
    ROBERTA_START_DOCSTRING,
    RobertaEmbeddings,
)

from .modeling_highway_bert import BertPreTrainedModel, DeeBertModel, HighwayException, entropy


@add_start_docstrings(
    "The RoBERTa Model transformer with early exiting (DeeRoBERTa). "       ,   SCREAMING_SNAKE_CASE_       ,   )
class    SCREAMING_SNAKE_CASE__    (		SCREAMING_SNAKE_CASE_    ):
       """simple docstring"""


       a  :    Optional[Any]       =RobertaConfig
       a  :    int       ="roberta"

       def __init__(						self		,					snake_case__						):






         """simple docstring"""





         super().__init__(snake_case__						)

         lowerCAmelCase					:					Union[str, Any]								=							RobertaEmbeddings(snake_case__						)
         self.init_weights()


@add_start_docstrings(
    "RoBERTa Model (with early exiting - DeeRoBERTa) with a classifier on top,\n    also takes care of multi-layer training. "       ,   SCREAMING_SNAKE_CASE_       ,   )
class    SCREAMING_SNAKE_CASE__    (		SCREAMING_SNAKE_CASE_    ):
       """simple docstring"""


       a  :    List[str]       =RobertaConfig
       a  :    int       ="roberta"

       def __init__(						self		,					snake_case__						):






         """simple docstring"""





         super().__init__(snake_case__						)
         lowerCAmelCase					:					Tuple								=							config.num_labels
         lowerCAmelCase					:					Any								=							config.num_hidden_layers

         lowerCAmelCase					:					int								=							DeeRobertaModel(snake_case__						)
         lowerCAmelCase					:					Union[str, Any]								=							nn.Dropout(config.hidden_dropout_prob						)
         lowerCAmelCase					:					List[Any]								=							nn.Linear(config.hidden_size		,					self.config.num_labels						)







       @add_start_docstrings_to_model_forward(snake_case__						)
       def 	lowercase__							(						self		,					snake_case__=None		,					snake_case__=None		,					snake_case__=None		,					snake_case__=None		,					snake_case__=None		,					snake_case__=None		,					snake_case__=None		,					snake_case__=-1		,					snake_case__=False		,					):






         """simple docstring"""





         lowerCAmelCase					:					int								=							self.num_layers
         try:
           lowerCAmelCase					:					str								=							self.roberta(
               snake_case__		,					attention_mask=snake_case__		,					token_type_ids=snake_case__		,					position_ids=snake_case__		,					head_mask=snake_case__		,					inputs_embeds=snake_case__		,					)

           lowerCAmelCase					:					List[Any]								=							outputs[1]

           lowerCAmelCase					:					Tuple								=							self.dropout(snake_case__						)
           lowerCAmelCase					:					Optional[int]								=							self.classifier(snake_case__						)
           lowerCAmelCase					:					Optional[Any]								=							(logits,) + outputs[2:]  # add hidden states and attention if they are here
         except HighwayException as e:
           lowerCAmelCase					:					List[Any]								=							e.message
           lowerCAmelCase					:					Dict								=							e.exit_layer
           lowerCAmelCase					:					List[Any]								=							outputs[0]

         if not self.training:
           lowerCAmelCase					:					Union[str, Any]								=							entropy(snake_case__						)
           lowerCAmelCase					:					Optional[Any]								=							[]
           lowerCAmelCase					:					Any								=							[]
         if labels is not None:
           if self.num_labels == 1:
             #  We are doing regression
             lowerCAmelCase					:					Optional[Any]								=							MSELoss()
             lowerCAmelCase					:					Dict								=							loss_fct(logits.view(-1						)		,					labels.view(-1						)						)
           else:
             lowerCAmelCase					:					Dict								=							CrossEntropyLoss()
             lowerCAmelCase					:					Optional[int]								=							loss_fct(logits.view(-1		,					self.num_labels						)		,					labels.view(-1						)						)

           # work with highway exits
           lowerCAmelCase					:					Union[str, Any]								=							[]
           for highway_exit in outputs[-1]:
             lowerCAmelCase					:					Optional[int]								=							highway_exit[0]
             if not self.training:
               highway_logits_all.append(snake_case__						)
               highway_entropy.append(highway_exit[2]						)
             if self.num_labels == 1:
               #  We are doing regression
               lowerCAmelCase					:					Any								=							MSELoss()
               lowerCAmelCase					:					Tuple								=							loss_fct(highway_logits.view(-1						)		,					labels.view(-1						)						)
             else:
               lowerCAmelCase					:					Dict								=							CrossEntropyLoss()
               lowerCAmelCase					:					List[str]								=							loss_fct(highway_logits.view(-1		,					self.num_labels						)		,					labels.view(-1						)						)
             highway_losses.append(snake_case__						)

           if train_highway:
             lowerCAmelCase					:					str								=							(sum(highway_losses[:-1]						),) + outputs
             # exclude the final highway, of course
           else:
             lowerCAmelCase					:					Dict								=							(loss,) + outputs
         if not self.training:
           lowerCAmelCase					:					Optional[Any]								=							outputs + ((original_entropy, highway_entropy), exit_layer)
           if output_layer >= 0:
             lowerCAmelCase					:					Any								=							(
                 (outputs[0],) + (highway_logits_all[output_layer],) + outputs[2:]
             )  # use the highway of the last layer

         return outputs  # (loss), logits, (hidden_states), (attentions), entropy









"""simple docstring"""







import multiprocessing
from typing import TYPE_CHECKING, Optional, Union

from .. import Dataset, Features, config
from ..formatting import query_table
from ..packaged_modules.sql.sql import Sql
from ..utils import logging
from .abc import AbstractDatasetInputStream


if TYPE_CHECKING:
     import sqlitea

     import sqlalchemy


class 				SCREAMING_SNAKE_CASE__    (		lowercase    ):
       """simple docstring"""


       def __init__(						self		,					snake_case__		,					snake_case__		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = False		,					**snake_case__		,					):






         """simple docstring"""





         super().__init__(features=snake_case__		,					cache_dir=snake_case__		,					keep_in_memory=snake_case__		,					**snake_case__						)
         lowerCAmelCase					:					Dict								=							Sql(
             cache_dir=snake_case__		,					features=snake_case__		,					sql=snake_case__		,					con=snake_case__		,					**snake_case__		,					)







       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Tuple								=							None
         lowerCAmelCase					:					Optional[int]								=							None
         lowerCAmelCase					:					str								=							None
         lowerCAmelCase					:					int								=							None

         self.builder.download_and_prepare(
             download_config=snake_case__		,					download_mode=snake_case__		,					verification_mode=snake_case__		,					base_path=snake_case__		,					)

         # Build dataset for splits
         lowerCAmelCase					:					str								=							self.builder.as_dataset(
             split="train"		,					verification_mode=snake_case__		,					in_memory=self.keep_in_memory						)
         return dataset


class 				SCREAMING_SNAKE_CASE__    :
       """simple docstring"""


       def __init__(						self		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__ = None		,					snake_case__ = None		,					**snake_case__		,					):






         """simple docstring"""





         if num_proc is not None and num_proc <= 0:
           raise ValueError(f"""num_proc {num_proc} must be an integer > 0."""						)

         lowerCAmelCase					:					Tuple								=							dataset
         lowerCAmelCase					:					Tuple								=							name
         lowerCAmelCase					:					List[str]								=							con
         lowerCAmelCase					:					List[Any]								=							batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
         lowerCAmelCase					:					Optional[int]								=							num_proc
         lowerCAmelCase					:					Optional[int]								=							to_sql_kwargs

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					List[str]								=							self.to_sql_kwargs.pop("sql"		,					snake_case__						)
         lowerCAmelCase					:					List[Any]								=							self.to_sql_kwargs.pop("con"		,					snake_case__						)
         lowerCAmelCase					:					Dict								=							self.to_sql_kwargs.pop("index"		,					snake_case__						)

         lowerCAmelCase					:					Dict								=							self._write(index=snake_case__		,					**self.to_sql_kwargs						)
         return written

       def 	lowercase__							(						self		,					snake_case__						):






         """simple docstring"""





         lowerCAmelCase						,  lowerCAmelCase						,  lowerCAmelCase					:					Optional[int]								=							args
         lowerCAmelCase					:					Optional[int]								=							{**to_sql_kwargs, "if_exists": "append"} if offset > 0 else to_sql_kwargs
         lowerCAmelCase					:					List[Any]								=							query_table(
             table=self.dataset.data		,					key=slice(snake_case__		,					offset + self.batch_size						)		,					indices=self.dataset._indices		,					)
         lowerCAmelCase					:					Tuple								=							batch.to_pandas()
         lowerCAmelCase					:					str								=							df.to_sql(self.name		,					self.con		,					index=snake_case__		,					**snake_case__						)
         return num_rows or len(snake_case__						)







       def 	lowercase__							(						self		,					snake_case__		,					**snake_case__						):






         """simple docstring"""





         lowerCAmelCase					:					Tuple								=							0

         if self.num_proc is None or self.num_proc == 1:
           for offset in logging.tqdm(
               range(0		,					len(self.dataset						)		,					self.batch_size						)		,					unit="ba"		,					disable=not logging.is_progress_bar_enabled()		,					desc="Creating SQL from Arrow format"		,					):
             written += self._batch_sql((offset, index, to_sql_kwargs)						)
         else:
           lowerCAmelCase						,  lowerCAmelCase					:					Dict								=							len(self.dataset						), self.batch_size
           with multiprocessing.Pool(self.num_proc						) as pool:
             for num_rows in logging.tqdm(
                 pool.imap(
                     self._batch_sql		,					[(offset, index, to_sql_kwargs) for offset in range(0		,					snake_case__		,					snake_case__						)]		,					)		,					total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size		,					unit="ba"		,					disable=not logging.is_progress_bar_enabled()		,					desc="Creating SQL from Arrow format"		,					):
               written += num_rows

         return written





