
'''simple docstring'''
import math
import unittest

from transformers import BioGptConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
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 (
         BioGptForCausalLM,
         BioGptForSequenceClassification,
         BioGptForTokenClassification,
         BioGptModel,
         BioGptTokenizer,
     )
     from transformers.models.biogpt.modeling_biogpt import BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST







class  __A				:
 def __init__(   self			:    int				,   lowerCamelCase			:    List[str]				,   lowerCamelCase			:    Union[str, Any]=13				,   lowerCamelCase			:    int=7				,   lowerCamelCase			:    Any=True				,   lowerCamelCase			:    Tuple=True				,   lowerCamelCase			:    Optional[Any]=False				,   lowerCamelCase			:    List[str]=True				,   lowerCamelCase			:    List[str]=99				,   lowerCamelCase			:    Union[str, Any]=32				,   lowerCamelCase			:    str=5				,   lowerCamelCase			:    Optional[Any]=4				,   lowerCamelCase			:    str=37				,   lowerCamelCase			:    Any="gelu"				,   lowerCamelCase			:    Tuple=0.1				,   lowerCamelCase			:    List[str]=0.1				,   lowerCamelCase			:    Union[str, Any]=5_12				,   lowerCamelCase			:    Any=16				,   lowerCamelCase			:    Union[str, Any]=2				,   lowerCamelCase			:    Optional[Any]=0.02				,   lowerCamelCase			:    List[str]=3				,   lowerCamelCase			:    Any=4				,   lowerCamelCase			:    Tuple=None				,   ):



   """simple docstring"""





   __A		:     Tuple												=		parent
   __A		:     int												=		batch_size
   __A		:     List[Any]												=		seq_length
   __A		:     Dict												=		is_training
   __A		:     Tuple												=		use_input_mask
   __A		:     int												=		use_token_type_ids
   __A		:     Optional[int]												=		use_labels
   __A		:     Any												=		vocab_size
   __A		:     Tuple												=		hidden_size
   __A		:     Union[str, Any]												=		num_hidden_layers
   __A		:     Optional[Any]												=		num_attention_heads
   __A		:     Optional[Any]												=		intermediate_size
   __A		:     List[str]												=		hidden_act
   __A		:     Optional[int]												=		hidden_dropout_prob
   __A		:     Union[str, Any]												=		attention_probs_dropout_prob
   __A		:     Optional[Any]												=		max_position_embeddings
   __A		:     Dict												=		type_vocab_size
   __A		:     Optional[int]												=		type_sequence_label_size
   __A		:     List[Any]												=		initializer_range
   __A		:     Union[str, Any]												=		num_labels
   __A		:     int												=		num_choices
   __A		:     Tuple												=		scope
 def 		lowercase_(   self			:    str       ):



   """simple docstring"""





   __A		:     Union[str, Any]												=		ids_tensor([self.batch_size, self.seq_length]				,   self.vocab_size       )

   __A		:     List[Any]												=		None
   if self.use_input_mask:
     __A		:     Dict												=		random_attention_mask([self.batch_size, self.seq_length]       )

   __A		:     Union[str, Any]												=		None
   if self.use_token_type_ids:
     __A		:     Any												=		ids_tensor([self.batch_size, self.seq_length]				,   self.type_vocab_size       )

   __A		:     List[str]												=		None
   __A		:     int												=		None
   __A		:     List[str]												=		None
   if self.use_labels:
     __A		:     Tuple												=		ids_tensor([self.batch_size]				,   self.type_sequence_label_size       )
     __A		:     Tuple												=		ids_tensor([self.batch_size, self.seq_length]				,   self.num_labels       )
     __A		:     List[Any]												=		ids_tensor([self.batch_size]				,   self.num_choices       )

   __A		:     Optional[Any]												=		self.get_config()

   return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
 def 		lowercase_(   self			:    int       ):



   """simple docstring"""





   return BioGptConfig(
       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				,   is_decoder=lowerCamelCase				,   initializer_range=self.initializer_range				,   )
 def 		lowercase_(   self			:    str				,   lowerCamelCase			:    Optional[int]				,   lowerCamelCase			:    Optional[int]				,   lowerCamelCase			:    Any				,   lowerCamelCase			:    Any				,   lowerCamelCase			:    Tuple				,   lowerCamelCase			:    List[Any]				,   lowerCamelCase			:    List[Any]       ):



   """simple docstring"""





   __A		:     Union[str, Any]												=		BioGptModel(config=lowerCamelCase       )
   model.to(lowerCamelCase       )
   model.eval()
   __A		:     Union[str, Any]												=		model(lowerCamelCase				,   attention_mask=lowerCamelCase       )
   __A		:     List[Any]												=		model(lowerCamelCase       )
   self.parent.assertEqual(result.last_hidden_state.shape				,   (self.batch_size, self.seq_length, self.hidden_size)       )
 def 		lowercase_(   self			:    List[str]				,   lowerCamelCase			:    str				,   lowerCamelCase			:    Optional[int]				,   lowerCamelCase			:    Dict				,   lowerCamelCase			:    str				,   lowerCamelCase			:    Union[str, Any]				,   lowerCamelCase			:    Dict				,   lowerCamelCase			:    str				,   lowerCamelCase			:    Tuple				,   lowerCamelCase			:    List[str]				,   ):



   """simple docstring"""





   __A		:     str												=		BioGptForCausalLM(config=lowerCamelCase       )
   model.to(lowerCamelCase       )
   model.eval()
   __A		:     Dict												=		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 		lowercase_(   self			:    Union[str, Any]				,   lowerCamelCase			:    Union[str, Any]				,   lowerCamelCase			:    Union[str, Any]				,   lowerCamelCase			:    Union[str, Any]				,   lowerCamelCase			:    List[str]				,   lowerCamelCase			:    Union[str, Any]				,   *lowerCamelCase			:    List[str]       ):



   """simple docstring"""





   __A		:     str												=		BioGptModel(config=lowerCamelCase       )
   model.to(lowerCamelCase       )
   model.eval()

   # create attention mask
   __A		:     str												=		torch.ones(input_ids.shape				,   dtype=torch.long				,   device=lowerCamelCase       )
   __A		:     Optional[Any]												=		self.seq_length // 2
   __A		:     str												=		0

   # first forward pass
   __A							,					__A		:     int												=		model(lowerCamelCase				,   attention_mask=lowerCamelCase       ).to_tuple()

   # create hypothetical next token and extent to next_input_ids
   __A		:     Tuple												=		ids_tensor((self.batch_size, 1)				,   config.vocab_size       )

   # change a random masked slice from input_ids
   __A		:     Any												=		ids_tensor((1,)				,   lowerCamelCase       ).item() + 1
   __A		:     List[str]												=		ids_tensor((self.batch_size, 1)				,   config.vocab_size       ).squeeze(-1       )
   __A		:     Dict												=		random_other_next_tokens

   # append to next input_ids and attn_mask
   __A		:     List[Any]												=		torch.cat([input_ids, next_tokens]				,   dim=-1       )
   __A		:     List[str]												=		torch.cat(
       [attn_mask, torch.ones((attn_mask.shape[0], 1)				,   dtype=torch.long				,   device=lowerCamelCase       )]				,   dim=1				,   )

   # get two different outputs
   __A		:     List[Any]												=		model(lowerCamelCase				,   attention_mask=lowerCamelCase       )["""last_hidden_state"""]
   __A		:     int												=		model(lowerCamelCase				,   past_key_values=lowerCamelCase				,   attention_mask=lowerCamelCase       )["""last_hidden_state"""]

   # select random slice
   __A		:     Optional[Any]												=		ids_tensor((1,)				,   output_from_past.shape[-1]       ).item()
   __A		:     Dict												=		output_from_no_past[:, -1, random_slice_idx].detach()
   __A		:     Optional[int]												=		output_from_past[:, 0, random_slice_idx].detach()

   # test that outputs are equal for slice
   self.parent.assertTrue(torch.allclose(lowerCamelCase				,   lowerCamelCase				,   atol=1e-3       )       )
 def 		lowercase_(   self			:    Dict				,   lowerCamelCase			:    Any				,   lowerCamelCase			:    List[Any]				,   lowerCamelCase			:    List[Any]				,   lowerCamelCase			:    List[str]				,   lowerCamelCase			:    Dict				,   *lowerCamelCase			:    Tuple       ):



   """simple docstring"""





   __A		:     List[Any]												=		BioGptModel(config=lowerCamelCase       ).to(lowerCamelCase       ).eval()

   __A		:     List[str]												=		torch.ones(input_ids.shape				,   dtype=torch.long				,   device=lowerCamelCase       )

   # first forward pass
   __A		:     Dict												=		model(lowerCamelCase				,   attention_mask=lowerCamelCase				,   use_cache=lowerCamelCase       )

   __A							,					__A		:     Any												=		outputs.to_tuple()

   # create hypothetical multiple next token and extent to next_input_ids
   __A		:     Optional[int]												=		ids_tensor((self.batch_size, 3)				,   config.vocab_size       )
   __A		:     Optional[Any]												=		ids_tensor((self.batch_size, 3)				,   2       )

   # append to next input_ids and
   __A		:     int												=		torch.cat([input_ids, next_tokens]				,   dim=-1       )
   __A		:     Any												=		torch.cat([attention_mask, next_attn_mask]				,   dim=-1       )

   __A		:     Optional[Any]												=		model(lowerCamelCase				,   attention_mask=lowerCamelCase       )["""last_hidden_state"""]
   __A		:     Union[str, Any]												=		model(lowerCamelCase				,   attention_mask=lowerCamelCase				,   past_key_values=lowerCamelCase       )[
       """last_hidden_state"""
   ]

   # select random slice
   __A		:     List[str]												=		ids_tensor((1,)				,   output_from_past.shape[-1]       ).item()
   __A		:     int												=		output_from_no_past[:, -3:, random_slice_idx].detach()
   __A		:     Tuple												=		output_from_past[:, :, random_slice_idx].detach()

   self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]       )

   # test that outputs are equal for slice
   self.parent.assertTrue(torch.allclose(lowerCamelCase				,   lowerCamelCase				,   atol=1e-3       )       )
 def 		lowercase_(   self			:    Optional[int]				,   lowerCamelCase			:    Tuple				,   lowerCamelCase			:    List[Any]				,   lowerCamelCase			:    Optional[Any]				,   lowerCamelCase			:    Optional[int]				,   lowerCamelCase			:    Dict				,   *lowerCamelCase			:    str				,   lowerCamelCase			:    Tuple=False       ):



   """simple docstring"""





   __A		:     List[Any]												=		BioGptForCausalLM(lowerCamelCase       )
   model.to(lowerCamelCase       )
   if gradient_checkpointing:
     model.gradient_checkpointing_enable()

   __A		:     Optional[int]												=		model(lowerCamelCase				,   labels=lowerCamelCase       )
   self.parent.assertEqual(result.loss.shape				,   ()       )
   self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.seq_length, self.vocab_size)       )
   result.loss.backward()
 def 		lowercase_(   self			:    Union[str, Any]				,   lowerCamelCase			:    Tuple				,   *lowerCamelCase			:    Optional[int]       ):



   """simple docstring"""





   __A		:     int												=		BioGptModel(lowerCamelCase       )
   __A		:     List[Any]												=		model.config.initializer_range / math.sqrt(2 * model.config.num_hidden_layers       )
   for key in model.state_dict().keys():
     if "c_proj" in key and "weight" in key:
       self.parent.assertLessEqual(abs(torch.std(model.state_dict()[key]       ) - model_std       )				,   0.001       )
       self.parent.assertLessEqual(abs(torch.mean(model.state_dict()[key]       ) - 0.0       )				,   0.01       )
 def 		lowercase_(   self			:    Any				,   lowerCamelCase			:    Optional[int]				,   lowerCamelCase			:    Optional[int]				,   lowerCamelCase			:    Any				,   lowerCamelCase			:    Optional[Any]				,   lowerCamelCase			:    Dict				,   *lowerCamelCase			:    List[str]       ):



   """simple docstring"""





   __A		:     int												=		self.num_labels
   __A		:     Optional[int]												=		BioGptForTokenClassification(lowerCamelCase       )
   model.to(lowerCamelCase       )
   model.eval()
   __A		:     List[Any]												=		model(lowerCamelCase				,   attention_mask=lowerCamelCase				,   token_type_ids=lowerCamelCase       )
   self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.seq_length, self.num_labels)       )






 def 		lowercase_(   self			:    List[str]       ):



   """simple docstring"""





   __A		:     Optional[Any]												=		self.prepare_config_and_inputs()
   (
       (
       __A
   )							,					(
       __A
   )							,					(
       __A
   )							,					(
       __A
   )							,					(
       __A
   )							,					(
       __A
   )							,					(
       __A
   )							,					
   )		:     Dict												=		config_and_inputs
   __A		:     str												=		{"""input_ids""": input_ids, """attention_mask""": input_mask}
   return config, inputs_dict







@require_torch
class  __A				( _SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						unittest.TestCase			):
 lowerCamelCase				       =(
     (BioGptModel, BioGptForCausalLM, BioGptForSequenceClassification, BioGptForTokenClassification)
     if is_torch_available()
     else ()
 )
 lowerCamelCase				       =(BioGptForCausalLM,) if is_torch_available() else ()
 lowerCamelCase				       =(
     {
         '''feature-extraction''': BioGptModel,
         '''text-classification''': BioGptForSequenceClassification,
         '''text-generation''': BioGptForCausalLM,
         '''token-classification''': BioGptForTokenClassification,
         '''zero-shot''': BioGptForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 lowerCamelCase				       =False
 def 		lowercase_(   self			:    int       ):



   """simple docstring"""





   __A		:     Union[str, Any]												=		BioGptModelTester(self       )
   __A		:     str												=		ConfigTester(self				,   config_class=lowerCamelCase				,   hidden_size=37       )
 def 		lowercase_(   self			:    int       ):



   """simple docstring"""





   self.config_tester.run_common_tests()
 def 		lowercase_(   self			:    str       ):



   """simple docstring"""





   __A		:     str												=		self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*lowerCamelCase       )
 def 		lowercase_(   self			:    Optional[int]       ):



   """simple docstring"""





   __A		:     Any												=		self.model_tester.prepare_config_and_inputs()
   for type in ["absolute", "relative_key", "relative_key_query"]:
     __A		:     Optional[int]												=		type
     self.model_tester.create_and_check_model(*lowerCamelCase       )
 def 		lowercase_(   self			:    Any       ):



   """simple docstring"""





   __A		:     Union[str, Any]												=		self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_biogpt_model_attention_mask_past(*lowerCamelCase       )
 def 		lowercase_(   self			:    int       ):



   """simple docstring"""





   __A		:     Any												=		self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_forward_and_backwards(*lowerCamelCase				,   gradient_checkpointing=lowerCamelCase       )
 def 		lowercase_(   self			:    List[str]       ):



   """simple docstring"""





   __A		:     Union[str, Any]												=		self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_biogpt_model_past_large_inputs(*lowerCamelCase       )
 def 		lowercase_(   self			:    int       ):



   """simple docstring"""





   __A		:     Dict												=		self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_biogpt_weight_initialization(*lowerCamelCase       )
 def 		lowercase_(   self			:    str       ):



   """simple docstring"""





   __A		:     str												=		self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_biogpt_for_token_classification(*lowerCamelCase       )
 @slow
 def 		lowercase_(   self			:    Union[str, Any]       ):



   """simple docstring"""





   __A		:     List[Any]												=		BioGptForCausalLM.from_pretrained("""microsoft/biogpt"""       )
   model.to(lowerCamelCase       )
   __A		:     Optional[Any]												=		BioGptTokenizer.from_pretrained("""microsoft/biogpt"""       )

   __A		:     str												=		"""left"""

   # Define PAD Token = EOS Token = 50256
   __A		:     List[Any]												=		tokenizer.eos_token
   __A		:     int												=		model.config.eos_token_id

   # use different length sentences to test batching
   __A		:     str												=		[
       """Hello, my dog is a little""",
       """Today, I""",
   ]

   __A		:     Optional[int]												=		tokenizer(lowerCamelCase				,   return_tensors="""pt"""				,   padding=lowerCamelCase       )
   __A		:     int												=		inputs["""input_ids"""].to(lowerCamelCase       )

   __A		:     Dict												=		model.generate(
       input_ids=lowerCamelCase				,   attention_mask=inputs["""attention_mask"""].to(lowerCamelCase       )				,   )

   __A		:     int												=		tokenizer(sentences[0]				,   return_tensors="""pt"""       ).input_ids.to(lowerCamelCase       )
   __A		:     List[Any]												=		model.generate(input_ids=lowerCamelCase       )

   __A		:     int												=		inputs_non_padded.shape[-1] - inputs["""attention_mask"""][-1].long().sum().cpu().item()
   __A		:     Union[str, Any]												=		tokenizer(sentences[1]				,   return_tensors="""pt"""       ).input_ids.to(lowerCamelCase       )
   __A		:     Optional[Any]												=		model.generate(input_ids=lowerCamelCase				,   max_length=model.config.max_length - num_paddings       )

   __A		:     Any												=		tokenizer.batch_decode(lowerCamelCase				,   skip_special_tokens=lowerCamelCase       )
   __A		:     List[Any]												=		tokenizer.decode(output_non_padded[0]				,   skip_special_tokens=lowerCamelCase       )
   __A		:     List[str]												=		tokenizer.decode(output_padded[0]				,   skip_special_tokens=lowerCamelCase       )

   __A		:     str												=		[
       """Hello, my dog is a little bit bigger than a little bit.""",
       """Today, I have a good idea of how to use the information""",
   ]
   self.assertListEqual(lowerCamelCase				,   lowerCamelCase       )
   self.assertListEqual(lowerCamelCase				,   [non_padded_sentence, padded_sentence]       )
 @slow
 def 		lowercase_(   self			:    List[str]       ):



   """simple docstring"""





   for model_name in BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     __A		:     Optional[Any]												=		BioGptModel.from_pretrained(lowerCamelCase       )
     self.assertIsNotNone(lowerCamelCase       )
 def 		lowercase_(   self			:    List[Any]       ):



   """simple docstring"""





   __A							,					__A		:     Tuple												=		self.model_tester.prepare_config_and_inputs_for_common()
   __A		:     List[str]												=		3
   __A		:     List[Any]												=		input_dict["""input_ids"""]
   __A		:     List[str]												=		input_ids.ne(1       ).to(lowerCamelCase       )
   __A		:     Optional[Any]												=		ids_tensor([self.model_tester.batch_size]				,   self.model_tester.type_sequence_label_size       )
   __A		:     List[Any]												=		BioGptForSequenceClassification(lowerCamelCase       )
   model.to(lowerCamelCase       )
   model.eval()
   __A		:     Any												=		model(lowerCamelCase				,   attention_mask=lowerCamelCase				,   labels=lowerCamelCase       )
   self.assertEqual(result.logits.shape				,   (self.model_tester.batch_size, self.model_tester.num_labels)       )






 def 		lowercase_(   self			:    List[Any]       ):



   """simple docstring"""





   __A							,					__A		:     Optional[Any]												=		self.model_tester.prepare_config_and_inputs_for_common()
   __A		:     str												=		3
   __A		:     Dict												=		"""multi_label_classification"""
   __A		:     Union[str, Any]												=		input_dict["""input_ids"""]
   __A		:     List[str]												=		input_ids.ne(1       ).to(lowerCamelCase       )
   __A		:     Tuple												=		ids_tensor(
       [self.model_tester.batch_size, config.num_labels]				,   self.model_tester.type_sequence_label_size       ).to(torch.float       )
   __A		:     List[str]												=		BioGptForSequenceClassification(lowerCamelCase       )
   model.to(lowerCamelCase       )
   model.eval()
   __A		:     Optional[Any]												=		model(lowerCamelCase				,   attention_mask=lowerCamelCase				,   labels=lowerCamelCase       )
   self.assertEqual(result.logits.shape				,   (self.model_tester.batch_size, self.model_tester.num_labels)       )







@require_torch
class  __A				( unittest.TestCase			):
 @slow
 def 		lowercase_(   self			:    Dict       ):



   """simple docstring"""





   __A		:     Tuple												=		BioGptForCausalLM.from_pretrained("""microsoft/biogpt"""       )
   __A		:     Dict												=		torch.tensor([[2, 48_05, 9, 6_56, 21]]       )
   __A		:     Optional[int]												=		model(lowerCamelCase       )[0]

   __A		:     Tuple												=		4_23_84

   __A		:     str												=		torch.Size((1, 5, vocab_size)       )
   self.assertEqual(output.shape				,   lowerCamelCase       )

   __A		:     Optional[int]												=		torch.tensor(
       [[[-9.5_236, -9.8_918, 10.4_557], [-11.0_469, -9.6_423, 8.1_022], [-8.8_664, -7.8_826, 5.5_325]]]       )

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






 @slow
 def 		lowercase_(   self			:    List[str]       ):



   """simple docstring"""





   __A		:     Any												=		BioGptTokenizer.from_pretrained("""microsoft/biogpt"""       )
   __A		:     List[Any]												=		BioGptForCausalLM.from_pretrained("""microsoft/biogpt"""       )
   model.to(lowerCamelCase       )

   torch.manual_seed(0       )
   __A		:     str												=		tokenizer("""COVID-19 is"""				,   return_tensors="""pt"""       ).to(lowerCamelCase       )
   __A		:     str												=		model.generate(
       **lowerCamelCase				,   min_length=1_00				,   max_length=10_24				,   num_beams=5				,   early_stopping=lowerCamelCase				,   )
   __A		:     Union[str, Any]												=		tokenizer.decode(output_ids[0]				,   skip_special_tokens=lowerCamelCase       )

   __A		:     Optional[Any]												=		(
       """COVID-19 is a global pandemic caused by severe acute respiratory syndrome coronavirus 2 (SARS-CoV-2), the"""
       """ causative agent of coronavirus disease 2019 (COVID-19), which has spread to more than 200 countries and"""
       """ territories, including the United States (US), Canada, Australia, New Zealand, the United Kingdom (UK),"""
       """ and the United States of America (USA), as of March 11, 2020, with more than 800,000 confirmed cases and"""
       """ more than 800,000 deaths."""
   )
   self.assertEqual(lowerCamelCase				,   lowerCamelCase       )





'''simple docstring'''
A__   :		List[Any] 		=[
    'Audio',
    'Array2D',
    'Array3D',
    'Array4D',
    'Array5D',
    'ClassLabel',
    'Features',
    'Sequence',
    'Value',
    'Image',
    'Translation',
    'TranslationVariableLanguages',
]
from .audio import Audio
from .features import ArrayaD, ArrayaD, ArrayaD, ArrayaD, ClassLabel, Features, Sequence, Value
from .image import Image
from .translation import Translation, TranslationVariableLanguages



