



import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
     from test_module.custom_tokenization_fast import CustomTokenizerFast
class    __UpperCamelCase			(       unittest.TestCase				):

 """simple docstring"""



 def 						_UpperCAmelCase       (	self      ) ->			Dict:
  a__												= 0

 @slow
 def 						_UpperCAmelCase       (	self      ) ->			Dict:
  for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
   a__												= AutoTokenizer.from_pretrained(snake_case_      )
   self.assertIsNotNone(snake_case_      )
   self.assertIsInstance(snake_case_		,				(BertTokenizer, BertTokenizerFast)      )
   self.assertGreater(len(snake_case_      )		,				0      )

  for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
   a__												= AutoTokenizer.from_pretrained(snake_case_      )
   self.assertIsNotNone(snake_case_      )
   self.assertIsInstance(snake_case_		,				(GPTaTokenizer, GPTaTokenizerFast)      )
   self.assertGreater(len(snake_case_      )		,				0      )

 def 						_UpperCAmelCase       (	self      ) ->			str:
  a__												= AutoTokenizer.from_pretrained(snake_case_      )
  self.assertIsInstance(snake_case_		,				(BertTokenizer, BertTokenizerFast)      )
  self.assertEqual(tokenizer.vocab_size		,				1_2      )

 def 						_UpperCAmelCase       (	self      ) ->			Tuple:
  a__												= AutoTokenizer.from_pretrained(snake_case_      )
  self.assertIsInstance(snake_case_		,				(RobertaTokenizer, RobertaTokenizerFast)      )
  self.assertEqual(tokenizer.vocab_size		,				2_0      )

 def 						_UpperCAmelCase       (	self      ) ->			str:
  a__												= AutoConfig.from_pretrained(snake_case_      )
  self.assertIsInstance(snake_case_		,				snake_case_      )
  # Check that tokenizer_type ≠ model_type
  a__												= AutoTokenizer.from_pretrained(snake_case_		,				config=snake_case_      )
  self.assertIsInstance(snake_case_		,				(BertTokenizer, BertTokenizerFast)      )
  self.assertEqual(tokenizer.vocab_size		,				1_2      )

 def 						_UpperCAmelCase       (	self      ) ->			Optional[Any]:
  with tempfile.TemporaryDirectory() as tmp_dir:
   shutil.copy('''./tests/fixtures/vocab.txt'''		,				os.path.join(snake_case_		,				'''vocab.txt'''      )      )

   a__												= AutoTokenizer.from_pretrained(snake_case_		,				tokenizer_type='''bert'''		,				use_fast=snake_case_      )
   self.assertIsInstance(snake_case_		,				snake_case_      )

  with tempfile.TemporaryDirectory() as tmp_dir:
   shutil.copy('''./tests/fixtures/vocab.json'''		,				os.path.join(snake_case_		,				'''vocab.json'''      )      )
   shutil.copy('''./tests/fixtures/merges.txt'''		,				os.path.join(snake_case_		,				'''merges.txt'''      )      )

   a__												= AutoTokenizer.from_pretrained(snake_case_		,				tokenizer_type='''gpt2'''		,				use_fast=snake_case_      )
   self.assertIsInstance(snake_case_		,				snake_case_      )

 @require_tokenizers
 def 						_UpperCAmelCase       (	self      ) ->			Any:
  with tempfile.TemporaryDirectory() as tmp_dir:
   shutil.copy('''./tests/fixtures/vocab.txt'''		,				os.path.join(snake_case_		,				'''vocab.txt'''      )      )

   a__												= AutoTokenizer.from_pretrained(snake_case_		,				tokenizer_type='''bert'''      )
   self.assertIsInstance(snake_case_		,				snake_case_      )

  with tempfile.TemporaryDirectory() as tmp_dir:
   shutil.copy('''./tests/fixtures/vocab.json'''		,				os.path.join(snake_case_		,				'''vocab.json'''      )      )
   shutil.copy('''./tests/fixtures/merges.txt'''		,				os.path.join(snake_case_		,				'''merges.txt'''      )      )

   a__												= AutoTokenizer.from_pretrained(snake_case_		,				tokenizer_type='''gpt2'''      )
   self.assertIsInstance(snake_case_		,				snake_case_      )

 def 						_UpperCAmelCase       (	self      ) ->			Optional[Any]:
  with pytest.raises(snake_case_      ):
   AutoTokenizer.from_pretrained('''./'''		,				tokenizer_type='''xxx'''      )

 @require_tokenizers
 def 						_UpperCAmelCase       (	self      ) ->			Tuple:
  for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
   a__												= tokenizer_class.from_pretrained('''wietsedv/bert-base-dutch-cased'''      )
   self.assertIsInstance(snake_case_		,				(BertTokenizer, BertTokenizerFast)      )

   if isinstance(snake_case_		,				snake_case_      ):
    self.assertEqual(tokenizer.basic_tokenizer.do_lower_case		,				snake_case_      )
   else:
    self.assertEqual(tokenizer.do_lower_case		,				snake_case_      )

   self.assertEqual(tokenizer.model_max_length		,				5_1_2      )

 @require_tokenizers
 def 						_UpperCAmelCase       (	self      ) ->			int:
  for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
   with self.assertRaisesRegex(
       snake_case_		,				'''julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier'''		,				):
    a__												= tokenizer_class.from_pretrained('''julien-c/herlolip-not-exists'''      )

 def 						_UpperCAmelCase       (	self      ) ->			List[str]:
  # tests: https://github.com/huggingface/transformers/pull/13251
  # 1. models with `-`, e.g. xlm-roberta -> xlm_roberta
  # 2. models that don't remap 1-1 from model-name to model file, e.g., openai-gpt -> openai
  a__												= TOKENIZER_MAPPING.values()
  a__												= []

  for slow_tok, fast_tok in tokenizers:
   if slow_tok is not None:
    tokenizer_names.append(slow_tok.__name__      )

   if fast_tok is not None:
    tokenizer_names.append(fast_tok.__name__      )

  for tokenizer_name in tokenizer_names:
   # must find the right class
   tokenizer_class_from_name(snake_case_      )

 @require_tokenizers
 def 						_UpperCAmelCase       (	self      ) ->			Union[str, Any]:
  self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''		,				use_fast=snake_case_      )		,				snake_case_      )
  self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''      )		,				snake_case_      )

 @require_tokenizers
 def 						_UpperCAmelCase       (	self      ) ->			Any:
  a__												= AutoTokenizer.from_pretrained('''distilbert-base-uncased'''		,				do_lower_case=snake_case_      )
  a__												= """Hello, world. How are you?"""
  a__												= tokenizer.tokenize(snake_case_      )
  self.assertEqual('''[UNK]'''		,				tokens[0]      )

  a__												= AutoTokenizer.from_pretrained('''microsoft/mpnet-base'''		,				do_lower_case=snake_case_      )
  a__												= tokenizer.tokenize(snake_case_      )
  self.assertEqual('''[UNK]'''		,				tokens[0]      )

 @require_tokenizers
 def 						_UpperCAmelCase       (	self      ) ->			Optional[int]:
  a__												= AutoTokenizer.from_pretrained('''robot-test/dummy-tokenizer-fast-with-model-config'''      )
  self.assertEqual(type(snake_case_      )		,				snake_case_      )
  self.assertEqual(tokenizer.model_max_length		,				5_1_2      )
  self.assertEqual(tokenizer.vocab_size		,				3_0_0_0_0      )
  self.assertEqual(tokenizer.unk_token		,				'''[UNK]'''      )
  self.assertEqual(tokenizer.padding_side		,				'''right'''      )
  self.assertEqual(tokenizer.truncation_side		,				'''right'''      )

 def 						_UpperCAmelCase       (	self      ) ->			List[Any]:
  a__												= AutoTokenizer.from_pretrained(snake_case_      )
  self.assertIsInstance(snake_case_		,				(BertTokenizer, BertTokenizerFast)      )
  with tempfile.TemporaryDirectory() as tmp_dir:
   tokenizer.save_pretrained(snake_case_      )
   a__												= AutoTokenizer.from_pretrained(snake_case_      )

  self.assertIsInstance(snake_case_		,				tokenizer.__class__      )
  self.assertEqual(tokenizera.vocab_size		,				1_2      )

 def 						_UpperCAmelCase       (	self      ) ->			Dict:
  a__												= AutoTokenizer.from_pretrained('''ctrl'''      )
  # There is no fast CTRL so this always gives us a slow tokenizer.
  self.assertIsInstance(snake_case_		,				snake_case_      )

 def 						_UpperCAmelCase       (	self      ) ->			int:
  # Check we can load the tokenizer config of an online model.
  a__												= get_tokenizer_config('''bert-base-cased'''      )
  a__												= config.pop('''_commit_hash'''		,				snake_case_      )
  # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
  self.assertEqual(snake_case_		,				{'''do_lower_case''': False}      )

  # This model does not have a tokenizer_config so we get back an empty dict.
  a__												= get_tokenizer_config(snake_case_      )
  self.assertDictEqual(snake_case_		,				{}      )

  # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
  a__												= AutoTokenizer.from_pretrained(snake_case_      )
  with tempfile.TemporaryDirectory() as tmp_dir:
   tokenizer.save_pretrained(snake_case_      )
   a__												= get_tokenizer_config(snake_case_      )

  # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
  self.assertEqual(config['''tokenizer_class''']		,				'''BertTokenizer'''      )

 def 						_UpperCAmelCase       (	self      ) ->			List[str]:
  try:
   AutoConfig.register('''custom'''		,				snake_case_      )

   AutoTokenizer.register(snake_case_		,				slow_tokenizer_class=snake_case_      )
   # Trying to register something existing in the Transformers library will raise an error
   with self.assertRaises(snake_case_      ):
    AutoTokenizer.register(snake_case_		,				slow_tokenizer_class=snake_case_      )

   a__												= CustomTokenizer.from_pretrained(snake_case_      )
   with tempfile.TemporaryDirectory() as tmp_dir:
    tokenizer.save_pretrained(snake_case_      )

    a__												= AutoTokenizer.from_pretrained(snake_case_      )
    self.assertIsInstance(snake_case_		,				snake_case_      )

  finally:
   if "custom" in CONFIG_MAPPING._extra_content:
    del CONFIG_MAPPING._extra_content["custom"]
   if CustomConfig in TOKENIZER_MAPPING._extra_content:
    del TOKENIZER_MAPPING._extra_content[CustomConfig]

 @require_tokenizers
 def 						_UpperCAmelCase       (	self      ) ->			Tuple:
  try:
   AutoConfig.register('''custom'''		,				snake_case_      )

   # Can register in two steps
   AutoTokenizer.register(snake_case_		,				slow_tokenizer_class=snake_case_      )
   self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,				(CustomTokenizer, None)      )
   AutoTokenizer.register(snake_case_		,				fast_tokenizer_class=snake_case_      )
   self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,				(CustomTokenizer, CustomTokenizerFast)      )

   del TOKENIZER_MAPPING._extra_content[CustomConfig]
   # Can register in one step
   AutoTokenizer.register(
       snake_case_		,				slow_tokenizer_class=snake_case_		,				fast_tokenizer_class=snake_case_      )
   self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,				(CustomTokenizer, CustomTokenizerFast)      )

   # Trying to register something existing in the Transformers library will raise an error
   with self.assertRaises(snake_case_      ):
    AutoTokenizer.register(snake_case_		,				fast_tokenizer_class=snake_case_      )

   # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
   # and that model does not have a tokenizer.json
   with tempfile.TemporaryDirectory() as tmp_dir:
    a__												= BertTokenizerFast.from_pretrained(snake_case_      )
    bert_tokenizer.save_pretrained(snake_case_      )
    a__												= CustomTokenizerFast.from_pretrained(snake_case_      )

   with tempfile.TemporaryDirectory() as tmp_dir:
    tokenizer.save_pretrained(snake_case_      )

    a__												= AutoTokenizer.from_pretrained(snake_case_      )
    self.assertIsInstance(snake_case_		,				snake_case_      )

    a__												= AutoTokenizer.from_pretrained(snake_case_		,				use_fast=snake_case_      )
    self.assertIsInstance(snake_case_		,				snake_case_      )

  finally:
   if "custom" in CONFIG_MAPPING._extra_content:
    del CONFIG_MAPPING._extra_content["custom"]
   if CustomConfig in TOKENIZER_MAPPING._extra_content:
    del TOKENIZER_MAPPING._extra_content[CustomConfig]

 def 						_UpperCAmelCase       (	self      ) ->			Dict:
  # If remote code is not set, we will time out when asking whether to load the model.
  with self.assertRaises(snake_case_      ):
   a__												= AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''      )
  # If remote code is disabled, we can't load this config.
  with self.assertRaises(snake_case_      ):
   a__												= AutoTokenizer.from_pretrained(
       '''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=snake_case_      )

  a__												= AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=snake_case_      )
  self.assertTrue(tokenizer.special_attribute_present      )
  # Test tokenizer can be reloaded.
  with tempfile.TemporaryDirectory() as tmp_dir:
   tokenizer.save_pretrained(snake_case_      )
   a__												= AutoTokenizer.from_pretrained(snake_case_		,				trust_remote_code=snake_case_      )
  self.assertTrue(reloaded_tokenizer.special_attribute_present      )

  if is_tokenizers_available():
   self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizerFast'''      )
   self.assertEqual(reloaded_tokenizer.__class__.__name__		,				'''NewTokenizerFast'''      )

   # Test we can also load the slow version
   a__												= AutoTokenizer.from_pretrained(
       '''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=snake_case_		,				use_fast=snake_case_      )
   self.assertTrue(tokenizer.special_attribute_present      )
   self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer'''      )
   # Test tokenizer can be reloaded.
   with tempfile.TemporaryDirectory() as tmp_dir:
    tokenizer.save_pretrained(snake_case_      )
    a__												= AutoTokenizer.from_pretrained(snake_case_		,				trust_remote_code=snake_case_		,				use_fast=snake_case_      )
   self.assertEqual(reloaded_tokenizer.__class__.__name__		,				'''NewTokenizer'''      )
   self.assertTrue(reloaded_tokenizer.special_attribute_present      )
  else:
   self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer'''      )
   self.assertEqual(reloaded_tokenizer.__class__.__name__		,				'''NewTokenizer'''      )

 @require_tokenizers
 def 						_UpperCAmelCase       (	self      ) ->			Optional[int]:
  class    __UpperCamelCase			(       _a				):

   """simple docstring"""



   _lowercase   :    int      						=					False





  class    __UpperCamelCase			(       _a				):

   """simple docstring"""



   _lowercase   :    List[str]      						=					NewTokenizer
   _lowercase   :    Any      						=					False

  try:
   AutoConfig.register('''custom'''		,				snake_case_      )
   AutoTokenizer.register(snake_case_		,				slow_tokenizer_class=snake_case_      )
   AutoTokenizer.register(snake_case_		,				fast_tokenizer_class=snake_case_      )
   # If remote code is not set, the default is to use local
   a__												= AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''      )
   self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizerFast'''      )
   self.assertFalse(tokenizer.special_attribute_present      )
   a__												= AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''		,				use_fast=snake_case_      )
   self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer'''      )
   self.assertFalse(tokenizer.special_attribute_present      )

   # If remote code is disabled, we load the local one.
   a__												= AutoTokenizer.from_pretrained(
       '''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=snake_case_      )
   self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizerFast'''      )
   self.assertFalse(tokenizer.special_attribute_present      )
   a__												= AutoTokenizer.from_pretrained(
       '''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=snake_case_		,				use_fast=snake_case_      )
   self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer'''      )
   self.assertFalse(tokenizer.special_attribute_present      )

   # If remote is enabled, we load from the Hub
   a__												= AutoTokenizer.from_pretrained(
       '''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=snake_case_      )
   self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizerFast'''      )
   self.assertTrue(tokenizer.special_attribute_present      )
   a__												= AutoTokenizer.from_pretrained(
       '''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=snake_case_		,				use_fast=snake_case_      )
   self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer'''      )
   self.assertTrue(tokenizer.special_attribute_present      )

  finally:
   if "custom" in CONFIG_MAPPING._extra_content:
    del CONFIG_MAPPING._extra_content["custom"]
   if CustomConfig in TOKENIZER_MAPPING._extra_content:
    del TOKENIZER_MAPPING._extra_content[CustomConfig]

 def 						_UpperCAmelCase       (	self      ) ->			Tuple:
  a__												= AutoTokenizer.from_pretrained(
      '''hf-internal-testing/test_dynamic_tokenizer_legacy'''		,				trust_remote_code=snake_case_      )
  self.assertTrue(tokenizer.special_attribute_present      )
  if is_tokenizers_available():
   self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizerFast'''      )

   # Test we can also load the slow version
   a__												= AutoTokenizer.from_pretrained(
       '''hf-internal-testing/test_dynamic_tokenizer_legacy'''		,				trust_remote_code=snake_case_		,				use_fast=snake_case_      )
   self.assertTrue(tokenizer.special_attribute_present      )
   self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer'''      )
  else:
   self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer'''      )

 def 						_UpperCAmelCase       (	self      ) ->			Any:
  with self.assertRaisesRegex(
      snake_case_		,				'''bert-base is not a local folder and is not a valid model identifier'''      ):
   a__												= AutoTokenizer.from_pretrained('''bert-base'''      )

 def 						_UpperCAmelCase       (	self      ) ->			List[Any]:
  with self.assertRaisesRegex(
      snake_case_		,				R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''      ):
   a__												= AutoTokenizer.from_pretrained(snake_case_		,				revision='''aaaaaa'''      )



 def 						_UpperCAmelCase       (	self      ) ->			Union[str, Any]:
  # Make sure we have cached the tokenizer.
  a__												= AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''      )
  with RequestCounter() as counter:
   a__												= AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''      )
   self.assertEqual(counter.get_request_count		,				0      )
   self.assertEqual(counter.head_request_count		,				1      )
   self.assertEqual(counter.other_request_count		,				0      )










'''simple docstring'''





import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation







class        UpperCAmelCase_			(			unittest.TestCase      ):
    """simple docstring"""







    def lowerCamelCase			(       self   :	Union[str, Any]		):
          snake_case__    :       int       		= get_activation("""swish"""		)

          self.assertIsInstance(snake_case_					,	nn.SiLU		)

          self.assertEqual(act(torch.tensor(-100					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertNotEqual(act(torch.tensor(-1					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(0					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(20					,	dtype=torch.floataa		)		).item()					,	20		)




    def lowerCamelCase			(       self   :	Optional[Any]		):
          snake_case__    :       int       		= get_activation("""silu"""		)

          self.assertIsInstance(snake_case_					,	nn.SiLU		)

          self.assertEqual(act(torch.tensor(-100					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertNotEqual(act(torch.tensor(-1					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(0					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(20					,	dtype=torch.floataa		)		).item()					,	20		)




    def lowerCamelCase			(       self   :	Dict		):
          snake_case__    :       Union[str, Any]       		= get_activation("""mish"""		)

          self.assertIsInstance(snake_case_					,	nn.Mish		)

          self.assertEqual(act(torch.tensor(-200					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertNotEqual(act(torch.tensor(-1					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(0					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(20					,	dtype=torch.floataa		)		).item()					,	20		)




    def lowerCamelCase			(       self   :	Union[str, Any]		):
          snake_case__    :       int       		= get_activation("""gelu"""		)

          self.assertIsInstance(snake_case_					,	nn.GELU		)

          self.assertEqual(act(torch.tensor(-100					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertNotEqual(act(torch.tensor(-1					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(0					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(20					,	dtype=torch.floataa		)		).item()					,	20		)
