





'''simple docstring'''

import unittest

from transformers import AlbertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import (
       MODEL_FOR_PRETRAINING_MAPPING,
       AlbertForMaskedLM,
       AlbertForMultipleChoice,
       AlbertForPreTraining,
       AlbertForQuestionAnswering,
       AlbertForSequenceClassification,
       AlbertForTokenClassification,
       AlbertModel,
   )
   from transformers.models.albert.modeling_albert import ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST
class 							__lowerCAmelCase	:






       """simple docstring"""





       def __init__(				self  :						Union[str, Any]			,					lowerCAmelCase__  :						List[Any]			,					lowerCAmelCase__  :						Any=13			,					lowerCAmelCase__  :						Optional[Any]=7			,					lowerCAmelCase__  :						Tuple=True			,					lowerCAmelCase__  :						Union[str, Any]=True			,					lowerCAmelCase__  :						Union[str, Any]=True			,					lowerCAmelCase__  :						str=True			,					lowerCAmelCase__  :						str=99			,					lowerCAmelCase__  :						Dict=16			,					lowerCAmelCase__  :						List[Any]=36			,					lowerCAmelCase__  :						List[Any]=6			,					lowerCAmelCase__  :						Any=6			,					lowerCAmelCase__  :						str=6			,					lowerCAmelCase__  :						Union[str, Any]=37			,					lowerCAmelCase__  :						Optional[int]="gelu"			,					lowerCAmelCase__  :						int=0.1			,					lowerCAmelCase__  :						Any=0.1			,					lowerCAmelCase__  :						Union[str, Any]=512			,					lowerCAmelCase__  :						List[str]=16			,					lowerCAmelCase__  :						Optional[int]=2			,					lowerCAmelCase__  :						Tuple=0.02			,					lowerCAmelCase__  :						int=3			,					lowerCAmelCase__  :						int=4			,					lowerCAmelCase__  :						str=None			,					)       ->	int:

            '''simple docstring'''




            _UpperCamelCase							       =			parent
            _UpperCamelCase							       =			batch_size
            _UpperCamelCase							       =			seq_length
            _UpperCamelCase							       =			is_training
            _UpperCamelCase							       =			use_input_mask
            _UpperCamelCase							       =			use_token_type_ids
            _UpperCamelCase							       =			use_labels
            _UpperCamelCase							       =			vocab_size
            _UpperCamelCase							       =			embedding_size
            _UpperCamelCase							       =			hidden_size
            _UpperCamelCase							       =			num_hidden_layers
            _UpperCamelCase							       =			num_hidden_groups
            _UpperCamelCase							       =			num_attention_heads
            _UpperCamelCase							       =			intermediate_size
            _UpperCamelCase							       =			hidden_act
            _UpperCamelCase							       =			hidden_dropout_prob
            _UpperCamelCase							       =			attention_probs_dropout_prob
            _UpperCamelCase							       =			max_position_embeddings
            _UpperCamelCase							       =			type_vocab_size
            _UpperCamelCase							       =			type_sequence_label_size
            _UpperCamelCase							       =			initializer_range
            _UpperCamelCase							       =			num_labels
            _UpperCamelCase							       =			num_choices
            _UpperCamelCase							       =			scope





       def snake_case__		(				self  :						List[str]	)       ->	Union[str, Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			ids_tensor([self.batch_size, self.seq_length]			,					self.vocab_size	)

            _UpperCamelCase							       =			None
            if self.use_input_mask:
                 _UpperCamelCase							       =			random_attention_mask([self.batch_size, self.seq_length]	)

            _UpperCamelCase							       =			None
            if self.use_token_type_ids:
                 _UpperCamelCase							       =			ids_tensor([self.batch_size, self.seq_length]			,					self.type_vocab_size	)

            _UpperCamelCase							       =			None
            _UpperCamelCase							       =			None
            _UpperCamelCase							       =			None
            if self.use_labels:
                 _UpperCamelCase							       =			ids_tensor([self.batch_size]			,					self.type_sequence_label_size	)
                 _UpperCamelCase							       =			ids_tensor([self.batch_size, self.seq_length]			,					self.num_labels	)
                 _UpperCamelCase							       =			ids_tensor([self.batch_size]			,					self.num_choices	)

            _UpperCamelCase							       =			self.get_config()

            return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





       def snake_case__		(				self  :						Optional[Any]	)       ->	Union[str, Any]:

            '''simple docstring'''




            return AlbertConfig(
                vocab_size=self.vocab_size			,					hidden_size=self.hidden_size			,					num_hidden_layers=self.num_hidden_layers			,					num_attention_heads=self.num_attention_heads			,					intermediate_size=self.intermediate_size			,					hidden_act=self.hidden_act			,					hidden_dropout_prob=self.hidden_dropout_prob			,					attention_probs_dropout_prob=self.attention_probs_dropout_prob			,					max_position_embeddings=self.max_position_embeddings			,					type_vocab_size=self.type_vocab_size			,					initializer_range=self.initializer_range			,					num_hidden_groups=self.num_hidden_groups			,					)





       def snake_case__		(				self  :						Dict			,					lowerCAmelCase__  :						Union[str, Any]			,					lowerCAmelCase__  :						Tuple			,					lowerCAmelCase__  :						Tuple			,					lowerCAmelCase__  :						Optional[Any]			,					lowerCAmelCase__  :						List[Any]			,					lowerCAmelCase__  :						List[str]			,					lowerCAmelCase__  :						Optional[int]	)       ->	Union[str, Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			AlbertModel(config=lowerCAmelCase__	)
            model.to(lowerCAmelCase__	)
            model.eval()
            _UpperCamelCase							       =			model(lowerCAmelCase__			,					attention_mask=lowerCAmelCase__			,					token_type_ids=lowerCAmelCase__	)
            _UpperCamelCase							       =			model(lowerCAmelCase__			,					token_type_ids=lowerCAmelCase__	)
            _UpperCamelCase							       =			model(lowerCAmelCase__	)
            self.parent.assertEqual(result.last_hidden_state.shape			,					(self.batch_size, self.seq_length, self.hidden_size)	)
            self.parent.assertEqual(result.pooler_output.shape			,					(self.batch_size, self.hidden_size)	)





       def snake_case__		(				self  :						Optional[int]			,					lowerCAmelCase__  :						Any			,					lowerCAmelCase__  :						List[str]			,					lowerCAmelCase__  :						Any			,					lowerCAmelCase__  :						List[str]			,					lowerCAmelCase__  :						Tuple			,					lowerCAmelCase__  :						int			,					lowerCAmelCase__  :						Dict	)       ->	str:

            '''simple docstring'''




            _UpperCamelCase							       =			AlbertForPreTraining(config=lowerCAmelCase__	)
            model.to(lowerCAmelCase__	)
            model.eval()
            _UpperCamelCase							       =			model(
                lowerCAmelCase__			,					attention_mask=lowerCAmelCase__			,					token_type_ids=lowerCAmelCase__			,					labels=lowerCAmelCase__			,					sentence_order_label=lowerCAmelCase__			,					)
            self.parent.assertEqual(result.prediction_logits.shape			,					(self.batch_size, self.seq_length, self.vocab_size)	)
            self.parent.assertEqual(result.sop_logits.shape			,					(self.batch_size, config.num_labels)	)





       def snake_case__		(				self  :						str			,					lowerCAmelCase__  :						Optional[Any]			,					lowerCAmelCase__  :						Optional[Any]			,					lowerCAmelCase__  :						Optional[int]			,					lowerCAmelCase__  :						Any			,					lowerCAmelCase__  :						Optional[int]			,					lowerCAmelCase__  :						List[Any]			,					lowerCAmelCase__  :						int	)       ->	Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			AlbertForMaskedLM(config=lowerCAmelCase__	)
            model.to(lowerCAmelCase__	)
            model.eval()
            _UpperCamelCase							       =			model(lowerCAmelCase__			,					attention_mask=lowerCAmelCase__			,					token_type_ids=lowerCAmelCase__			,					labels=lowerCAmelCase__	)
            self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.seq_length, self.vocab_size)	)





       def snake_case__		(				self  :						List[Any]			,					lowerCAmelCase__  :						Dict			,					lowerCAmelCase__  :						Union[str, Any]			,					lowerCAmelCase__  :						List[str]			,					lowerCAmelCase__  :						str			,					lowerCAmelCase__  :						int			,					lowerCAmelCase__  :						Any			,					lowerCAmelCase__  :						Optional[Any]	)       ->	List[str]:

            '''simple docstring'''




            _UpperCamelCase							       =			AlbertForQuestionAnswering(config=lowerCAmelCase__	)
            model.to(lowerCAmelCase__	)
            model.eval()
            _UpperCamelCase							       =			model(
                lowerCAmelCase__			,					attention_mask=lowerCAmelCase__			,					token_type_ids=lowerCAmelCase__			,					start_positions=lowerCAmelCase__			,					end_positions=lowerCAmelCase__			,					)
            self.parent.assertEqual(result.start_logits.shape			,					(self.batch_size, self.seq_length)	)
            self.parent.assertEqual(result.end_logits.shape			,					(self.batch_size, self.seq_length)	)





       def snake_case__		(				self  :						Tuple			,					lowerCAmelCase__  :						Any			,					lowerCAmelCase__  :						Any			,					lowerCAmelCase__  :						List[Any]			,					lowerCAmelCase__  :						List[Any]			,					lowerCAmelCase__  :						Dict			,					lowerCAmelCase__  :						Tuple			,					lowerCAmelCase__  :						Tuple	)       ->	Union[str, Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			self.num_labels
            _UpperCamelCase							       =			AlbertForSequenceClassification(lowerCAmelCase__	)
            model.to(lowerCAmelCase__	)
            model.eval()
            _UpperCamelCase							       =			model(lowerCAmelCase__			,					attention_mask=lowerCAmelCase__			,					token_type_ids=lowerCAmelCase__			,					labels=lowerCAmelCase__	)
            self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.num_labels)	)





       def snake_case__		(				self  :						List[str]			,					lowerCAmelCase__  :						Dict			,					lowerCAmelCase__  :						Optional[int]			,					lowerCAmelCase__  :						Dict			,					lowerCAmelCase__  :						List[Any]			,					lowerCAmelCase__  :						List[Any]			,					lowerCAmelCase__  :						Dict			,					lowerCAmelCase__  :						Optional[Any]	)       ->	Union[str, Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			self.num_labels
            _UpperCamelCase							       =			AlbertForTokenClassification(config=lowerCAmelCase__	)
            model.to(lowerCAmelCase__	)
            model.eval()
            _UpperCamelCase							       =			model(lowerCAmelCase__			,					attention_mask=lowerCAmelCase__			,					token_type_ids=lowerCAmelCase__			,					labels=lowerCAmelCase__	)
            self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.seq_length, self.num_labels)	)





       def snake_case__		(				self  :						List[str]			,					lowerCAmelCase__  :						Dict			,					lowerCAmelCase__  :						Union[str, Any]			,					lowerCAmelCase__  :						List[str]			,					lowerCAmelCase__  :						List[Any]			,					lowerCAmelCase__  :						Optional[Any]			,					lowerCAmelCase__  :						List[str]			,					lowerCAmelCase__  :						Tuple	)       ->	str:

            '''simple docstring'''




            _UpperCamelCase							       =			self.num_choices
            _UpperCamelCase							       =			AlbertForMultipleChoice(config=lowerCAmelCase__	)
            model.to(lowerCAmelCase__	)
            model.eval()
            _UpperCamelCase							       =			input_ids.unsqueeze(1	).expand(-1			,					self.num_choices			,					-1	).contiguous()
            _UpperCamelCase							       =			token_type_ids.unsqueeze(1	).expand(-1			,					self.num_choices			,					-1	).contiguous()
            _UpperCamelCase							       =			input_mask.unsqueeze(1	).expand(-1			,					self.num_choices			,					-1	).contiguous()
            _UpperCamelCase							       =			model(
                lowerCAmelCase__			,					attention_mask=lowerCAmelCase__			,					token_type_ids=lowerCAmelCase__			,					labels=lowerCAmelCase__			,					)
            self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.num_choices)	)







       def snake_case__		(				self  :						Optional[int]	)       ->	Any:

            '''simple docstring'''




            _UpperCamelCase							       =			self.prepare_config_and_inputs()
            (
                (
                _UpperCamelCase
            )       ,							(
                _UpperCamelCase
            )       ,							(
                _UpperCamelCase
            )       ,							(
                _UpperCamelCase
            )       ,							(
                _UpperCamelCase
            )       ,							(
                _UpperCamelCase
            )       ,							(
                _UpperCamelCase
            )       ,							
            )							       =			config_and_inputs
            _UpperCamelCase							       =			{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
            return config, inputs_dict

@require_torch
class 							__lowerCAmelCase	(       __magic_name__		,		__magic_name__		,		unittest.TestCase					):






       """simple docstring"""
       _snake_case      :	Union[str, Any]									=       (
           (
               AlbertModel,
               AlbertForPreTraining,
               AlbertForMaskedLM,
               AlbertForMultipleChoice,
               AlbertForSequenceClassification,
               AlbertForTokenClassification,
               AlbertForQuestionAnswering,
           )
           if is_torch_available()
           else ()
       )
       _snake_case      :	List[Any]									=       (
           {
               'feature-extraction': AlbertModel,
               'fill-mask': AlbertForMaskedLM,
               'question-answering': AlbertForQuestionAnswering,
               'text-classification': AlbertForSequenceClassification,
               'token-classification': AlbertForTokenClassification,
               'zero-shot': AlbertForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       _snake_case      :	List[Any]									=       True





       def snake_case__		(				self  :						int			,					lowerCAmelCase__  :						List[str]			,					lowerCAmelCase__  :						List[Any]			,					lowerCAmelCase__  :						Any=False	)       ->	Union[str, Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			super()._prepare_for_class(lowerCAmelCase__			,					lowerCAmelCase__			,					return_labels=lowerCAmelCase__	)

            if return_labels:
                 if model_class in get_values(lowerCAmelCase__	):
                      _UpperCamelCase							       =			torch.zeros(
                          (self.model_tester.batch_size, self.model_tester.seq_length)			,					dtype=torch.long			,					device=lowerCAmelCase__	)
                      _UpperCamelCase							       =			torch.zeros(
                          self.model_tester.batch_size			,					dtype=torch.long			,					device=lowerCAmelCase__	)
            return inputs_dict





       def snake_case__		(				self  :						Union[str, Any]	)       ->	List[Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			AlbertModelTester(self	)
            _UpperCamelCase							       =			ConfigTester(self			,					config_class=lowerCAmelCase__			,					hidden_size=37	)





       def snake_case__		(				self  :						Tuple	)       ->	List[Any]:

            '''simple docstring'''




            self.config_tester.run_common_tests()





       def snake_case__		(				self  :						int	)       ->	str:

            '''simple docstring'''




            _UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*lowerCAmelCase__	)





       def snake_case__		(				self  :						Any	)       ->	Tuple:

            '''simple docstring'''




            _UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_pretraining(*lowerCAmelCase__	)





       def snake_case__		(				self  :						int	)       ->	List[str]:

            '''simple docstring'''




            _UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase__	)





       def snake_case__		(				self  :						Optional[int]	)       ->	Union[str, Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_multiple_choice(*lowerCAmelCase__	)





       def snake_case__		(				self  :						Optional[Any]	)       ->	int:

            '''simple docstring'''




            _UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase__	)





       def snake_case__		(				self  :						Any	)       ->	Dict:

            '''simple docstring'''




            _UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase__	)





       def snake_case__		(				self  :						Tuple	)       ->	int:

            '''simple docstring'''




            _UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs()
            for type in ["absolute", "relative_key", "relative_key_query"]:
                 _UpperCamelCase							       =			type
                 self.model_tester.create_and_check_model(*lowerCAmelCase__	)







       @slow
       def snake_case__		(				self  :						Optional[Any]	)       ->	Dict:

            '''simple docstring'''




            for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 _UpperCamelCase							       =			AlbertModel.from_pretrained(lowerCAmelCase__	)
                 self.assertIsNotNone(lowerCAmelCase__	)

@require_torch
class 							__lowerCAmelCase	(       unittest.TestCase					):






       """simple docstring"""





       @slow
       def snake_case__		(				self  :						str	)       ->	List[str]:

            '''simple docstring'''




            _UpperCamelCase							       =			AlbertModel.from_pretrained('''albert-base-v2'''	)
            _UpperCamelCase							       =			torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]	)
            _UpperCamelCase							       =			torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]	)
            with torch.no_grad():
                 _UpperCamelCase							       =			model(lowerCAmelCase__			,					attention_mask=lowerCAmelCase__	)[0]
            _UpperCamelCase							       =			torch.Size((1, 11, 768)	)
            self.assertEqual(output.shape			,					lowerCAmelCase__	)
            _UpperCamelCase							       =			torch.tensor(
                [[[-0.6513, 1.5035, -0.2766], [-0.6515, 1.5046, -0.2780], [-0.6512, 1.5049, -0.2784]]]	)

            self.assertTrue(torch.allclose(output[:, 1:4, 1:4]			,					lowerCAmelCase__			,					atol=1e-4	)	)








from __future__ import annotations

import requests






def     __a					(		__UpperCAmelCase       ):
 a__												= f"https://hacker-news.firebaseio.com/v0/item/{story_id}.json?print=pretty"
 return requests.get(__UpperCAmelCase       ).json()






def     __a					(		__UpperCAmelCase = 10       ):
 a__												= '''https://hacker-news.firebaseio.com/v0/topstories.json?print=pretty'''
 a__												= requests.get(__UpperCAmelCase       ).json()[:max_stories]
 return [get_hackernews_story(__UpperCAmelCase       ) for story_id in story_ids]






def     __a					(		__UpperCAmelCase = 10       ):
 a__												= hackernews_top_stories(__UpperCAmelCase       )
 return "\n".join('''* [{title}]({url})'''.format(**__UpperCAmelCase       ) for story in stories       )


if __name__ == "__main__":
     print(hackernews_top_stories_as_markdown())





