code stringlengths 82 54.1k | code_codestyle int64 0 699 | style_context stringlengths 111 35.6k | style_context_codestyle int64 0 699 | label int64 0 1 |
|---|---|---|---|---|
"""simple docstring"""
import math
from datetime import datetime, timedelta
def lowerCamelCase (a_ :int) -> datetime:
lowercase :Optional[int] = year % 19
lowercase :Union[str, Any] = year % 4
lowercase :str = year % 7
lowercase :List[str] = math.floor(year / 100)
lowercase :Dict = math.floor((13 + 8 * leap_day_inhibits) / 25)
lowercase :str = leap_day_inhibits / 4
lowercase :List[str] = (
15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
) % 30
lowercase :List[Any] = (4 + leap_day_inhibits - leap_day_reinstall_number) % 7
# days to be added to March 21
lowercase :Optional[Any] = (19 * metonic_cycle + secular_moon_shift) % 30
# PHM -> Paschal Full Moon
lowercase :Optional[int] = (
2 * julian_leap_year
+ 4 * non_leap_year
+ 6 * days_to_add
+ century_starting_point
) % 7
if days_to_add == 29 and days_from_phm_to_sunday == 6:
return datetime(a_ , 4 , 19)
elif days_to_add == 28 and days_from_phm_to_sunday == 6:
return datetime(a_ , 4 , 18)
else:
return datetime(a_ , 3 , 22) + timedelta(
days=int(days_to_add + days_from_phm_to_sunday))
if __name__ == "__main__":
for year in (1_994, 2_000, 2_010, 2_021, 2_023):
UpperCAmelCase = '''will be''' if year > datetime.now().year else '''was'''
print(F"""Easter in {year} {tense} {gauss_easter(year)}""")
| 677 |
"""simple docstring"""
from typing import List, Optional, Union
from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
class __magic_name__ ( __UpperCAmelCase ):
__A : Tuple = ["image_processor", "tokenizer"]
__A : Dict = "BlipImageProcessor"
__A : Dict = "AutoTokenizer"
def __init__( self : Any , snake_case__ : Union[str, Any] , snake_case__ : str ):
'''simple docstring'''
lowercase :Dict = False
super().__init__(snake_case__ , snake_case__ )
lowercase :Union[str, Any] = self.image_processor
def __call__( self : Optional[int] , snake_case__ : ImageInput = None , snake_case__ : Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None , snake_case__ : bool = True , snake_case__ : Union[bool, str, PaddingStrategy] = False , snake_case__ : Union[bool, str, TruncationStrategy] = None , snake_case__ : Optional[int] = None , snake_case__ : int = 0 , snake_case__ : Optional[int] = None , snake_case__ : Optional[bool] = None , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = True , snake_case__ : Optional[Union[str, TensorType]] = None , **snake_case__ : Optional[Any] , ):
'''simple docstring'''
if images is None and text is None:
raise ValueError('''You have to specify either images or text.''' )
# Get only text
if images is None:
lowercase :List[Any] = self.tokenizer
lowercase :str = self.tokenizer(
text=snake_case__ , add_special_tokens=snake_case__ , padding=snake_case__ , truncation=snake_case__ , max_length=snake_case__ , stride=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , return_overflowing_tokens=snake_case__ , return_special_tokens_mask=snake_case__ , return_offsets_mapping=snake_case__ , return_token_type_ids=snake_case__ , return_length=snake_case__ , verbose=snake_case__ , return_tensors=snake_case__ , **snake_case__ , )
return text_encoding
# add pixel_values
lowercase :Union[str, Any] = self.image_processor(snake_case__ , return_tensors=snake_case__ )
if text is not None:
lowercase :int = self.tokenizer(
text=snake_case__ , add_special_tokens=snake_case__ , padding=snake_case__ , truncation=snake_case__ , max_length=snake_case__ , stride=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , return_overflowing_tokens=snake_case__ , return_special_tokens_mask=snake_case__ , return_offsets_mapping=snake_case__ , return_token_type_ids=snake_case__ , return_length=snake_case__ , verbose=snake_case__ , return_tensors=snake_case__ , **snake_case__ , )
else:
lowercase :Optional[int] = None
if text_encoding is not None:
encoding_image_processor.update(snake_case__ )
return encoding_image_processor
def __snake_case ( self : Tuple , *snake_case__ : List[Any] , **snake_case__ : Tuple ):
'''simple docstring'''
return self.tokenizer.batch_decode(*snake_case__ , **snake_case__ )
def __snake_case ( self : List[str] , *snake_case__ : Dict , **snake_case__ : List[Any] ):
'''simple docstring'''
return self.tokenizer.decode(*snake_case__ , **snake_case__ )
@property
# Copied from transformers.models.blip.processing_blip.BlipProcessor.model_input_names
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase :List[Any] = self.tokenizer.model_input_names
lowercase :List[Any] = self.image_processor.model_input_names
return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) )
| 677 | 1 |
"""simple docstring"""
import argparse
import os
import re
# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_dummies.py
UpperCAmelCase = '''src/diffusers'''
# Matches is_xxx_available()
UpperCAmelCase = re.compile(R'''is\_([a-z_]*)_available\(\)''')
# Matches from xxx import bla
UpperCAmelCase = re.compile(R'''\s+from\s+\S*\s+import\s+([^\(\s].*)\n''')
UpperCAmelCase = '''
{0} = None
'''
UpperCAmelCase = '''
class {0}(metaclass=DummyObject):
_backends = {1}
def __init__(self, *args, **kwargs):
requires_backends(self, {1})
@classmethod
def from_config(cls, *args, **kwargs):
requires_backends(cls, {1})
@classmethod
def from_pretrained(cls, *args, **kwargs):
requires_backends(cls, {1})
'''
UpperCAmelCase = '''
def {0}(*args, **kwargs):
requires_backends({0}, {1})
'''
def lowerCamelCase (a_ :Dict) -> Optional[int]:
lowercase :Union[str, Any] = _re_backend.findall(a_)
if len(a_) == 0:
return None
return "_and_".join(a_)
def lowerCamelCase () -> List[Any]:
with open(os.path.join(a_ , '''__init__.py''') , '''r''' , encoding='''utf-8''' , newline='''\n''') as f:
lowercase :List[str] = f.readlines()
# Get to the point we do the actual imports for type checking
lowercase :List[str] = 0
lowercase :str = {}
# Go through the end of the file
while line_index < len(a_):
# If the line contains is_backend_available, we grab all objects associated with the `else` block
lowercase :Optional[int] = find_backend(lines[line_index])
if backend is not None:
while not lines[line_index].startswith('''else:'''):
line_index += 1
line_index += 1
lowercase :List[Any] = []
# Until we unindent, add backend objects to the list
while line_index < len(a_) and len(lines[line_index]) > 1:
lowercase :List[Any] = lines[line_index]
lowercase :int = _re_single_line_import.search(a_)
if single_line_import_search is not None:
objects.extend(single_line_import_search.groups()[0].split(''', '''))
elif line.startswith(''' ''' * 8):
objects.append(line[8:-2])
line_index += 1
if len(a_) > 0:
lowercase :Optional[Any] = objects
else:
line_index += 1
return backend_specific_objects
def lowerCamelCase (a_ :Tuple , a_ :Any) -> Union[str, Any]:
if name.isupper():
return DUMMY_CONSTANT.format(a_)
elif name.islower():
return DUMMY_FUNCTION.format(a_ , a_)
else:
return DUMMY_CLASS.format(a_ , a_)
def lowerCamelCase (a_ :Optional[Any]=None) -> int:
if backend_specific_objects is None:
lowercase :int = read_init()
# For special correspondence backend to module name as used in the function requires_modulename
lowercase :Optional[Any] = {}
for backend, objects in backend_specific_objects.items():
lowercase :List[Any] = '''[''' + ''', '''.join(F"""\"{b}\"""" for b in backend.split('''_and_''')) + ''']'''
lowercase :Union[str, Any] = '''# This file is autogenerated by the command `make fix-copies`, do not edit.\n'''
dummy_file += "from ..utils import DummyObject, requires_backends\n\n"
dummy_file += "\n".join([create_dummy_object(a_ , a_) for o in objects])
lowercase :Optional[Any] = dummy_file
return dummy_files
def lowerCamelCase (a_ :Union[str, Any]=False) -> int:
lowercase :int = create_dummy_files()
# For special correspondence backend to shortcut as used in utils/dummy_xxx_objects.py
lowercase :Dict = {'''torch''': '''pt'''}
# Locate actual dummy modules and read their content.
lowercase :Optional[int] = os.path.join(a_ , '''utils''')
lowercase :List[str] = {
backend: os.path.join(a_ , F"""dummy_{short_names.get(a_ , a_)}_objects.py""")
for backend in dummy_files.keys()
}
lowercase :Optional[int] = {}
for backend, file_path in dummy_file_paths.items():
if os.path.isfile(a_):
with open(a_ , '''r''' , encoding='''utf-8''' , newline='''\n''') as f:
lowercase :Union[str, Any] = f.read()
else:
lowercase :List[Any] = ''''''
for backend in dummy_files.keys():
if dummy_files[backend] != actual_dummies[backend]:
if overwrite:
print(
F"""Updating diffusers.utils.dummy_{short_names.get(a_ , a_)}_objects.py as the main """
'''__init__ has new objects.''')
with open(dummy_file_paths[backend] , '''w''' , encoding='''utf-8''' , newline='''\n''') as f:
f.write(dummy_files[backend])
else:
raise ValueError(
'''The main __init__ has objects that are not present in '''
F"""diffusers.utils.dummy_{short_names.get(a_ , a_)}_objects.py. Run `make fix-copies` """
'''to fix this.''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
parser.add_argument('''--fix_and_overwrite''', action='''store_true''', help='''Whether to fix inconsistencies.''')
UpperCAmelCase = parser.parse_args()
check_dummies(args.fix_and_overwrite)
| 677 |
"""simple docstring"""
import subprocess
import sys
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch
class __magic_name__ ( __UpperCAmelCase ):
@require_torch
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Optional[Any] = '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
'''
lowercase :Any = '''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
'''
lowercase :Tuple = '''
import socket
def offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")
socket.socket = offline_socket
'''
# Force fetching the files so that we can use the cache
lowercase :str = '''hf-internal-testing/tiny-random-bert'''
BertConfig.from_pretrained(snake_case__ )
BertModel.from_pretrained(snake_case__ )
BertTokenizer.from_pretrained(snake_case__ )
pipeline(task='''fill-mask''' , model=snake_case__ )
# baseline - just load from_pretrained with normal network
lowercase :Union[str, Any] = [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]
# should succeed
lowercase :Any = self.get_env()
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :List[Any] = '''1'''
lowercase :List[str] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :List[str] = '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
'''
lowercase :Dict = '''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
'''
lowercase :List[Any] = '''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")
socket.socket = offline_socket
'''
# Force fetching the files so that we can use the cache
lowercase :str = '''hf-internal-testing/tiny-random-bert'''
BertConfig.from_pretrained(snake_case__ )
BertModel.from_pretrained(snake_case__ )
BertTokenizer.from_pretrained(snake_case__ )
pipeline(task='''fill-mask''' , model=snake_case__ )
# baseline - just load from_pretrained with normal network
lowercase :List[str] = [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]
# should succeed
lowercase :str = self.get_env()
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : int ):
'''simple docstring'''
lowercase :str = '''
from transformers import BertConfig, BertModel, BertTokenizer
'''
lowercase :Union[str, Any] = '''
mname = "hf-internal-testing/tiny-random-bert-sharded"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
print("success")
'''
lowercase :Optional[int] = '''
import socket
def offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")
socket.socket = offline_socket
'''
# baseline - just load from_pretrained with normal network
lowercase :Optional[Any] = [sys.executable, '''-c''', '''\n'''.join([load, run] )]
# should succeed
lowercase :Union[str, Any] = self.get_env()
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
# next emulate no network
lowercase :Tuple = [sys.executable, '''-c''', '''\n'''.join([load, mock, run] )]
# Doesn't fail anymore since the model is in the cache due to other tests, so commenting this.
# env["TRANSFORMERS_OFFLINE"] = "0"
# result = subprocess.run(cmd, env=env, check=False, capture_output=True)
# self.assertEqual(result.returncode, 1, result.stderr)
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :Any = '''1'''
lowercase :Optional[Any] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :Dict = '''
from transformers import pipeline
'''
lowercase :Optional[Any] = '''
mname = "hf-internal-testing/tiny-random-bert"
pipe = pipeline(model=mname)
'''
lowercase :Dict = '''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")
socket.socket = offline_socket
'''
lowercase :Tuple = self.get_env()
lowercase :Optional[Any] = '''1'''
lowercase :Optional[int] = [sys.executable, '''-c''', '''\n'''.join([load, mock, run] )]
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 1 , result.stderr )
self.assertIn(
'''You cannot infer task automatically within `pipeline` when using offline mode''' , result.stderr.decode().replace('''\n''' , '''''' ) , )
@require_torch
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = '''
from transformers import AutoModel
'''
lowercase :Union[str, Any] = '''
mname = "hf-internal-testing/test_dynamic_model"
AutoModel.from_pretrained(mname, trust_remote_code=True)
print("success")
'''
# baseline - just load from_pretrained with normal network
lowercase :Union[str, Any] = [sys.executable, '''-c''', '''\n'''.join([load, run] )]
# should succeed
lowercase :List[str] = self.get_env()
lowercase :Optional[int] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :List[Any] = '''1'''
lowercase :Tuple = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
| 677 | 1 |
"""simple docstring"""
import argparse
import json
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from typing import List
import timm
import torch
import torch.nn as nn
from huggingface_hub import hf_hub_download
from torch import Tensor
from transformers import AutoImageProcessor, ResNetConfig, ResNetForImageClassification
from transformers.utils import logging
logging.set_verbosity_info()
UpperCAmelCase = logging.get_logger()
@dataclass
class __magic_name__ :
__A : nn.Module
__A : List[nn.Module] = field(default_factory=__UpperCAmelCase )
__A : list = field(default_factory=__UpperCAmelCase )
def __snake_case ( self : List[str] , snake_case__ : List[str] , snake_case__ : Tensor , snake_case__ : Tensor ):
'''simple docstring'''
lowercase :List[str] = len(list(m.modules() ) ) == 1 or isinstance(snake_case__ , nn.Convad ) or isinstance(snake_case__ , nn.BatchNormad )
if has_not_submodules:
self.traced.append(snake_case__ )
def __call__( self : int , snake_case__ : Tensor ):
'''simple docstring'''
for m in self.module.modules():
self.handles.append(m.register_forward_hook(self._forward_hook ) )
self.module(snake_case__ )
[x.remove() for x in self.handles]
return self
@property
def __snake_case ( self : int ):
'''simple docstring'''
return list(filter(lambda snake_case__ : len(list(x.state_dict().keys() ) ) > 0 , self.traced ) )
@dataclass
class __magic_name__ :
__A : nn.Module
__A : nn.Module
__A : int = 0
__A : List = field(default_factory=__UpperCAmelCase )
__A : List = field(default_factory=__UpperCAmelCase )
def __call__( self : Dict , snake_case__ : Tensor ):
'''simple docstring'''
lowercase :Dict = Tracker(self.dest )(snake_case__ ).parametrized
lowercase :Optional[Any] = Tracker(self.src )(snake_case__ ).parametrized
lowercase :List[str] = list(filter(lambda snake_case__ : type(snake_case__ ) not in self.src_skip , snake_case__ ) )
lowercase :Tuple = list(filter(lambda snake_case__ : type(snake_case__ ) not in self.dest_skip , snake_case__ ) )
if len(snake_case__ ) != len(snake_case__ ):
raise Exception(
f"""Numbers of operations are different. Source module has {len(snake_case__ )} operations while"""
f""" destination module has {len(snake_case__ )}.""" )
for dest_m, src_m in zip(snake_case__ , snake_case__ ):
dest_m.load_state_dict(src_m.state_dict() )
if self.verbose == 1:
print(f"""Transfered from={src_m} to={dest_m}""" )
def lowerCamelCase (a_ :str , a_ :ResNetConfig , a_ :Path , a_ :bool = True) -> Optional[Any]:
print(F"""Converting {name}...""")
with torch.no_grad():
lowercase :Union[str, Any] = timm.create_model(a_ , pretrained=a_).eval()
lowercase :Tuple = ResNetForImageClassification(a_).eval()
lowercase :int = ModuleTransfer(src=a_ , dest=a_)
lowercase :List[Any] = torch.randn((1, 3, 224, 224))
module_transfer(a_)
assert torch.allclose(from_model(a_) , our_model(a_).logits), "The model logits don't match the original one."
lowercase :List[Any] = F"""resnet{'-'.join(name.split('resnet'))}"""
print(a_)
if push_to_hub:
our_model.push_to_hub(
repo_path_or_name=save_directory / checkpoint_name , commit_message='''Add model''' , use_temp_dir=a_ , )
# we can use the convnext one
lowercase :Any = AutoImageProcessor.from_pretrained('''facebook/convnext-base-224-22k-1k''')
image_processor.push_to_hub(
repo_path_or_name=save_directory / checkpoint_name , commit_message='''Add image processor''' , use_temp_dir=a_ , )
print(F"""Pushed {checkpoint_name}""")
def lowerCamelCase (a_ :Path , a_ :str = None , a_ :bool = True) -> int:
lowercase :Optional[Any] = '''imagenet-1k-id2label.json'''
lowercase :Union[str, Any] = 1000
lowercase :Any = (1, num_labels)
lowercase :Tuple = '''huggingface/label-files'''
lowercase :List[str] = num_labels
lowercase :Union[str, Any] = json.load(open(hf_hub_download(a_ , a_ , repo_type='''dataset''') , '''r'''))
lowercase :Any = {int(a_): v for k, v in idalabel.items()}
lowercase :str = idalabel
lowercase :Any = {v: k for k, v in idalabel.items()}
lowercase :Union[str, Any] = partial(a_ , num_labels=a_ , idalabel=a_ , labelaid=a_)
lowercase :Optional[int] = {
'''resnet18''': ImageNetPreTrainedConfig(
depths=[2, 2, 2, 2] , hidden_sizes=[64, 128, 256, 512] , layer_type='''basic'''),
'''resnet26''': ImageNetPreTrainedConfig(
depths=[2, 2, 2, 2] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet34''': ImageNetPreTrainedConfig(
depths=[3, 4, 6, 3] , hidden_sizes=[64, 128, 256, 512] , layer_type='''basic'''),
'''resnet50''': ImageNetPreTrainedConfig(
depths=[3, 4, 6, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet101''': ImageNetPreTrainedConfig(
depths=[3, 4, 23, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet152''': ImageNetPreTrainedConfig(
depths=[3, 8, 36, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
}
if model_name:
convert_weight_and_push(a_ , names_to_config[model_name] , a_ , a_)
else:
for model_name, config in names_to_config.items():
convert_weight_and_push(a_ , a_ , a_ , a_)
return config, expected_shape
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'''--model_name''',
default=None,
type=str,
help=(
'''The name of the model you wish to convert, it must be one of the supported resnet* architecture,'''
''' currently: resnet18,26,34,50,101,152. If `None`, all of them will the converted.'''
),
)
parser.add_argument(
'''--pytorch_dump_folder_path''',
default=None,
type=Path,
required=True,
help='''Path to the output PyTorch model directory.''',
)
parser.add_argument(
'''--push_to_hub''',
default=True,
type=bool,
required=False,
help='''If True, push model and image processor to the hub.''',
)
UpperCAmelCase = parser.parse_args()
UpperCAmelCase = args.pytorch_dump_folder_path
pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
| 677 |
"""simple docstring"""
import argparse
import json
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from typing import List
import timm
import torch
import torch.nn as nn
from huggingface_hub import hf_hub_download
from torch import Tensor
from transformers import AutoImageProcessor, ResNetConfig, ResNetForImageClassification
from transformers.utils import logging
logging.set_verbosity_info()
UpperCAmelCase = logging.get_logger()
@dataclass
class __magic_name__ :
__A : nn.Module
__A : List[nn.Module] = field(default_factory=__UpperCAmelCase )
__A : list = field(default_factory=__UpperCAmelCase )
def __snake_case ( self : List[str] , snake_case__ : List[str] , snake_case__ : Tensor , snake_case__ : Tensor ):
'''simple docstring'''
lowercase :List[str] = len(list(m.modules() ) ) == 1 or isinstance(snake_case__ , nn.Convad ) or isinstance(snake_case__ , nn.BatchNormad )
if has_not_submodules:
self.traced.append(snake_case__ )
def __call__( self : int , snake_case__ : Tensor ):
'''simple docstring'''
for m in self.module.modules():
self.handles.append(m.register_forward_hook(self._forward_hook ) )
self.module(snake_case__ )
[x.remove() for x in self.handles]
return self
@property
def __snake_case ( self : int ):
'''simple docstring'''
return list(filter(lambda snake_case__ : len(list(x.state_dict().keys() ) ) > 0 , self.traced ) )
@dataclass
class __magic_name__ :
__A : nn.Module
__A : nn.Module
__A : int = 0
__A : List = field(default_factory=__UpperCAmelCase )
__A : List = field(default_factory=__UpperCAmelCase )
def __call__( self : Dict , snake_case__ : Tensor ):
'''simple docstring'''
lowercase :Dict = Tracker(self.dest )(snake_case__ ).parametrized
lowercase :Optional[Any] = Tracker(self.src )(snake_case__ ).parametrized
lowercase :List[str] = list(filter(lambda snake_case__ : type(snake_case__ ) not in self.src_skip , snake_case__ ) )
lowercase :Tuple = list(filter(lambda snake_case__ : type(snake_case__ ) not in self.dest_skip , snake_case__ ) )
if len(snake_case__ ) != len(snake_case__ ):
raise Exception(
f"""Numbers of operations are different. Source module has {len(snake_case__ )} operations while"""
f""" destination module has {len(snake_case__ )}.""" )
for dest_m, src_m in zip(snake_case__ , snake_case__ ):
dest_m.load_state_dict(src_m.state_dict() )
if self.verbose == 1:
print(f"""Transfered from={src_m} to={dest_m}""" )
def lowerCamelCase (a_ :str , a_ :ResNetConfig , a_ :Path , a_ :bool = True) -> Optional[Any]:
print(F"""Converting {name}...""")
with torch.no_grad():
lowercase :Union[str, Any] = timm.create_model(a_ , pretrained=a_).eval()
lowercase :Tuple = ResNetForImageClassification(a_).eval()
lowercase :int = ModuleTransfer(src=a_ , dest=a_)
lowercase :List[Any] = torch.randn((1, 3, 224, 224))
module_transfer(a_)
assert torch.allclose(from_model(a_) , our_model(a_).logits), "The model logits don't match the original one."
lowercase :List[Any] = F"""resnet{'-'.join(name.split('resnet'))}"""
print(a_)
if push_to_hub:
our_model.push_to_hub(
repo_path_or_name=save_directory / checkpoint_name , commit_message='''Add model''' , use_temp_dir=a_ , )
# we can use the convnext one
lowercase :Any = AutoImageProcessor.from_pretrained('''facebook/convnext-base-224-22k-1k''')
image_processor.push_to_hub(
repo_path_or_name=save_directory / checkpoint_name , commit_message='''Add image processor''' , use_temp_dir=a_ , )
print(F"""Pushed {checkpoint_name}""")
def lowerCamelCase (a_ :Path , a_ :str = None , a_ :bool = True) -> int:
lowercase :Optional[Any] = '''imagenet-1k-id2label.json'''
lowercase :Union[str, Any] = 1000
lowercase :Any = (1, num_labels)
lowercase :Tuple = '''huggingface/label-files'''
lowercase :List[str] = num_labels
lowercase :Union[str, Any] = json.load(open(hf_hub_download(a_ , a_ , repo_type='''dataset''') , '''r'''))
lowercase :Any = {int(a_): v for k, v in idalabel.items()}
lowercase :str = idalabel
lowercase :Any = {v: k for k, v in idalabel.items()}
lowercase :Union[str, Any] = partial(a_ , num_labels=a_ , idalabel=a_ , labelaid=a_)
lowercase :Optional[int] = {
'''resnet18''': ImageNetPreTrainedConfig(
depths=[2, 2, 2, 2] , hidden_sizes=[64, 128, 256, 512] , layer_type='''basic'''),
'''resnet26''': ImageNetPreTrainedConfig(
depths=[2, 2, 2, 2] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet34''': ImageNetPreTrainedConfig(
depths=[3, 4, 6, 3] , hidden_sizes=[64, 128, 256, 512] , layer_type='''basic'''),
'''resnet50''': ImageNetPreTrainedConfig(
depths=[3, 4, 6, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet101''': ImageNetPreTrainedConfig(
depths=[3, 4, 23, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet152''': ImageNetPreTrainedConfig(
depths=[3, 8, 36, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
}
if model_name:
convert_weight_and_push(a_ , names_to_config[model_name] , a_ , a_)
else:
for model_name, config in names_to_config.items():
convert_weight_and_push(a_ , a_ , a_ , a_)
return config, expected_shape
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'''--model_name''',
default=None,
type=str,
help=(
'''The name of the model you wish to convert, it must be one of the supported resnet* architecture,'''
''' currently: resnet18,26,34,50,101,152. If `None`, all of them will the converted.'''
),
)
parser.add_argument(
'''--pytorch_dump_folder_path''',
default=None,
type=Path,
required=True,
help='''Path to the output PyTorch model directory.''',
)
parser.add_argument(
'''--push_to_hub''',
default=True,
type=bool,
required=False,
help='''If True, push model and image processor to the hub.''',
)
UpperCAmelCase = parser.parse_args()
UpperCAmelCase = args.pytorch_dump_folder_path
pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
| 677 | 1 |
"""simple docstring"""
UpperCAmelCase = {
'''A''': ['''B''', '''C''', '''E'''],
'''B''': ['''A''', '''D''', '''E'''],
'''C''': ['''A''', '''F''', '''G'''],
'''D''': ['''B'''],
'''E''': ['''A''', '''B''', '''D'''],
'''F''': ['''C'''],
'''G''': ['''C'''],
}
def lowerCamelCase (a_ :dict , a_ :List[str] , a_ :Tuple) -> list[str]:
lowercase :str = set()
# keep track of all the paths to be checked
lowercase :Dict = [[start]]
# return path if start is goal
if start == goal:
return [start]
# keeps looping until all possible paths have been checked
while queue:
# pop the first path from the queue
lowercase :Optional[int] = queue.pop(0)
# get the last node from the path
lowercase :Any = path[-1]
if node not in explored:
lowercase :int = graph[node]
# go through all neighbour nodes, construct a new path and
# push it into the queue
for neighbour in neighbours:
lowercase :List[Any] = list(a_)
new_path.append(a_)
queue.append(a_)
# return path if neighbour is goal
if neighbour == goal:
return new_path
# mark node as explored
explored.add(a_)
# in case there's no path between the 2 nodes
return []
def lowerCamelCase (a_ :dict , a_ :List[Any] , a_ :List[Any]) -> int:
if not graph or start not in graph or target not in graph:
return -1
if start == target:
return 0
lowercase :List[str] = [start]
lowercase :Optional[Any] = set(a_)
# Keep tab on distances from `start` node.
lowercase :Union[str, Any] = {start: 0, target: -1}
while queue:
lowercase :Union[str, Any] = queue.pop(0)
if node == target:
lowercase :Any = (
dist[node] if dist[target] == -1 else min(dist[target] , dist[node])
)
for adjacent in graph[node]:
if adjacent not in visited:
visited.add(a_)
queue.append(a_)
lowercase :Dict = dist[node] + 1
return dist[target]
if __name__ == "__main__":
print(bfs_shortest_path(demo_graph, '''G''', '''D''')) # returns ['G', 'C', 'A', 'B', 'D']
print(bfs_shortest_path_distance(demo_graph, '''G''', '''D''')) # returns 4
| 677 |
"""simple docstring"""
from __future__ import annotations
import unittest
from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin
if is_tf_available():
import tensorflow as tf
from transformers import (
TF_MODEL_FOR_PRETRAINING_MAPPING,
TFMobileBertForMaskedLM,
TFMobileBertForMultipleChoice,
TFMobileBertForNextSentencePrediction,
TFMobileBertForPreTraining,
TFMobileBertForQuestionAnswering,
TFMobileBertForSequenceClassification,
TFMobileBertForTokenClassification,
TFMobileBertModel,
)
@require_tf
class __magic_name__ ( __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
__A : Any = (
(
TFMobileBertModel,
TFMobileBertForMaskedLM,
TFMobileBertForNextSentencePrediction,
TFMobileBertForPreTraining,
TFMobileBertForQuestionAnswering,
TFMobileBertForSequenceClassification,
TFMobileBertForTokenClassification,
TFMobileBertForMultipleChoice,
)
if is_tf_available()
else ()
)
__A : List[Any] = (
{
"feature-extraction": TFMobileBertModel,
"fill-mask": TFMobileBertForMaskedLM,
"question-answering": TFMobileBertForQuestionAnswering,
"text-classification": TFMobileBertForSequenceClassification,
"token-classification": TFMobileBertForTokenClassification,
"zero-shot": TFMobileBertForSequenceClassification,
}
if is_tf_available()
else {}
)
__A : List[str] = False
__A : int = False
def __snake_case ( self : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Any , snake_case__ : int=False ):
'''simple docstring'''
lowercase :Union[str, Any] = super()._prepare_for_class(snake_case__ , snake_case__ , return_labels=snake_case__ )
if return_labels:
if model_class in get_values(snake_case__ ):
lowercase :Tuple = tf.zeros(self.model_tester.batch_size , dtype=tf.intaa )
return inputs_dict
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Any , snake_case__ : Dict , snake_case__ : Dict=1_3 , snake_case__ : Tuple=7 , snake_case__ : Optional[Any]=True , snake_case__ : Union[str, Any]=True , snake_case__ : str=True , snake_case__ : Optional[Any]=True , snake_case__ : Any=9_9 , snake_case__ : Optional[Any]=3_2 , snake_case__ : Optional[Any]=3_2 , snake_case__ : Any=2 , snake_case__ : Optional[int]=4 , snake_case__ : List[Any]=3_7 , snake_case__ : Optional[int]="gelu" , snake_case__ : List[Any]=0.1 , snake_case__ : str=0.1 , snake_case__ : List[Any]=5_1_2 , snake_case__ : List[str]=1_6 , snake_case__ : Union[str, Any]=2 , snake_case__ : Optional[Any]=0.02 , snake_case__ : Optional[Any]=3 , snake_case__ : Dict=4 , snake_case__ : int=None , ):
'''simple docstring'''
lowercase :Tuple = parent
lowercase :Tuple = batch_size
lowercase :Optional[Any] = seq_length
lowercase :Optional[Any] = is_training
lowercase :Optional[Any] = use_input_mask
lowercase :List[Any] = use_token_type_ids
lowercase :str = use_labels
lowercase :List[str] = vocab_size
lowercase :str = hidden_size
lowercase :Optional[int] = num_hidden_layers
lowercase :Dict = num_attention_heads
lowercase :Any = intermediate_size
lowercase :List[str] = hidden_act
lowercase :Optional[Any] = hidden_dropout_prob
lowercase :List[Any] = attention_probs_dropout_prob
lowercase :List[Any] = max_position_embeddings
lowercase :List[Any] = type_vocab_size
lowercase :Union[str, Any] = type_sequence_label_size
lowercase :Union[str, Any] = initializer_range
lowercase :Any = num_labels
lowercase :int = num_choices
lowercase :Dict = scope
lowercase :Dict = embedding_size
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :Optional[int] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size )
lowercase :int = None
if self.use_input_mask:
lowercase :int = random_attention_mask([self.batch_size, self.seq_length] )
lowercase :Tuple = None
if self.use_token_type_ids:
lowercase :int = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size )
lowercase :Union[str, Any] = None
lowercase :int = None
lowercase :str = None
if self.use_labels:
lowercase :int = ids_tensor([self.batch_size] , self.type_sequence_label_size )
lowercase :str = ids_tensor([self.batch_size, self.seq_length] , self.num_labels )
lowercase :Dict = ids_tensor([self.batch_size] , self.num_choices )
lowercase :Optional[int] = MobileBertConfig(
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 , embedding_size=self.embedding_size , )
return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
def __snake_case ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Any , snake_case__ : Tuple , snake_case__ : Tuple ):
'''simple docstring'''
lowercase :Dict = TFMobileBertModel(config=snake_case__ )
lowercase :Union[str, Any] = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
lowercase :Optional[int] = [input_ids, input_mask]
lowercase :Optional[int] = model(snake_case__ )
lowercase :Union[str, Any] = model(snake_case__ )
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 : List[Any] , snake_case__ : Dict , snake_case__ : Optional[int] , snake_case__ : int , snake_case__ : str , snake_case__ : Dict , snake_case__ : Tuple , snake_case__ : Optional[int] ):
'''simple docstring'''
lowercase :Any = TFMobileBertForMaskedLM(config=snake_case__ )
lowercase :Any = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :int = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) )
def __snake_case ( self : Tuple , snake_case__ : Any , snake_case__ : Optional[Any] , snake_case__ : List[Any] , snake_case__ : Dict , snake_case__ : str , snake_case__ : List[Any] , snake_case__ : Tuple ):
'''simple docstring'''
lowercase :Optional[Any] = TFMobileBertForNextSentencePrediction(config=snake_case__ )
lowercase :Tuple = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :Optional[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, 2) )
def __snake_case ( self : Dict , snake_case__ : Optional[Any] , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : Optional[int] , snake_case__ : int , snake_case__ : Union[str, Any] , snake_case__ : Dict ):
'''simple docstring'''
lowercase :int = TFMobileBertForPreTraining(config=snake_case__ )
lowercase :Any = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
self.parent.assertEqual(
result.prediction_logits.shape , (self.batch_size, self.seq_length, self.vocab_size) )
self.parent.assertEqual(result.seq_relationship_logits.shape , (self.batch_size, 2) )
def __snake_case ( self : Optional[Any] , snake_case__ : Tuple , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Optional[Any] , snake_case__ : List[str] , snake_case__ : Dict , snake_case__ : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = self.num_labels
lowercase :List[Any] = TFMobileBertForSequenceClassification(config=snake_case__ )
lowercase :Dict = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def __snake_case ( self : Any , snake_case__ : Optional[int] , snake_case__ : Tuple , snake_case__ : Union[str, Any] , snake_case__ : List[Any] , snake_case__ : List[Any] , snake_case__ : List[Any] , snake_case__ : Optional[Any] ):
'''simple docstring'''
lowercase :Tuple = self.num_choices
lowercase :Any = TFMobileBertForMultipleChoice(config=snake_case__ )
lowercase :Any = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :Union[str, Any] = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :List[Any] = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :Dict = {
'''input_ids''': multiple_choice_inputs_ids,
'''attention_mask''': multiple_choice_input_mask,
'''token_type_ids''': multiple_choice_token_type_ids,
}
lowercase :Optional[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) )
def __snake_case ( self : Any , snake_case__ : str , snake_case__ : Tuple , snake_case__ : int , snake_case__ : Tuple , snake_case__ : Dict , snake_case__ : Optional[Any] , snake_case__ : Dict ):
'''simple docstring'''
lowercase :List[Any] = self.num_labels
lowercase :List[str] = TFMobileBertForTokenClassification(config=snake_case__ )
lowercase :int = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :int = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) )
def __snake_case ( self : List[str] , snake_case__ : List[Any] , snake_case__ : Optional[int] , snake_case__ : Optional[int] , snake_case__ : List[Any] , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : str ):
'''simple docstring'''
lowercase :Union[str, Any] = TFMobileBertForQuestionAnswering(config=snake_case__ )
lowercase :List[Any] = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :str = model(snake_case__ )
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 : List[Any] ):
'''simple docstring'''
lowercase :Dict = self.prepare_config_and_inputs()
(
(
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) ,
) :Dict = config_and_inputs
lowercase :Optional[Any] = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
return config, inputs_dict
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = TFMobileBertModelTest.TFMobileBertModelTester(self )
lowercase :List[str] = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
self.config_tester.run_common_tests()
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :List[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_model(*snake_case__ )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :List[str] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_masked_lm(*snake_case__ )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :str = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_multiple_choice(*snake_case__ )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :Tuple = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*snake_case__ )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :int = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_pretraining(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Tuple = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_question_answering(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Optional[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_sequence_classification(*snake_case__ )
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_token_classification(*snake_case__ )
@slow
def __snake_case ( self : int ):
'''simple docstring'''
for model_name in ["google/mobilebert-uncased"]:
lowercase :List[str] = TFMobileBertModel.from_pretrained(snake_case__ )
self.assertIsNotNone(snake_case__ )
@require_tf
class __magic_name__ ( unittest.TestCase ):
@slow
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :int = TFMobileBertForPreTraining.from_pretrained('''google/mobilebert-uncased''' )
lowercase :Optional[Any] = tf.constant([[0, 1, 2, 3, 4, 5]] )
lowercase :List[Any] = model(snake_case__ )[0]
lowercase :Union[str, Any] = [1, 6, 3_0_5_2_2]
self.assertEqual(output.shape , snake_case__ )
lowercase :Optional[int] = tf.constant(
[
[
[-4.5_91_95_47, -9.24_82_95, -9.64_52_56],
[-6.7_30_61_75, -6.44_02_84, -6.6_05_28_37],
[-7.2_74_35_06, -6.7_84_79_15, -6.02_46_73],
]
] )
tf.debugging.assert_near(output[:, :3, :3] , snake_case__ , atol=1e-4 )
| 677 | 1 |
"""simple docstring"""
from __future__ import annotations
import csv
import requests
from bsa import BeautifulSoup
def lowerCamelCase (a_ :str = "") -> dict[str, float]:
lowercase :str = url or '''https://www.imdb.com/chart/top/?ref_=nv_mv_250'''
lowercase :Any = BeautifulSoup(requests.get(a_).text , '''html.parser''')
lowercase :Optional[Any] = soup.find_all('''td''' , attrs='''titleColumn''')
lowercase :Optional[int] = soup.find_all('''td''' , class_='''ratingColumn imdbRating''')
return {
title.a.text: float(rating.strong.text)
for title, rating in zip(a_ , a_)
}
def lowerCamelCase (a_ :str = "IMDb_Top_250_Movies.csv") -> None:
lowercase :Optional[int] = get_imdb_top_aaa_movies()
with open(a_ , '''w''' , newline='''''') as out_file:
lowercase :Union[str, Any] = csv.writer(a_)
writer.writerow(['''Movie title''', '''IMDb rating'''])
for title, rating in movies.items():
writer.writerow([title, rating])
if __name__ == "__main__":
write_movies()
| 677 |
"""simple docstring"""
import contextlib
import copy
import random
from typing import Any, Dict, Iterable, Optional, Union
import numpy as np
import torch
from .utils import deprecate, is_transformers_available
if is_transformers_available():
import transformers
def lowerCamelCase (a_ :int) -> List[str]:
random.seed(a_)
np.random.seed(a_)
torch.manual_seed(a_)
torch.cuda.manual_seed_all(a_)
# ^^ safe to call this function even if cuda is not available
class __magic_name__ :
def __init__( self : Optional[Any] , snake_case__ : Iterable[torch.nn.Parameter] , snake_case__ : float = 0.99_99 , snake_case__ : float = 0.0 , snake_case__ : int = 0 , snake_case__ : bool = False , snake_case__ : Union[float, int] = 1.0 , snake_case__ : Union[float, int] = 2 / 3 , snake_case__ : Optional[Any] = None , snake_case__ : Dict[str, Any] = None , **snake_case__ : Tuple , ):
'''simple docstring'''
if isinstance(snake_case__ , torch.nn.Module ):
lowercase :int = (
'''Passing a `torch.nn.Module` to `ExponentialMovingAverage` is deprecated. '''
'''Please pass the parameters of the module instead.'''
)
deprecate(
'''passing a `torch.nn.Module` to `ExponentialMovingAverage`''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ , )
lowercase :Dict = parameters.parameters()
# set use_ema_warmup to True if a torch.nn.Module is passed for backwards compatibility
lowercase :Optional[Any] = True
if kwargs.get('''max_value''' , snake_case__ ) is not None:
lowercase :Optional[Any] = '''The `max_value` argument is deprecated. Please use `decay` instead.'''
deprecate('''max_value''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
lowercase :Optional[int] = kwargs['''max_value''']
if kwargs.get('''min_value''' , snake_case__ ) is not None:
lowercase :List[Any] = '''The `min_value` argument is deprecated. Please use `min_decay` instead.'''
deprecate('''min_value''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
lowercase :str = kwargs['''min_value''']
lowercase :Any = list(snake_case__ )
lowercase :Optional[Any] = [p.clone().detach() for p in parameters]
if kwargs.get('''device''' , snake_case__ ) is not None:
lowercase :str = '''The `device` argument is deprecated. Please use `to` instead.'''
deprecate('''device''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
self.to(device=kwargs['''device'''] )
lowercase :int = None
lowercase :int = decay
lowercase :Union[str, Any] = min_decay
lowercase :List[Any] = update_after_step
lowercase :Union[str, Any] = use_ema_warmup
lowercase :Any = inv_gamma
lowercase :Any = power
lowercase :str = 0
lowercase :int = None # set in `step()`
lowercase :List[str] = model_cls
lowercase :Any = model_config
@classmethod
def __snake_case ( cls : int , snake_case__ : Tuple , snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase , lowercase :int = model_cls.load_config(snake_case__ , return_unused_kwargs=snake_case__ )
lowercase :List[Any] = model_cls.from_pretrained(snake_case__ )
lowercase :Optional[int] = cls(model.parameters() , model_cls=snake_case__ , model_config=model.config )
ema_model.load_state_dict(snake_case__ )
return ema_model
def __snake_case ( self : int , snake_case__ : Union[str, Any] ):
'''simple docstring'''
if self.model_cls is None:
raise ValueError('''`save_pretrained` can only be used if `model_cls` was defined at __init__.''' )
if self.model_config is None:
raise ValueError('''`save_pretrained` can only be used if `model_config` was defined at __init__.''' )
lowercase :Dict = self.model_cls.from_config(self.model_config )
lowercase :Tuple = self.state_dict()
state_dict.pop('''shadow_params''' , snake_case__ )
model.register_to_config(**snake_case__ )
self.copy_to(model.parameters() )
model.save_pretrained(snake_case__ )
def __snake_case ( self : int , snake_case__ : int ):
'''simple docstring'''
lowercase :Union[str, Any] = max(0 , optimization_step - self.update_after_step - 1 )
if step <= 0:
return 0.0
if self.use_ema_warmup:
lowercase :int = 1 - (1 + step / self.inv_gamma) ** -self.power
else:
lowercase :Dict = (1 + step) / (1_0 + step)
lowercase :Optional[int] = min(snake_case__ , self.decay )
# make sure decay is not smaller than min_decay
lowercase :Optional[int] = max(snake_case__ , self.min_decay )
return cur_decay_value
@torch.no_grad()
def __snake_case ( self : Any , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
if isinstance(snake_case__ , torch.nn.Module ):
lowercase :Tuple = (
'''Passing a `torch.nn.Module` to `ExponentialMovingAverage.step` is deprecated. '''
'''Please pass the parameters of the module instead.'''
)
deprecate(
'''passing a `torch.nn.Module` to `ExponentialMovingAverage.step`''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ , )
lowercase :Union[str, Any] = parameters.parameters()
lowercase :Optional[Any] = list(snake_case__ )
self.optimization_step += 1
# Compute the decay factor for the exponential moving average.
lowercase :List[Any] = self.get_decay(self.optimization_step )
lowercase :Optional[Any] = decay
lowercase :List[Any] = 1 - decay
lowercase :List[str] = contextlib.nullcontext
if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
import deepspeed
for s_param, param in zip(self.shadow_params , snake_case__ ):
if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
lowercase :Union[str, Any] = deepspeed.zero.GatheredParameters(snake_case__ , modifier_rank=snake_case__ )
with context_manager():
if param.requires_grad:
s_param.sub_(one_minus_decay * (s_param - param) )
else:
s_param.copy_(snake_case__ )
def __snake_case ( self : str , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
lowercase :Optional[Any] = list(snake_case__ )
for s_param, param in zip(self.shadow_params , snake_case__ ):
param.data.copy_(s_param.to(param.device ).data )
def __snake_case ( self : Optional[int] , snake_case__ : Dict=None , snake_case__ : Dict=None ):
'''simple docstring'''
lowercase :str = [
p.to(device=snake_case__ , dtype=snake_case__ ) if p.is_floating_point() else p.to(device=snake_case__ )
for p in self.shadow_params
]
def __snake_case ( self : Dict ):
'''simple docstring'''
return {
"decay": self.decay,
"min_decay": self.min_decay,
"optimization_step": self.optimization_step,
"update_after_step": self.update_after_step,
"use_ema_warmup": self.use_ema_warmup,
"inv_gamma": self.inv_gamma,
"power": self.power,
"shadow_params": self.shadow_params,
}
def __snake_case ( self : Optional[int] , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
lowercase :str = [param.detach().cpu().clone() for param in parameters]
def __snake_case ( self : List[Any] , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
if self.temp_stored_params is None:
raise RuntimeError('''This ExponentialMovingAverage has no `store()`ed weights ''' '''to `restore()`''' )
for c_param, param in zip(self.temp_stored_params , snake_case__ ):
param.data.copy_(c_param.data )
# Better memory-wise.
lowercase :Dict = None
def __snake_case ( self : Union[str, Any] , snake_case__ : dict ):
'''simple docstring'''
lowercase :List[str] = copy.deepcopy(snake_case__ )
lowercase :Any = state_dict.get('''decay''' , self.decay )
if self.decay < 0.0 or self.decay > 1.0:
raise ValueError('''Decay must be between 0 and 1''' )
lowercase :int = state_dict.get('''min_decay''' , self.min_decay )
if not isinstance(self.min_decay , snake_case__ ):
raise ValueError('''Invalid min_decay''' )
lowercase :List[Any] = state_dict.get('''optimization_step''' , self.optimization_step )
if not isinstance(self.optimization_step , snake_case__ ):
raise ValueError('''Invalid optimization_step''' )
lowercase :int = state_dict.get('''update_after_step''' , self.update_after_step )
if not isinstance(self.update_after_step , snake_case__ ):
raise ValueError('''Invalid update_after_step''' )
lowercase :Optional[int] = state_dict.get('''use_ema_warmup''' , self.use_ema_warmup )
if not isinstance(self.use_ema_warmup , snake_case__ ):
raise ValueError('''Invalid use_ema_warmup''' )
lowercase :Any = state_dict.get('''inv_gamma''' , self.inv_gamma )
if not isinstance(self.inv_gamma , (float, int) ):
raise ValueError('''Invalid inv_gamma''' )
lowercase :Dict = state_dict.get('''power''' , self.power )
if not isinstance(self.power , (float, int) ):
raise ValueError('''Invalid power''' )
lowercase :Optional[int] = state_dict.get('''shadow_params''' , snake_case__ )
if shadow_params is not None:
lowercase :List[Any] = shadow_params
if not isinstance(self.shadow_params , snake_case__ ):
raise ValueError('''shadow_params must be a list''' )
if not all(isinstance(snake_case__ , torch.Tensor ) for p in self.shadow_params ):
raise ValueError('''shadow_params must all be Tensors''' )
| 677 | 1 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available
UpperCAmelCase = {
'''configuration_conditional_detr''': [
'''CONDITIONAL_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''ConditionalDetrConfig''',
'''ConditionalDetrOnnxConfig''',
]
}
try:
if not is_vision_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''ConditionalDetrFeatureExtractor''']
UpperCAmelCase = ['''ConditionalDetrImageProcessor''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''CONDITIONAL_DETR_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''ConditionalDetrForObjectDetection''',
'''ConditionalDetrForSegmentation''',
'''ConditionalDetrModel''',
'''ConditionalDetrPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_conditional_detr import (
CONDITIONAL_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP,
ConditionalDetrConfig,
ConditionalDetrOnnxConfig,
)
try:
if not is_vision_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .feature_extraction_conditional_detr import ConditionalDetrFeatureExtractor
from .image_processing_conditional_detr import ConditionalDetrImageProcessor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_conditional_detr import (
CONDITIONAL_DETR_PRETRAINED_MODEL_ARCHIVE_LIST,
ConditionalDetrForObjectDetection,
ConditionalDetrForSegmentation,
ConditionalDetrModel,
ConditionalDetrPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 |
"""simple docstring"""
import argparse
import collections
import numpy as np
import torch
from flax import traverse_util
from tax import checkpoints
from transformers import MTaConfig, UMTaEncoderModel, UMTaForConditionalGeneration
from transformers.utils import logging
logging.set_verbosity_info()
def lowerCamelCase (a_ :int , a_ :Union[str, Any] , a_ :List[Any]) -> List[str]:
return params[F"""{prefix}/{prefix}/relpos_bias/rel_embedding"""][:, i, :]
def lowerCamelCase (a_ :Optional[Any] , a_ :Optional[int] , a_ :str , a_ :Any="attention") -> Optional[int]:
lowercase :Tuple = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/key/kernel"""][:, i, :, :])
lowercase :int = k_tmp.reshape(k_tmp.shape[0] , k_tmp.shape[1] * k_tmp.shape[2])
lowercase :str = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/out/kernel"""][:, i, :, :])
lowercase :Any = o_tmp.reshape(o_tmp.shape[0] * o_tmp.shape[1] , o_tmp.shape[2])
lowercase :int = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/query/kernel"""][:, i, :, :])
lowercase :List[str] = q_tmp.reshape(q_tmp.shape[0] , q_tmp.shape[1] * q_tmp.shape[2])
lowercase :List[Any] = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/value/kernel"""][:, i, :, :])
lowercase :Optional[int] = v_tmp.reshape(v_tmp.shape[0] , v_tmp.shape[1] * v_tmp.shape[2])
return k, o, q, v
def lowerCamelCase (a_ :Any , a_ :Union[str, Any] , a_ :Union[str, Any] , a_ :Union[str, Any]=False) -> List[Any]:
if split_mlp_wi:
lowercase :List[Any] = params[F"""{prefix}/{prefix}/mlp/wi_0/kernel"""][:, i, :]
lowercase :Optional[int] = params[F"""{prefix}/{prefix}/mlp/wi_1/kernel"""][:, i, :]
lowercase :Dict = (wi_a, wi_a)
else:
lowercase :Optional[Any] = params[F"""{prefix}/{prefix}/mlp/wi/kernel"""][:, i, :]
lowercase :Union[str, Any] = params[F"""{prefix}/{prefix}/mlp/wo/kernel"""][:, i, :]
return wi, wo
def lowerCamelCase (a_ :Any , a_ :Optional[Any] , a_ :Optional[Any] , a_ :Union[str, Any]) -> Optional[Any]:
return params[F"""{prefix}/{prefix}/{layer_name}/scale"""][:, i]
def lowerCamelCase (a_ :dict , *, a_ :int , a_ :bool , a_ :bool = False) -> int:
lowercase :Dict = traverse_util.flatten_dict(variables['''target'''])
lowercase :Optional[Any] = {'''/'''.join(a_): v for k, v in old.items()}
# v1.1 models have a gated GeLU with wi_0 and wi_1 instead of wi
lowercase :str = '''encoder/encoder/mlp/wi_0/kernel''' in old
print('''Split MLP:''' , a_)
lowercase :str = collections.OrderedDict()
# Shared embeddings.
lowercase :int = old['''token_embedder/embedding''']
# Encoder.
for i in range(a_):
# Block i, layer 0 (Self Attention).
lowercase :Union[str, Any] = tax_layer_norm_lookup(a_ , a_ , '''encoder''' , '''pre_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :Tuple = tax_attention_lookup(a_ , a_ , '''encoder''' , '''attention''')
lowercase :Dict = layer_norm
lowercase :Dict = k.T
lowercase :Union[str, Any] = o.T
lowercase :List[Any] = q.T
lowercase :int = v.T
# Block i, layer 1 (MLP).
lowercase :Optional[int] = tax_layer_norm_lookup(a_ , a_ , '''encoder''' , '''pre_mlp_layer_norm''')
lowercase , lowercase :str = tax_mlp_lookup(a_ , a_ , '''encoder''' , a_)
lowercase :int = layer_norm
if split_mlp_wi:
lowercase :Tuple = wi[0].T
lowercase :Tuple = wi[1].T
else:
lowercase :int = wi.T
lowercase :Tuple = wo.T
if scalable_attention:
# convert the rel_embedding of each layer
lowercase :Dict = tax_relpos_bias_lookup(
a_ , a_ , '''encoder''').T
lowercase :str = old['''encoder/encoder_norm/scale''']
if not scalable_attention:
lowercase :str = tax_relpos_bias_lookup(
a_ , 0 , '''encoder''').T
lowercase :List[Any] = tax_relpos_bias_lookup(
a_ , 0 , '''decoder''').T
if not is_encoder_only:
# Decoder.
for i in range(a_):
# Block i, layer 0 (Self Attention).
lowercase :Any = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_self_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :str = tax_attention_lookup(a_ , a_ , '''decoder''' , '''self_attention''')
lowercase :List[str] = layer_norm
lowercase :Dict = k.T
lowercase :List[Any] = o.T
lowercase :List[Any] = q.T
lowercase :Any = v.T
# Block i, layer 1 (Cross Attention).
lowercase :Tuple = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_cross_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :int = tax_attention_lookup(a_ , a_ , '''decoder''' , '''encoder_decoder_attention''')
lowercase :int = layer_norm
lowercase :Dict = k.T
lowercase :int = o.T
lowercase :List[Any] = q.T
lowercase :Tuple = v.T
# Block i, layer 2 (MLP).
lowercase :Any = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_mlp_layer_norm''')
lowercase , lowercase :Tuple = tax_mlp_lookup(a_ , a_ , '''decoder''' , a_)
lowercase :Any = layer_norm
if split_mlp_wi:
lowercase :int = wi[0].T
lowercase :Union[str, Any] = wi[1].T
else:
lowercase :int = wi.T
lowercase :List[Any] = wo.T
if scalable_attention:
# convert the rel_embedding of each layer
lowercase :Union[str, Any] = tax_relpos_bias_lookup(a_ , a_ , '''decoder''').T
lowercase :Union[str, Any] = old['''decoder/decoder_norm/scale''']
# LM Head (only in v1.1 checkpoints, in v1.0 embeddings are used instead)
if "decoder/logits_dense/kernel" in old:
lowercase :int = old['''decoder/logits_dense/kernel'''].T
return new
def lowerCamelCase (a_ :Dict , a_ :bool) -> Tuple:
lowercase :str = collections.OrderedDict([(k, torch.from_numpy(v.copy())) for (k, v) in converted_params.items()])
# Add what is missing.
if "encoder.embed_tokens.weight" not in state_dict:
lowercase :Any = state_dict['''shared.weight''']
if not is_encoder_only:
if "decoder.embed_tokens.weight" not in state_dict:
lowercase :Optional[Any] = state_dict['''shared.weight''']
if "lm_head.weight" not in state_dict: # For old 1.0 models.
print('''Using shared word embeddings as lm_head.''')
lowercase :Optional[int] = state_dict['''shared.weight''']
return state_dict
def lowerCamelCase (a_ :List[str] , a_ :List[str] , a_ :Tuple , a_ :Optional[int] , a_ :List[str]) -> List[str]:
lowercase :Optional[Any] = checkpoints.load_tax_checkpoint(a_)
lowercase :Optional[int] = convert_tax_to_pytorch(
a_ , num_layers=config.num_layers , is_encoder_only=a_ , scalable_attention=a_)
lowercase :Union[str, Any] = make_state_dict(a_ , a_)
model.load_state_dict(a_ , strict=a_)
def lowerCamelCase (a_ :str , a_ :Optional[int] , a_ :Any , a_ :bool = False , a_ :bool = False , ) -> Tuple:
lowercase :Optional[int] = MTaConfig.from_json_file(a_)
print(F"""Building PyTorch model from configuration: {config}""")
# Non-v1.1 checkpoints could also use T5Model, but this works for all.
# The v1.0 checkpoints will simply have an LM head that is the word embeddings.
if is_encoder_only:
lowercase :Union[str, Any] = UMTaEncoderModel(a_)
else:
lowercase :int = UMTaForConditionalGeneration(a_)
# Load weights from tf checkpoint
load_tax_weights_in_ta(a_ , a_ , a_ , a_ , a_)
# Save pytorch-model
print(F"""Save PyTorch model to {pytorch_dump_path}""")
model.save_pretrained(a_)
# Verify that we can load the checkpoint.
model.from_pretrained(a_)
print('''Done''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser(description='''Converts a native T5X checkpoint into a PyTorch checkpoint.''')
# Required parameters
parser.add_argument(
'''--t5x_checkpoint_path''', default=None, type=str, required=True, help='''Path to the T5X checkpoint.'''
)
parser.add_argument(
'''--config_file''',
default=None,
type=str,
required=True,
help='''The config json file corresponding to the pre-trained T5 model.\nThis specifies the model architecture.''',
)
parser.add_argument(
'''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
)
parser.add_argument(
'''--is_encoder_only''', action='''store_true''', help='''Check if the model is encoder-decoder model''', default=False
)
parser.add_argument(
'''--scalable_attention''',
action='''store_true''',
help='''Whether the model uses scaled attention (umt5 model)''',
default=False,
)
UpperCAmelCase = parser.parse_args()
convert_tax_checkpoint_to_pytorch(
args.tax_checkpoint_path,
args.config_file,
args.pytorch_dump_path,
args.is_encoder_only,
args.scalable_attention,
)
| 677 | 1 |
"""simple docstring"""
def lowerCamelCase (a_ :int = 100) -> int:
lowercase :Union[str, Any] = set()
lowercase :List[Any] = 0
lowercase :Dict = n + 1 # maximum limit
for a in range(2 , a_):
for b in range(2 , a_):
lowercase :Tuple = a**b # calculates the current power
collect_powers.add(a_) # adds the result to the set
return len(a_)
if __name__ == "__main__":
print('''Number of terms ''', solution(int(str(input()).strip())))
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tf_available,
is_tokenizers_available,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_blenderbot''': [
'''BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''BlenderbotConfig''',
'''BlenderbotOnnxConfig''',
],
'''tokenization_blenderbot''': ['''BlenderbotTokenizer'''],
}
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''BlenderbotTokenizerFast''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''BlenderbotForCausalLM''',
'''BlenderbotForConditionalGeneration''',
'''BlenderbotModel''',
'''BlenderbotPreTrainedModel''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TFBlenderbotForConditionalGeneration''',
'''TFBlenderbotModel''',
'''TFBlenderbotPreTrainedModel''',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxBlenderbotForConditionalGeneration''',
'''FlaxBlenderbotModel''',
'''FlaxBlenderbotPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_blenderbot import (
BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP,
BlenderbotConfig,
BlenderbotOnnxConfig,
)
from .tokenization_blenderbot import BlenderbotTokenizer
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_blenderbot_fast import BlenderbotTokenizerFast
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_blenderbot import (
BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST,
BlenderbotForCausalLM,
BlenderbotForConditionalGeneration,
BlenderbotModel,
BlenderbotPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_blenderbot import (
TFBlenderbotForConditionalGeneration,
TFBlenderbotModel,
TFBlenderbotPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_blenderbot import (
FlaxBlenderbotForConditionalGeneration,
FlaxBlenderbotModel,
FlaxBlenderbotPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
def lowerCamelCase (a_ :int , a_ :int) -> int:
return abs(a_) if a == 0 else greatest_common_divisor(b % a , a_)
def lowerCamelCase (a_ :int , a_ :int) -> int:
while y: # --> when y=0 then loop will terminate and return x as final GCD.
lowercase , lowercase :List[str] = y, x % y
return abs(a_)
def lowerCamelCase () -> List[str]:
try:
lowercase :Optional[Any] = input('''Enter two integers separated by comma (,): ''').split(''',''')
lowercase :List[str] = int(nums[0])
lowercase :List[str] = int(nums[1])
print(
F"""greatest_common_divisor({num_a}, {num_a}) = """
F"""{greatest_common_divisor(a_ , a_)}""")
print(F"""By iterative gcd({num_a}, {num_a}) = {gcd_by_iterative(a_ , a_)}""")
except (IndexError, UnboundLocalError, ValueError):
print('''Wrong input''')
if __name__ == "__main__":
main()
| 677 |
"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''naver-clova-ix/donut-base''': '''https://huggingface.co/naver-clova-ix/donut-base/resolve/main/config.json''',
# See all Donut models at https://huggingface.co/models?filter=donut-swin
}
class __magic_name__ ( __UpperCAmelCase ):
__A : Tuple = "donut-swin"
__A : Optional[Any] = {
"num_attention_heads": "num_heads",
"num_hidden_layers": "num_layers",
}
def __init__( self : List[str] , snake_case__ : Any=2_2_4 , snake_case__ : Tuple=4 , snake_case__ : str=3 , snake_case__ : Dict=9_6 , snake_case__ : Optional[Any]=[2, 2, 6, 2] , snake_case__ : Any=[3, 6, 1_2, 2_4] , snake_case__ : List[str]=7 , snake_case__ : Dict=4.0 , snake_case__ : str=True , snake_case__ : Optional[int]=0.0 , snake_case__ : Tuple=0.0 , snake_case__ : Any=0.1 , snake_case__ : List[str]="gelu" , snake_case__ : Tuple=False , snake_case__ : int=0.02 , snake_case__ : Optional[Any]=1e-5 , **snake_case__ : Any , ):
'''simple docstring'''
super().__init__(**snake_case__ )
lowercase :Union[str, Any] = image_size
lowercase :Optional[Any] = patch_size
lowercase :List[str] = num_channels
lowercase :Optional[int] = embed_dim
lowercase :Optional[Any] = depths
lowercase :List[Any] = len(snake_case__ )
lowercase :Optional[Any] = num_heads
lowercase :int = window_size
lowercase :str = mlp_ratio
lowercase :Optional[int] = qkv_bias
lowercase :Dict = hidden_dropout_prob
lowercase :Any = attention_probs_dropout_prob
lowercase :Any = drop_path_rate
lowercase :int = hidden_act
lowercase :int = use_absolute_embeddings
lowercase :List[str] = layer_norm_eps
lowercase :Union[str, Any] = initializer_range
# we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
# this indicates the channel dimension after the last stage of the model
lowercase :str = int(embed_dim * 2 ** (len(snake_case__ ) - 1) )
| 677 | 1 |
"""simple docstring"""
import collections
import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple
from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = '''▁'''
UpperCAmelCase = {'''vocab_file''': '''prophetnet.tokenizer'''}
UpperCAmelCase = {
'''vocab_file''': {
'''microsoft/xprophetnet-large-wiki100-cased''': (
'''https://huggingface.co/microsoft/xprophetnet-large-wiki100-cased/resolve/main/prophetnet.tokenizer'''
),
}
}
UpperCAmelCase = {
'''microsoft/xprophetnet-large-wiki100-cased''': {'''do_lower_case''': False},
}
UpperCAmelCase = {
'''microsoft/xprophetnet-large-wiki100-cased''': 512,
}
def lowerCamelCase (a_ :Any) -> str:
lowercase :Optional[int] = collections.OrderedDict()
with open(a_ , '''r''' , encoding='''utf-8''') as reader:
lowercase :Any = reader.readlines()
for index, token in enumerate(a_):
lowercase :Dict = token.rstrip('''\n''')
lowercase :Tuple = index
return vocab
class __magic_name__ ( __UpperCAmelCase ):
__A : List[Any] = VOCAB_FILES_NAMES
__A : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP
__A : str = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
__A : List[str] = ["input_ids", "attention_mask"]
def __init__( self : Tuple , snake_case__ : Union[str, Any] , snake_case__ : str="[SEP]" , snake_case__ : List[Any]="[SEP]" , snake_case__ : Dict="[SEP]" , snake_case__ : Tuple="[UNK]" , snake_case__ : str="[PAD]" , snake_case__ : int="[CLS]" , snake_case__ : int="[MASK]" , snake_case__ : Optional[Dict[str, Any]] = None , **snake_case__ : Dict , ):
'''simple docstring'''
lowercase :List[str] = {} if sp_model_kwargs is None else sp_model_kwargs
super().__init__(
bos_token=snake_case__ , eos_token=snake_case__ , sep_token=snake_case__ , unk_token=snake_case__ , pad_token=snake_case__ , cls_token=snake_case__ , mask_token=snake_case__ , sp_model_kwargs=self.sp_model_kwargs , **snake_case__ , )
try:
import sentencepiece as spm
except ImportError:
logger.warning(
'''You need to install SentencePiece to use XLMRobertaTokenizer: https://github.com/google/sentencepiece'''
''' pip install sentencepiece''' )
raise
lowercase :Optional[Any] = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(str(snake_case__ ) )
lowercase :List[Any] = vocab_file
# Original fairseq vocab and spm vocab must be "aligned":
# Vocab | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
# -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
# fairseq | '<s>' | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's' | '▁de' | '-'
# spm | '<unk>' | '<s>' | '</s>' | ',' | '.' | '▁' | 's' | '▁de' | '-' | '▁a'
# put special tokens and [unused] tokens into the vocab
lowercase :str = {'''[PAD]''': 0, '''[CLS]''': 1, '''[SEP]''': 2, '''[UNK]''': 3, '''[MASK]''': 4}
for i in range(1_0 ):
lowercase :Dict = f"""[unused{i}]"""
lowercase :Any = 5 + i
# The first "real" token "," has position 15 in the embedding vocab and position 3 in the spm vocab
lowercase :Optional[Any] = 1_2
lowercase :Tuple = {v: k for k, v in self.fairseq_tokens_to_ids.items()}
for k in self.fairseq_tokens_to_ids.keys():
self.unique_no_split_tokens.append(snake_case__ )
def __getstate__( self : Optional[int] ):
'''simple docstring'''
lowercase :Any = self.__dict__.copy()
lowercase :Any = None
return state
def __setstate__( self : Optional[int] , snake_case__ : Optional[int] ):
'''simple docstring'''
lowercase :Optional[Any] = d
try:
import sentencepiece as spm
except ImportError:
logger.warning(
'''You need to install SentencePiece to use XLMRobertaTokenizer: https://github.com/google/sentencepiece'''
''' pip install sentencepiece''' )
raise
# for backward compatibility
if not hasattr(self , '''sp_model_kwargs''' ):
lowercase :str = {}
lowercase :Optional[int] = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(self.vocab_file )
def __snake_case ( self : int , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None , snake_case__ : bool = False ):
'''simple docstring'''
if already_has_special_tokens:
return super().get_special_tokens_mask(
token_ids_a=snake_case__ , token_ids_a=snake_case__ , already_has_special_tokens=snake_case__ )
if token_ids_a is None:
return ([0] * len(snake_case__ )) + [1]
return ([0] * len(snake_case__ )) + [1] + ([0] * len(snake_case__ )) + [1]
def __snake_case ( self : str , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ):
'''simple docstring'''
lowercase :List[Any] = [self.sep_token_id]
if token_ids_a is None:
return len(token_ids_a + sep ) * [0]
return len(token_ids_a + sep + sep + token_ids_a + sep ) * [0]
@property
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
return len(self.sp_model ) + self.fairseq_offset
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :Optional[Any] = {self.convert_ids_to_tokens(snake_case__ ): i for i in range(self.vocab_size )}
vocab.update(self.added_tokens_encoder )
return vocab
def __snake_case ( self : List[Any] , snake_case__ : str ):
'''simple docstring'''
return self.sp_model.encode(snake_case__ , out_type=snake_case__ )
def __snake_case ( self : List[Any] , snake_case__ : List[str] ):
'''simple docstring'''
if token in self.fairseq_tokens_to_ids:
return self.fairseq_tokens_to_ids[token]
lowercase :List[Any] = self.sp_model.PieceToId(snake_case__ )
# Need to return unknown token if the SP model returned 0
return spm_id + self.fairseq_offset if spm_id else self.unk_token_id
def __snake_case ( self : List[str] , snake_case__ : List[str] ):
'''simple docstring'''
if index in self.fairseq_ids_to_tokens:
return self.fairseq_ids_to_tokens[index]
return self.sp_model.IdToPiece(index - self.fairseq_offset )
def __snake_case ( self : List[Any] , snake_case__ : Optional[int] ):
'''simple docstring'''
lowercase :Tuple = ''''''.join(snake_case__ ).replace(snake_case__ , ''' ''' ).strip()
return out_string
def __snake_case ( self : Dict , snake_case__ : str , snake_case__ : Optional[str] = None ):
'''simple docstring'''
if not os.path.isdir(snake_case__ ):
logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" )
return
lowercase :Tuple = os.path.join(
snake_case__ , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] )
if os.path.abspath(self.vocab_file ) != os.path.abspath(snake_case__ ) and os.path.isfile(self.vocab_file ):
copyfile(self.vocab_file , snake_case__ )
elif not os.path.isfile(self.vocab_file ):
with open(snake_case__ , '''wb''' ) as fi:
lowercase :Union[str, Any] = self.sp_model.serialized_model_proto()
fi.write(snake_case__ )
return (out_vocab_file,)
def __snake_case ( self : int , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ):
'''simple docstring'''
if token_ids_a is None:
return token_ids_a + [self.sep_token_id]
lowercase :int = [self.sep_token_id]
return token_ids_a + sep + token_ids_a + sep
| 677 |
"""simple docstring"""
import argparse
import os
import shutil
from pathlib import Path
import onnx
import torch
from packaging import version
from torch.onnx import export
from diffusers import OnnxRuntimeModel, OnnxStableDiffusionPipeline, StableDiffusionPipeline
UpperCAmelCase = version.parse(version.parse(torch.__version__).base_version) < version.parse('''1.11''')
def lowerCamelCase (a_ :Optional[int] , a_ :tuple , a_ :Path , a_ :str , a_ :int , a_ :List[Any] , a_ :Any , a_ :Union[str, Any]=False , ) -> Dict:
output_path.parent.mkdir(parents=a_ , exist_ok=a_)
# PyTorch deprecated the `enable_onnx_checker` and `use_external_data_format` arguments in v1.11,
# so we check the torch version for backwards compatibility
if is_torch_less_than_1_11:
export(
a_ , a_ , f=output_path.as_posix() , input_names=a_ , output_names=a_ , dynamic_axes=a_ , do_constant_folding=a_ , use_external_data_format=a_ , enable_onnx_checker=a_ , opset_version=a_ , )
else:
export(
a_ , a_ , f=output_path.as_posix() , input_names=a_ , output_names=a_ , dynamic_axes=a_ , do_constant_folding=a_ , opset_version=a_ , )
@torch.no_grad()
def lowerCamelCase (a_ :str , a_ :str , a_ :int , a_ :bool = False) -> Union[str, Any]:
lowercase :Any = torch.floataa if fpaa else torch.floataa
if fpaa and torch.cuda.is_available():
lowercase :Union[str, Any] = '''cuda'''
elif fpaa and not torch.cuda.is_available():
raise ValueError('''`float16` model export is only supported on GPUs with CUDA''')
else:
lowercase :List[str] = '''cpu'''
lowercase :List[str] = StableDiffusionPipeline.from_pretrained(a_ , torch_dtype=a_).to(a_)
lowercase :List[Any] = Path(a_)
# TEXT ENCODER
lowercase :List[Any] = pipeline.text_encoder.config.max_position_embeddings
lowercase :Dict = pipeline.text_encoder.config.hidden_size
lowercase :Union[str, Any] = pipeline.tokenizer(
'''A sample prompt''' , padding='''max_length''' , max_length=pipeline.tokenizer.model_max_length , truncation=a_ , return_tensors='''pt''' , )
onnx_export(
pipeline.text_encoder , model_args=(text_input.input_ids.to(device=a_ , dtype=torch.intaa)) , output_path=output_path / '''text_encoder''' / '''model.onnx''' , ordered_input_names=['''input_ids'''] , output_names=['''last_hidden_state''', '''pooler_output'''] , dynamic_axes={
'''input_ids''': {0: '''batch''', 1: '''sequence'''},
} , opset=a_ , )
del pipeline.text_encoder
# UNET
lowercase :Any = pipeline.unet.config.in_channels
lowercase :List[Any] = pipeline.unet.config.sample_size
lowercase :Optional[int] = output_path / '''unet''' / '''model.onnx'''
onnx_export(
pipeline.unet , model_args=(
torch.randn(2 , a_ , a_ , a_).to(device=a_ , dtype=a_),
torch.randn(2).to(device=a_ , dtype=a_),
torch.randn(2 , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=a_ , ordered_input_names=['''sample''', '''timestep''', '''encoder_hidden_states''', '''return_dict'''] , output_names=['''out_sample'''] , dynamic_axes={
'''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
'''timestep''': {0: '''batch'''},
'''encoder_hidden_states''': {0: '''batch''', 1: '''sequence'''},
} , opset=a_ , use_external_data_format=a_ , )
lowercase :List[Any] = str(unet_path.absolute().as_posix())
lowercase :str = os.path.dirname(a_)
lowercase :Optional[Any] = onnx.load(a_)
# clean up existing tensor files
shutil.rmtree(a_)
os.mkdir(a_)
# collate external tensor files into one
onnx.save_model(
a_ , a_ , save_as_external_data=a_ , all_tensors_to_one_file=a_ , location='''weights.pb''' , convert_attribute=a_ , )
del pipeline.unet
# VAE ENCODER
lowercase :Tuple = pipeline.vae
lowercase :Optional[Any] = vae_encoder.config.in_channels
lowercase :Any = vae_encoder.config.sample_size
# need to get the raw tensor output (sample) from the encoder
lowercase :Any = lambda a_ , a_: vae_encoder.encode(a_ , a_)[0].sample()
onnx_export(
a_ , model_args=(
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=output_path / '''vae_encoder''' / '''model.onnx''' , ordered_input_names=['''sample''', '''return_dict'''] , output_names=['''latent_sample'''] , dynamic_axes={
'''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
} , opset=a_ , )
# VAE DECODER
lowercase :Any = pipeline.vae
lowercase :Dict = vae_decoder.config.latent_channels
lowercase :Union[str, Any] = vae_decoder.config.out_channels
# forward only through the decoder part
lowercase :List[Any] = vae_encoder.decode
onnx_export(
a_ , model_args=(
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=output_path / '''vae_decoder''' / '''model.onnx''' , ordered_input_names=['''latent_sample''', '''return_dict'''] , output_names=['''sample'''] , dynamic_axes={
'''latent_sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
} , opset=a_ , )
del pipeline.vae
# SAFETY CHECKER
if pipeline.safety_checker is not None:
lowercase :Dict = pipeline.safety_checker
lowercase :str = safety_checker.config.vision_config.num_channels
lowercase :str = safety_checker.config.vision_config.image_size
lowercase :List[str] = safety_checker.forward_onnx
onnx_export(
pipeline.safety_checker , model_args=(
torch.randn(
1 , a_ , a_ , a_ , ).to(device=a_ , dtype=a_),
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
) , output_path=output_path / '''safety_checker''' / '''model.onnx''' , ordered_input_names=['''clip_input''', '''images'''] , output_names=['''out_images''', '''has_nsfw_concepts'''] , dynamic_axes={
'''clip_input''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
'''images''': {0: '''batch''', 1: '''height''', 2: '''width''', 3: '''channels'''},
} , opset=a_ , )
del pipeline.safety_checker
lowercase :Tuple = OnnxRuntimeModel.from_pretrained(output_path / '''safety_checker''')
lowercase :Optional[Any] = pipeline.feature_extractor
else:
lowercase :int = None
lowercase :Union[str, Any] = None
lowercase :Optional[int] = OnnxStableDiffusionPipeline(
vae_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_encoder''') , vae_decoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_decoder''') , text_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''text_encoder''') , tokenizer=pipeline.tokenizer , unet=OnnxRuntimeModel.from_pretrained(output_path / '''unet''') , scheduler=pipeline.scheduler , safety_checker=a_ , feature_extractor=a_ , requires_safety_checker=safety_checker is not None , )
onnx_pipeline.save_pretrained(a_)
print('''ONNX pipeline saved to''' , a_)
del pipeline
del onnx_pipeline
lowercase :Tuple = OnnxStableDiffusionPipeline.from_pretrained(a_ , provider='''CPUExecutionProvider''')
print('''ONNX pipeline is loadable''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
parser.add_argument(
'''--model_path''',
type=str,
required=True,
help='''Path to the `diffusers` checkpoint to convert (either a local directory or on the Hub).''',
)
parser.add_argument('''--output_path''', type=str, required=True, help='''Path to the output model.''')
parser.add_argument(
'''--opset''',
default=14,
type=int,
help='''The version of the ONNX operator set to use.''',
)
parser.add_argument('''--fp16''', action='''store_true''', default=False, help='''Export the models in `float16` mode''')
UpperCAmelCase = parser.parse_args()
convert_models(args.model_path, args.output_path, args.opset, args.fpaa)
| 677 | 1 |
"""simple docstring"""
import os
import time
import numpy as np
import onnxruntime as ort
UpperCAmelCase = '''1'''
UpperCAmelCase = '''0'''
UpperCAmelCase = '''1'''
UpperCAmelCase = ort.SessionOptions()
UpperCAmelCase = ort.GraphOptimizationLevel.ORT_DISABLE_ALL
print('''Create inference session...''')
UpperCAmelCase = ['''TensorrtExecutionProvider''', '''CUDAExecutionProvider''']
UpperCAmelCase = ort.InferenceSession('''model.onnx''', sess_options=sess_opt, providers=execution_provider)
UpperCAmelCase = ort.RunOptions()
UpperCAmelCase = 128
UpperCAmelCase = 1
UpperCAmelCase = np.ones((batch, sequence), dtype=np.intaa)
UpperCAmelCase = np.ones((batch, sequence), dtype=np.intaa)
UpperCAmelCase = np.ones((batch, sequence), dtype=np.intaa)
print('''Warm up phase...''')
sess.run(
None,
{
sess.get_inputs()[0].name: input_ids,
sess.get_inputs()[1].name: attention_mask,
sess.get_inputs()[2].name: token_type_ids,
},
run_options=run_opt,
)
print('''Start inference...''')
UpperCAmelCase = time.time()
UpperCAmelCase = 2_000
UpperCAmelCase = {}
for iter in range(max_iters):
UpperCAmelCase = sess.run(
None,
{
sess.get_inputs()[0].name: input_ids,
sess.get_inputs()[1].name: attention_mask,
sess.get_inputs()[2].name: token_type_ids,
},
run_options=run_opt,
)
print('''Average Inference Time = {:.3f} ms'''.format((time.time() - start_time) * 1_000 / max_iters))
| 677 |
"""simple docstring"""
import itertools
import json
import linecache
import os
import pickle
import re
import socket
import string
from collections import Counter
from logging import getLogger
from pathlib import Path
from typing import Callable, Dict, Iterable, List
import git
import torch
from torch.utils.data import Dataset
from transformers import BartTokenizer, RagTokenizer, TaTokenizer
def lowerCamelCase (a_ :List[Any] , a_ :Union[str, Any] , a_ :Tuple , a_ :List[str] , a_ :str=True , a_ :str="pt") -> List[str]:
lowercase :Optional[int] = {'''add_prefix_space''': True} if isinstance(a_ , a_) and not line.startswith(''' ''') else {}
lowercase :Optional[int] = padding_side
return tokenizer(
[line] , max_length=a_ , padding='''max_length''' if pad_to_max_length else None , truncation=a_ , return_tensors=a_ , add_special_tokens=a_ , **a_ , )
def lowerCamelCase (a_ :str , a_ :Tuple , a_ :Optional[Any]=None , ) -> Tuple:
lowercase :Optional[Any] = input_ids.ne(a_).any(dim=0)
if attention_mask is None:
return input_ids[:, keep_column_mask]
else:
return (input_ids[:, keep_column_mask], attention_mask[:, keep_column_mask])
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Union[str, Any] , snake_case__ : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : str="train" , snake_case__ : Optional[Any]=None , snake_case__ : Tuple=None , snake_case__ : Any=None , snake_case__ : Dict="" , ):
'''simple docstring'''
super().__init__()
lowercase :Tuple = Path(snake_case__ ).joinpath(type_path + '''.source''' )
lowercase :Union[str, Any] = Path(snake_case__ ).joinpath(type_path + '''.target''' )
lowercase :List[Any] = self.get_char_lens(self.src_file )
lowercase :Tuple = max_source_length
lowercase :Optional[int] = max_target_length
assert min(self.src_lens ) > 0, f"""found empty line in {self.src_file}"""
lowercase :Any = tokenizer
lowercase :Tuple = prefix
if n_obs is not None:
lowercase :List[str] = self.src_lens[:n_obs]
lowercase :List[Any] = src_lang
lowercase :str = tgt_lang
def __len__( self : Any ):
'''simple docstring'''
return len(self.src_lens )
def __getitem__( self : str , snake_case__ : Any ):
'''simple docstring'''
lowercase :Optional[int] = index + 1 # linecache starts at 1
lowercase :Optional[Any] = self.prefix + linecache.getline(str(self.src_file ) , snake_case__ ).rstrip('''\n''' )
lowercase :Dict = linecache.getline(str(self.tgt_file ) , snake_case__ ).rstrip('''\n''' )
assert source_line, f"""empty source line for index {index}"""
assert tgt_line, f"""empty tgt line for index {index}"""
# Need to add eos token manually for T5
if isinstance(self.tokenizer , snake_case__ ):
source_line += self.tokenizer.eos_token
tgt_line += self.tokenizer.eos_token
# Pad source and target to the right
lowercase :Dict = (
self.tokenizer.question_encoder if isinstance(self.tokenizer , snake_case__ ) else self.tokenizer
)
lowercase :Optional[int] = self.tokenizer.generator if isinstance(self.tokenizer , snake_case__ ) else self.tokenizer
lowercase :Optional[int] = encode_line(snake_case__ , snake_case__ , self.max_source_length , '''right''' )
lowercase :Tuple = encode_line(snake_case__ , snake_case__ , self.max_target_length , '''right''' )
lowercase :List[str] = source_inputs['''input_ids'''].squeeze()
lowercase :Optional[Any] = target_inputs['''input_ids'''].squeeze()
lowercase :List[str] = source_inputs['''attention_mask'''].squeeze()
return {
"input_ids": source_ids,
"attention_mask": src_mask,
"decoder_input_ids": target_ids,
}
@staticmethod
def __snake_case ( snake_case__ : Optional[int] ):
'''simple docstring'''
return [len(snake_case__ ) for x in Path(snake_case__ ).open().readlines()]
def __snake_case ( self : Tuple , snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase :Optional[Any] = torch.stack([x['''input_ids'''] for x in batch] )
lowercase :Tuple = torch.stack([x['''attention_mask'''] for x in batch] )
lowercase :Tuple = torch.stack([x['''decoder_input_ids'''] for x in batch] )
lowercase :str = (
self.tokenizer.generator.pad_token_id
if isinstance(self.tokenizer , snake_case__ )
else self.tokenizer.pad_token_id
)
lowercase :Optional[int] = (
self.tokenizer.question_encoder.pad_token_id
if isinstance(self.tokenizer , snake_case__ )
else self.tokenizer.pad_token_id
)
lowercase :List[Any] = trim_batch(snake_case__ , snake_case__ )
lowercase , lowercase :List[str] = trim_batch(snake_case__ , snake_case__ , attention_mask=snake_case__ )
lowercase :Optional[int] = {
'''input_ids''': source_ids,
'''attention_mask''': source_mask,
'''decoder_input_ids''': y,
}
return batch
UpperCAmelCase = getLogger(__name__)
def lowerCamelCase (a_ :List[List]) -> Tuple:
return list(itertools.chain.from_iterable(a_))
def lowerCamelCase (a_ :str) -> None:
lowercase :List[str] = get_git_info()
save_json(a_ , os.path.join(a_ , '''git_log.json'''))
def lowerCamelCase (a_ :Optional[int] , a_ :Optional[int] , a_ :Optional[Any]=4 , **a_ :Optional[Any]) -> str:
with open(a_ , '''w''') as f:
json.dump(a_ , a_ , indent=a_ , **a_)
def lowerCamelCase (a_ :Dict) -> Union[str, Any]:
with open(a_) as f:
return json.load(a_)
def lowerCamelCase () -> List[str]:
lowercase :Dict = git.Repo(search_parent_directories=a_)
lowercase :int = {
'''repo_id''': str(a_),
'''repo_sha''': str(repo.head.object.hexsha),
'''repo_branch''': str(repo.active_branch),
'''hostname''': str(socket.gethostname()),
}
return repo_infos
def lowerCamelCase (a_ :Callable , a_ :Iterable) -> List:
return list(map(a_ , a_))
def lowerCamelCase (a_ :Optional[Any] , a_ :str) -> Any:
with open(a_ , '''wb''') as f:
return pickle.dump(a_ , a_)
def lowerCamelCase (a_ :List[str]) -> List[str]:
def remove_articles(a_ :Union[str, Any]):
return re.sub(R'''\b(a|an|the)\b''' , ''' ''' , a_)
def white_space_fix(a_ :Tuple):
return " ".join(text.split())
def remove_punc(a_ :int):
lowercase :List[Any] = set(string.punctuation)
return "".join(ch for ch in text if ch not in exclude)
def lower(a_ :int):
return text.lower()
return white_space_fix(remove_articles(remove_punc(lower(a_))))
def lowerCamelCase (a_ :List[str] , a_ :Any) -> List[str]:
lowercase :Dict = normalize_answer(a_).split()
lowercase :int = normalize_answer(a_).split()
lowercase :List[Any] = Counter(a_) & Counter(a_)
lowercase :Optional[int] = sum(common.values())
if num_same == 0:
return 0
lowercase :str = 1.0 * num_same / len(a_)
lowercase :Tuple = 1.0 * num_same / len(a_)
lowercase :Tuple = (2 * precision * recall) / (precision + recall)
return fa
def lowerCamelCase (a_ :Tuple , a_ :Optional[Any]) -> List[Any]:
return normalize_answer(a_) == normalize_answer(a_)
def lowerCamelCase (a_ :List[str] , a_ :List[str]) -> Dict:
assert len(a_) == len(a_)
lowercase :Any = 0
for hypo, pred in zip(a_ , a_):
em += exact_match_score(a_ , a_)
if len(a_) > 0:
em /= len(a_)
return {"em": em}
def lowerCamelCase (a_ :Union[str, Any]) -> Optional[Any]:
return model_prefix.startswith('''rag''')
def lowerCamelCase (a_ :List[str] , a_ :Tuple , a_ :List[str]) -> Any:
lowercase :List[str] = {p: p for p in extra_params}
# T5 models don't have `dropout` param, they have `dropout_rate` instead
lowercase :str = '''dropout_rate'''
for p in extra_params:
if getattr(a_ , a_ , a_):
if not hasattr(a_ , a_) and not hasattr(a_ , equivalent_param[p]):
logger.info('''config doesn\'t have a `{}` attribute'''.format(a_))
delattr(a_ , a_)
continue
lowercase :List[str] = p if hasattr(a_ , a_) else equivalent_param[p]
setattr(a_ , a_ , getattr(a_ , a_))
delattr(a_ , a_)
return hparams, config
| 677 | 1 |
"""simple docstring"""
import argparse
import os
import shutil
from pathlib import Path
import onnx
import torch
from packaging import version
from torch.onnx import export
from diffusers import OnnxRuntimeModel, OnnxStableDiffusionPipeline, StableDiffusionPipeline
UpperCAmelCase = version.parse(version.parse(torch.__version__).base_version) < version.parse('''1.11''')
def lowerCamelCase (a_ :Optional[int] , a_ :tuple , a_ :Path , a_ :str , a_ :int , a_ :List[Any] , a_ :Any , a_ :Union[str, Any]=False , ) -> Dict:
output_path.parent.mkdir(parents=a_ , exist_ok=a_)
# PyTorch deprecated the `enable_onnx_checker` and `use_external_data_format` arguments in v1.11,
# so we check the torch version for backwards compatibility
if is_torch_less_than_1_11:
export(
a_ , a_ , f=output_path.as_posix() , input_names=a_ , output_names=a_ , dynamic_axes=a_ , do_constant_folding=a_ , use_external_data_format=a_ , enable_onnx_checker=a_ , opset_version=a_ , )
else:
export(
a_ , a_ , f=output_path.as_posix() , input_names=a_ , output_names=a_ , dynamic_axes=a_ , do_constant_folding=a_ , opset_version=a_ , )
@torch.no_grad()
def lowerCamelCase (a_ :str , a_ :str , a_ :int , a_ :bool = False) -> Union[str, Any]:
lowercase :Any = torch.floataa if fpaa else torch.floataa
if fpaa and torch.cuda.is_available():
lowercase :Union[str, Any] = '''cuda'''
elif fpaa and not torch.cuda.is_available():
raise ValueError('''`float16` model export is only supported on GPUs with CUDA''')
else:
lowercase :List[str] = '''cpu'''
lowercase :List[str] = StableDiffusionPipeline.from_pretrained(a_ , torch_dtype=a_).to(a_)
lowercase :List[Any] = Path(a_)
# TEXT ENCODER
lowercase :List[Any] = pipeline.text_encoder.config.max_position_embeddings
lowercase :Dict = pipeline.text_encoder.config.hidden_size
lowercase :Union[str, Any] = pipeline.tokenizer(
'''A sample prompt''' , padding='''max_length''' , max_length=pipeline.tokenizer.model_max_length , truncation=a_ , return_tensors='''pt''' , )
onnx_export(
pipeline.text_encoder , model_args=(text_input.input_ids.to(device=a_ , dtype=torch.intaa)) , output_path=output_path / '''text_encoder''' / '''model.onnx''' , ordered_input_names=['''input_ids'''] , output_names=['''last_hidden_state''', '''pooler_output'''] , dynamic_axes={
'''input_ids''': {0: '''batch''', 1: '''sequence'''},
} , opset=a_ , )
del pipeline.text_encoder
# UNET
lowercase :Any = pipeline.unet.config.in_channels
lowercase :List[Any] = pipeline.unet.config.sample_size
lowercase :Optional[int] = output_path / '''unet''' / '''model.onnx'''
onnx_export(
pipeline.unet , model_args=(
torch.randn(2 , a_ , a_ , a_).to(device=a_ , dtype=a_),
torch.randn(2).to(device=a_ , dtype=a_),
torch.randn(2 , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=a_ , ordered_input_names=['''sample''', '''timestep''', '''encoder_hidden_states''', '''return_dict'''] , output_names=['''out_sample'''] , dynamic_axes={
'''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
'''timestep''': {0: '''batch'''},
'''encoder_hidden_states''': {0: '''batch''', 1: '''sequence'''},
} , opset=a_ , use_external_data_format=a_ , )
lowercase :List[Any] = str(unet_path.absolute().as_posix())
lowercase :str = os.path.dirname(a_)
lowercase :Optional[Any] = onnx.load(a_)
# clean up existing tensor files
shutil.rmtree(a_)
os.mkdir(a_)
# collate external tensor files into one
onnx.save_model(
a_ , a_ , save_as_external_data=a_ , all_tensors_to_one_file=a_ , location='''weights.pb''' , convert_attribute=a_ , )
del pipeline.unet
# VAE ENCODER
lowercase :Tuple = pipeline.vae
lowercase :Optional[Any] = vae_encoder.config.in_channels
lowercase :Any = vae_encoder.config.sample_size
# need to get the raw tensor output (sample) from the encoder
lowercase :Any = lambda a_ , a_: vae_encoder.encode(a_ , a_)[0].sample()
onnx_export(
a_ , model_args=(
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=output_path / '''vae_encoder''' / '''model.onnx''' , ordered_input_names=['''sample''', '''return_dict'''] , output_names=['''latent_sample'''] , dynamic_axes={
'''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
} , opset=a_ , )
# VAE DECODER
lowercase :Any = pipeline.vae
lowercase :Dict = vae_decoder.config.latent_channels
lowercase :Union[str, Any] = vae_decoder.config.out_channels
# forward only through the decoder part
lowercase :List[Any] = vae_encoder.decode
onnx_export(
a_ , model_args=(
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=output_path / '''vae_decoder''' / '''model.onnx''' , ordered_input_names=['''latent_sample''', '''return_dict'''] , output_names=['''sample'''] , dynamic_axes={
'''latent_sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
} , opset=a_ , )
del pipeline.vae
# SAFETY CHECKER
if pipeline.safety_checker is not None:
lowercase :Dict = pipeline.safety_checker
lowercase :str = safety_checker.config.vision_config.num_channels
lowercase :str = safety_checker.config.vision_config.image_size
lowercase :List[str] = safety_checker.forward_onnx
onnx_export(
pipeline.safety_checker , model_args=(
torch.randn(
1 , a_ , a_ , a_ , ).to(device=a_ , dtype=a_),
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
) , output_path=output_path / '''safety_checker''' / '''model.onnx''' , ordered_input_names=['''clip_input''', '''images'''] , output_names=['''out_images''', '''has_nsfw_concepts'''] , dynamic_axes={
'''clip_input''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
'''images''': {0: '''batch''', 1: '''height''', 2: '''width''', 3: '''channels'''},
} , opset=a_ , )
del pipeline.safety_checker
lowercase :Tuple = OnnxRuntimeModel.from_pretrained(output_path / '''safety_checker''')
lowercase :Optional[Any] = pipeline.feature_extractor
else:
lowercase :int = None
lowercase :Union[str, Any] = None
lowercase :Optional[int] = OnnxStableDiffusionPipeline(
vae_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_encoder''') , vae_decoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_decoder''') , text_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''text_encoder''') , tokenizer=pipeline.tokenizer , unet=OnnxRuntimeModel.from_pretrained(output_path / '''unet''') , scheduler=pipeline.scheduler , safety_checker=a_ , feature_extractor=a_ , requires_safety_checker=safety_checker is not None , )
onnx_pipeline.save_pretrained(a_)
print('''ONNX pipeline saved to''' , a_)
del pipeline
del onnx_pipeline
lowercase :Tuple = OnnxStableDiffusionPipeline.from_pretrained(a_ , provider='''CPUExecutionProvider''')
print('''ONNX pipeline is loadable''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
parser.add_argument(
'''--model_path''',
type=str,
required=True,
help='''Path to the `diffusers` checkpoint to convert (either a local directory or on the Hub).''',
)
parser.add_argument('''--output_path''', type=str, required=True, help='''Path to the output model.''')
parser.add_argument(
'''--opset''',
default=14,
type=int,
help='''The version of the ONNX operator set to use.''',
)
parser.add_argument('''--fp16''', action='''store_true''', default=False, help='''Export the models in `float16` mode''')
UpperCAmelCase = parser.parse_args()
convert_models(args.model_path, args.output_path, args.opset, args.fpaa)
| 677 |
"""simple docstring"""
def lowerCamelCase (a_ :Tuple , a_ :int , a_ :Tuple , a_ :List[Any]) -> str:
if height >= 1:
move_tower(height - 1 , a_ , a_ , a_)
move_disk(a_ , a_)
move_tower(height - 1 , a_ , a_ , a_)
def lowerCamelCase (a_ :int , a_ :Union[str, Any]) -> str:
print('''moving disk from''' , a_ , '''to''' , a_)
def lowerCamelCase () -> Tuple:
lowercase :int = int(input('''Height of hanoi: ''').strip())
move_tower(a_ , '''A''' , '''B''' , '''C''')
if __name__ == "__main__":
main()
| 677 | 1 |
"""simple docstring"""
import argparse
import math
import os
import torch
from neural_compressor.utils.pytorch import load
from PIL import Image
from transformers import CLIPTextModel, CLIPTokenizer
from diffusers import AutoencoderKL, StableDiffusionPipeline, UNetaDConditionModel
def lowerCamelCase () -> Tuple:
lowercase :List[str] = argparse.ArgumentParser()
parser.add_argument(
'''-m''' , '''--pretrained_model_name_or_path''' , type=a_ , default=a_ , required=a_ , help='''Path to pretrained model or model identifier from huggingface.co/models.''' , )
parser.add_argument(
'''-c''' , '''--caption''' , type=a_ , default='''robotic cat with wings''' , help='''Text used to generate images.''' , )
parser.add_argument(
'''-n''' , '''--images_num''' , type=a_ , default=4 , help='''How much images to generate.''' , )
parser.add_argument(
'''-s''' , '''--seed''' , type=a_ , default=42 , help='''Seed for random process.''' , )
parser.add_argument(
'''-ci''' , '''--cuda_id''' , type=a_ , default=0 , help='''cuda_id.''' , )
lowercase :Any = parser.parse_args()
return args
def lowerCamelCase (a_ :str , a_ :Tuple , a_ :Optional[int]) -> List[str]:
if not len(a_) == rows * cols:
raise ValueError('''The specified number of rows and columns are not correct.''')
lowercase , lowercase :Optional[Any] = imgs[0].size
lowercase :Tuple = Image.new('''RGB''' , size=(cols * w, rows * h))
lowercase , lowercase :Union[str, Any] = grid.size
for i, img in enumerate(a_):
grid.paste(a_ , box=(i % cols * w, i // cols * h))
return grid
def lowerCamelCase (a_ :int , a_ :List[str]="robotic cat with wings" , a_ :Tuple=7.5 , a_ :int=50 , a_ :List[str]=1 , a_ :str=42 , ) -> Any:
lowercase :List[str] = torch.Generator(pipeline.device).manual_seed(a_)
lowercase :Any = pipeline(
a_ , guidance_scale=a_ , num_inference_steps=a_ , generator=a_ , num_images_per_prompt=a_ , ).images
lowercase :List[str] = int(math.sqrt(a_))
lowercase :str = image_grid(a_ , rows=_rows , cols=num_images_per_prompt // _rows)
return grid, images
UpperCAmelCase = parse_args()
# Load models and create wrapper for stable diffusion
UpperCAmelCase = CLIPTokenizer.from_pretrained(args.pretrained_model_name_or_path, subfolder='''tokenizer''')
UpperCAmelCase = CLIPTextModel.from_pretrained(args.pretrained_model_name_or_path, subfolder='''text_encoder''')
UpperCAmelCase = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder='''vae''')
UpperCAmelCase = UNetaDConditionModel.from_pretrained(args.pretrained_model_name_or_path, subfolder='''unet''')
UpperCAmelCase = StableDiffusionPipeline.from_pretrained(
args.pretrained_model_name_or_path, text_encoder=text_encoder, vae=vae, unet=unet, tokenizer=tokenizer
)
UpperCAmelCase = lambda images, clip_input: (images, False)
if os.path.exists(os.path.join(args.pretrained_model_name_or_path, '''best_model.pt''')):
UpperCAmelCase = load(args.pretrained_model_name_or_path, model=unet)
unet.eval()
setattr(pipeline, '''unet''', unet)
else:
UpperCAmelCase = unet.to(torch.device('''cuda''', args.cuda_id))
UpperCAmelCase = pipeline.to(unet.device)
UpperCAmelCase , UpperCAmelCase = generate_images(pipeline, prompt=args.caption, num_images_per_prompt=args.images_num, seed=args.seed)
grid.save(os.path.join(args.pretrained_model_name_or_path, '''{}.png'''.format('''_'''.join(args.caption.split()))))
UpperCAmelCase = os.path.join(args.pretrained_model_name_or_path, '''_'''.join(args.caption.split()))
os.makedirs(dirname, exist_ok=True)
for idx, image in enumerate(images):
image.save(os.path.join(dirname, '''{}.png'''.format(idx + 1)))
| 677 |
"""simple docstring"""
from sklearn.metrics import mean_squared_error
import datasets
UpperCAmelCase = '''\
@article{scikit-learn,
title={Scikit-learn: Machine Learning in {P}ython},
author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
journal={Journal of Machine Learning Research},
volume={12},
pages={2825--2830},
year={2011}
}
'''
UpperCAmelCase = '''\
Mean Squared Error(MSE) is the average of the square of difference between the predicted
and actual values.
'''
UpperCAmelCase = '''
Args:
predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)
Estimated target values.
references: array-like of shape (n_samples,) or (n_samples, n_outputs)
Ground truth (correct) target values.
sample_weight: array-like of shape (n_samples,), default=None
Sample weights.
multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"
Defines aggregating of multiple output values. Array-like value defines weights used to average errors.
"raw_values" : Returns a full set of errors in case of multioutput input.
"uniform_average" : Errors of all outputs are averaged with uniform weight.
squared : bool, default=True
If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.
Returns:
mse : mean squared error.
Examples:
>>> mse_metric = datasets.load_metric("mse")
>>> predictions = [2.5, 0.0, 2, 8]
>>> references = [3, -0.5, 2, 7]
>>> results = mse_metric.compute(predictions=predictions, references=references)
>>> print(results)
{\'mse\': 0.375}
>>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)
>>> print(rmse_result)
{\'mse\': 0.6123724356957945}
If you\'re using multi-dimensional lists, then set the config as follows :
>>> mse_metric = datasets.load_metric("mse", "multilist")
>>> predictions = [[0.5, 1], [-1, 1], [7, -6]]
>>> references = [[0, 2], [-1, 2], [8, -5]]
>>> results = mse_metric.compute(predictions=predictions, references=references)
>>> print(results)
{\'mse\': 0.7083333333333334}
>>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')
>>> print(results) # doctest: +NORMALIZE_WHITESPACE
{\'mse\': array([0.41666667, 1. ])}
'''
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class __magic_name__ ( datasets.Metric ):
def __snake_case ( self : int ):
'''simple docstring'''
return datasets.MetricInfo(
description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(self._get_feature_types() ) , reference_urls=[
'''https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html'''
] , )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
if self.config_name == "multilist":
return {
"predictions": datasets.Sequence(datasets.Value('''float''' ) ),
"references": datasets.Sequence(datasets.Value('''float''' ) ),
}
else:
return {
"predictions": datasets.Value('''float''' ),
"references": datasets.Value('''float''' ),
}
def __snake_case ( self : List[Any] , snake_case__ : str , snake_case__ : int , snake_case__ : str=None , snake_case__ : List[Any]="uniform_average" , snake_case__ : Dict=True ):
'''simple docstring'''
lowercase :Dict = mean_squared_error(
snake_case__ , snake_case__ , sample_weight=snake_case__ , multioutput=snake_case__ , squared=snake_case__ )
return {"mse": mse}
| 677 | 1 |
"""simple docstring"""
import json
from typing import List, Optional, Tuple
from tokenizers import normalizers
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_electra import ElectraTokenizer
UpperCAmelCase = {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}
UpperCAmelCase = {
'''vocab_file''': {
'''google/electra-small-generator''': (
'''https://huggingface.co/google/electra-small-generator/resolve/main/vocab.txt'''
),
'''google/electra-base-generator''': '''https://huggingface.co/google/electra-base-generator/resolve/main/vocab.txt''',
'''google/electra-large-generator''': (
'''https://huggingface.co/google/electra-large-generator/resolve/main/vocab.txt'''
),
'''google/electra-small-discriminator''': (
'''https://huggingface.co/google/electra-small-discriminator/resolve/main/vocab.txt'''
),
'''google/electra-base-discriminator''': (
'''https://huggingface.co/google/electra-base-discriminator/resolve/main/vocab.txt'''
),
'''google/electra-large-discriminator''': (
'''https://huggingface.co/google/electra-large-discriminator/resolve/main/vocab.txt'''
),
},
'''tokenizer_file''': {
'''google/electra-small-generator''': (
'''https://huggingface.co/google/electra-small-generator/resolve/main/tokenizer.json'''
),
'''google/electra-base-generator''': (
'''https://huggingface.co/google/electra-base-generator/resolve/main/tokenizer.json'''
),
'''google/electra-large-generator''': (
'''https://huggingface.co/google/electra-large-generator/resolve/main/tokenizer.json'''
),
'''google/electra-small-discriminator''': (
'''https://huggingface.co/google/electra-small-discriminator/resolve/main/tokenizer.json'''
),
'''google/electra-base-discriminator''': (
'''https://huggingface.co/google/electra-base-discriminator/resolve/main/tokenizer.json'''
),
'''google/electra-large-discriminator''': (
'''https://huggingface.co/google/electra-large-discriminator/resolve/main/tokenizer.json'''
),
},
}
UpperCAmelCase = {
'''google/electra-small-generator''': 512,
'''google/electra-base-generator''': 512,
'''google/electra-large-generator''': 512,
'''google/electra-small-discriminator''': 512,
'''google/electra-base-discriminator''': 512,
'''google/electra-large-discriminator''': 512,
}
UpperCAmelCase = {
'''google/electra-small-generator''': {'''do_lower_case''': True},
'''google/electra-base-generator''': {'''do_lower_case''': True},
'''google/electra-large-generator''': {'''do_lower_case''': True},
'''google/electra-small-discriminator''': {'''do_lower_case''': True},
'''google/electra-base-discriminator''': {'''do_lower_case''': True},
'''google/electra-large-discriminator''': {'''do_lower_case''': True},
}
class __magic_name__ ( __UpperCAmelCase ):
__A : Dict = VOCAB_FILES_NAMES
__A : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP
__A : Any = PRETRAINED_INIT_CONFIGURATION
__A : int = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
__A : List[Any] = ElectraTokenizer
def __init__( self : Dict , snake_case__ : Optional[int]=None , snake_case__ : List[Any]=None , snake_case__ : Any=True , snake_case__ : Tuple="[UNK]" , snake_case__ : Tuple="[SEP]" , snake_case__ : str="[PAD]" , snake_case__ : Dict="[CLS]" , snake_case__ : Union[str, Any]="[MASK]" , snake_case__ : Optional[Any]=True , snake_case__ : str=None , **snake_case__ : Optional[int] , ):
'''simple docstring'''
super().__init__(
snake_case__ , tokenizer_file=snake_case__ , do_lower_case=snake_case__ , unk_token=snake_case__ , sep_token=snake_case__ , pad_token=snake_case__ , cls_token=snake_case__ , mask_token=snake_case__ , tokenize_chinese_chars=snake_case__ , strip_accents=snake_case__ , **snake_case__ , )
lowercase :Union[str, Any] = json.loads(self.backend_tokenizer.normalizer.__getstate__() )
if (
normalizer_state.get('''lowercase''' , snake_case__ ) != do_lower_case
or normalizer_state.get('''strip_accents''' , snake_case__ ) != strip_accents
or normalizer_state.get('''handle_chinese_chars''' , snake_case__ ) != tokenize_chinese_chars
):
lowercase :Any = getattr(snake_case__ , normalizer_state.pop('''type''' ) )
lowercase :int = do_lower_case
lowercase :List[Any] = strip_accents
lowercase :Optional[Any] = tokenize_chinese_chars
lowercase :Tuple = normalizer_class(**snake_case__ )
lowercase :List[str] = do_lower_case
def __snake_case ( self : Any , snake_case__ : Dict , snake_case__ : Any=None ):
'''simple docstring'''
lowercase :int = [self.cls_token_id] + token_ids_a + [self.sep_token_id]
if token_ids_a:
output += token_ids_a + [self.sep_token_id]
return output
def __snake_case ( self : Tuple , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ):
'''simple docstring'''
lowercase :Tuple = [self.sep_token_id]
lowercase :List[str] = [self.cls_token_id]
if token_ids_a is None:
return len(cls + token_ids_a + sep ) * [0]
return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]
def __snake_case ( self : Optional[Any] , snake_case__ : str , snake_case__ : Optional[str] = None ):
'''simple docstring'''
lowercase :str = self._tokenizer.model.save(snake_case__ , name=snake_case__ )
return tuple(snake_case__ )
| 677 |
"""simple docstring"""
from abc import ABC, abstractmethod
from argparse import ArgumentParser
class __magic_name__ ( __UpperCAmelCase ):
@staticmethod
@abstractmethod
def __snake_case ( snake_case__ : ArgumentParser ):
'''simple docstring'''
raise NotImplementedError()
@abstractmethod
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
raise NotImplementedError()
| 677 | 1 |
"""simple docstring"""
import json
import os
import tempfile
import transformers
import datasets
from utils import generate_example_dataset, get_duration
UpperCAmelCase = 500_000
UpperCAmelCase , UpperCAmelCase = os.path.split(__file__)
UpperCAmelCase = os.path.join(RESULTS_BASEPATH, '''results''', RESULTS_FILENAME.replace('''.py''', '''.json'''))
@get_duration
def lowerCamelCase (a_ :datasets.Dataset , **a_ :Tuple) -> Tuple:
lowercase :Any = dataset.map(**a_)
@get_duration
def lowerCamelCase (a_ :datasets.Dataset , **a_ :int) -> str:
lowercase :int = dataset.filter(**a_)
def lowerCamelCase () -> Any:
lowercase :Union[str, Any] = {'''num examples''': SPEED_TEST_N_EXAMPLES}
with tempfile.TemporaryDirectory() as tmp_dir:
lowercase :List[str] = datasets.Features({'''text''': datasets.Value('''string'''), '''numbers''': datasets.Value('''float32''')})
lowercase :Optional[Any] = generate_example_dataset(
os.path.join(a_ , '''dataset.arrow''') , a_ , num_examples=a_)
lowercase :List[Any] = transformers.AutoTokenizer.from_pretrained('''bert-base-cased''' , use_fast=a_)
def tokenize(a_ :Tuple):
return tokenizer(examples['''text'''])
lowercase :Dict = map(a_)
lowercase :Optional[int] = map(a_ , batched=a_)
lowercase :Tuple = map(a_ , function=lambda a_: None , batched=a_)
with dataset.formatted_as(type='''numpy'''):
lowercase :Optional[Any] = map(a_ , function=lambda a_: None , batched=a_)
with dataset.formatted_as(type='''pandas'''):
lowercase :Union[str, Any] = map(a_ , function=lambda a_: None , batched=a_)
with dataset.formatted_as(type='''torch''' , columns='''numbers'''):
lowercase :str = map(a_ , function=lambda a_: None , batched=a_)
with dataset.formatted_as(type='''tensorflow''' , columns='''numbers'''):
lowercase :Optional[int] = map(a_ , function=lambda a_: None , batched=a_)
lowercase :Dict = map(a_ , function=a_ , batched=a_)
lowercase :int = filter(a_)
# Activate later when tokenizer support batched inputs
# with dataset.formatted_as(type='numpy'):
# times[func.__name__ + " fast-tokenizer batched numpy"] = func(dataset, function=tokenize, batched=True)
with open(a_ , '''wb''') as f:
f.write(json.dumps(a_).encode('''utf-8'''))
if __name__ == "__main__": # useful to run the profiler
benchmark_map_filter()
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_encodec''': [
'''ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''EncodecConfig''',
],
'''feature_extraction_encodec''': ['''EncodecFeatureExtractor'''],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''EncodecModel''',
'''EncodecPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_encodec import (
ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP,
EncodecConfig,
)
from .feature_extraction_encodec import EncodecFeatureExtractor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_encodec import (
ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST,
EncodecModel,
EncodecPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
def lowerCamelCase (a_ :int , a_ :int) -> str:
if not isinstance(a_ , a_):
raise ValueError('''iterations must be defined as integers''')
if not isinstance(a_ , a_) or not number >= 1:
raise ValueError(
'''starting number must be
and integer and be more than 0''')
if not iterations >= 1:
raise ValueError('''Iterations must be done more than 0 times to play FizzBuzz''')
lowercase :Optional[int] = ''''''
while number <= iterations:
if number % 3 == 0:
out += "Fizz"
if number % 5 == 0:
out += "Buzz"
if 0 not in (number % 3, number % 5):
out += str(a_)
# print(out)
number += 1
out += " "
return out
if __name__ == "__main__":
import doctest
doctest.testmod()
| 677 |
"""simple docstring"""
import inspect
import unittest
from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available
from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor
if is_flax_available():
import jax
import jax.numpy as jnp
from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel
if is_vision_available():
from PIL import Image
from transformers import AutoImageProcessor
class __magic_name__ ( unittest.TestCase ):
def __init__( self : List[Any] , snake_case__ : Optional[int] , snake_case__ : List[str]=3 , snake_case__ : int=3_2 , snake_case__ : int=3 , snake_case__ : str=1_0 , snake_case__ : str=[1_0, 2_0, 3_0, 4_0] , snake_case__ : int=[1, 1, 2, 1] , snake_case__ : List[Any]=True , snake_case__ : Tuple=True , snake_case__ : Optional[Any]="relu" , snake_case__ : Optional[int]=3 , snake_case__ : Optional[Any]=None , ):
'''simple docstring'''
lowercase :Union[str, Any] = parent
lowercase :Optional[Any] = batch_size
lowercase :Dict = image_size
lowercase :Any = num_channels
lowercase :List[str] = embeddings_size
lowercase :Union[str, Any] = hidden_sizes
lowercase :Any = depths
lowercase :Dict = is_training
lowercase :Any = use_labels
lowercase :Any = hidden_act
lowercase :List[str] = num_labels
lowercase :List[Any] = scope
lowercase :int = len(snake_case__ )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :Optional[int] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
lowercase :Union[str, Any] = self.get_config()
return config, pixel_values
def __snake_case ( self : Dict ):
'''simple docstring'''
return RegNetConfig(
num_channels=self.num_channels , embeddings_size=self.embeddings_size , hidden_sizes=self.hidden_sizes , depths=self.depths , hidden_act=self.hidden_act , num_labels=self.num_labels , image_size=self.image_size , )
def __snake_case ( self : str , snake_case__ : Tuple , snake_case__ : List[Any] ):
'''simple docstring'''
lowercase :Any = FlaxRegNetModel(config=snake_case__ )
lowercase :str = model(snake_case__ )
# Output shape (b, c, h, w)
self.parent.assertEqual(
result.last_hidden_state.shape , (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2) , )
def __snake_case ( self : List[str] , snake_case__ : Optional[int] , snake_case__ : str ):
'''simple docstring'''
lowercase :Tuple = self.num_labels
lowercase :str = FlaxRegNetForImageClassification(config=snake_case__ )
lowercase :Union[str, Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :int = self.prepare_config_and_inputs()
lowercase , lowercase :Tuple = config_and_inputs
lowercase :Union[str, Any] = {'''pixel_values''': pixel_values}
return config, inputs_dict
@require_flax
class __magic_name__ ( __UpperCAmelCase , unittest.TestCase ):
__A : List[Any] = (FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()
__A : str = False
__A : Tuple = False
__A : Dict = False
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :Dict = FlaxRegNetModelTester(self )
lowercase :Tuple = ConfigTester(self , config_class=snake_case__ , has_text_modality=snake_case__ )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
self.create_and_test_config_common_properties()
self.config_tester.create_and_test_config_to_json_string()
self.config_tester.create_and_test_config_to_json_file()
self.config_tester.create_and_test_config_from_and_save_pretrained()
self.config_tester.create_and_test_config_with_num_labels()
self.config_tester.check_config_can_be_init_without_params()
self.config_tester.check_config_arguments_init()
def __snake_case ( self : List[Any] ):
'''simple docstring'''
return
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :Dict = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_image_classification(*snake_case__ )
@unittest.skip(reason='''RegNet does not use inputs_embeds''' )
def __snake_case ( self : Tuple ):
'''simple docstring'''
pass
@unittest.skip(reason='''RegNet does not support input and output embeddings''' )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
pass
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :Union[str, Any] = model_class(snake_case__ )
lowercase :int = inspect.signature(model.__call__ )
# signature.parameters is an OrderedDict => so arg_names order is deterministic
lowercase :Tuple = [*signature.parameters.keys()]
lowercase :Tuple = ['''pixel_values''']
self.assertListEqual(arg_names[:1] , snake_case__ )
def __snake_case ( self : Tuple ):
'''simple docstring'''
def check_hidden_states_output(snake_case__ : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[int] ):
lowercase :int = model_class(snake_case__ )
lowercase :Tuple = model(**self._prepare_for_class(snake_case__ , snake_case__ ) )
lowercase :Any = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
lowercase :Dict = self.model_tester.num_stages
self.assertEqual(len(snake_case__ ) , expected_num_stages + 1 )
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :Optional[int] = True
check_hidden_states_output(snake_case__ , snake_case__ , snake_case__ )
# check that output_hidden_states also work using config
del inputs_dict["output_hidden_states"]
lowercase :str = True
check_hidden_states_output(snake_case__ , snake_case__ , snake_case__ )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
with self.subTest(model_class.__name__ ):
lowercase :Optional[Any] = self._prepare_for_class(snake_case__ , snake_case__ )
lowercase :List[Any] = model_class(snake_case__ )
@jax.jit
def model_jitted(snake_case__ : str , **snake_case__ : Optional[int] ):
return model(pixel_values=snake_case__ , **snake_case__ )
with self.subTest('''JIT Enabled''' ):
lowercase :Optional[int] = model_jitted(**snake_case__ ).to_tuple()
with self.subTest('''JIT Disabled''' ):
with jax.disable_jit():
lowercase :Optional[int] = model_jitted(**snake_case__ ).to_tuple()
self.assertEqual(len(snake_case__ ) , len(snake_case__ ) )
for jitted_output, output in zip(snake_case__ , snake_case__ ):
self.assertEqual(jitted_output.shape , output.shape )
def lowerCamelCase () -> Tuple:
lowercase :Tuple = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
return image
@require_flax
class __magic_name__ ( unittest.TestCase ):
@cached_property
def __snake_case ( self : int ):
'''simple docstring'''
return AutoImageProcessor.from_pretrained('''facebook/regnet-y-040''' ) if is_vision_available() else None
@slow
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :int = FlaxRegNetForImageClassification.from_pretrained('''facebook/regnet-y-040''' )
lowercase :Optional[Any] = self.default_image_processor
lowercase :Dict = prepare_img()
lowercase :Any = image_processor(images=snake_case__ , return_tensors='''np''' )
lowercase :List[str] = model(**snake_case__ )
# verify the logits
lowercase :Any = (1, 1_0_0_0)
self.assertEqual(outputs.logits.shape , snake_case__ )
lowercase :List[Any] = jnp.array([-0.41_80, -1.50_51, -3.48_36] )
self.assertTrue(jnp.allclose(outputs.logits[0, :3] , snake_case__ , atol=1e-4 ) )
| 677 | 1 |
"""simple docstring"""
import uuid
from typing import Any, Dict, List, Optional, Union
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline
if is_tf_available():
import tensorflow as tf
if is_torch_available():
import torch
UpperCAmelCase = logging.get_logger(__name__)
class __magic_name__ :
def __init__( self : Tuple , snake_case__ : str = None , snake_case__ : uuid.UUID = None , snake_case__ : Optional[int]=None , snake_case__ : Tuple=None ):
'''simple docstring'''
if not conversation_id:
lowercase :List[Any] = uuid.uuida()
if past_user_inputs is None:
lowercase :Union[str, Any] = []
if generated_responses is None:
lowercase :List[str] = []
lowercase :uuid.UUID = conversation_id
lowercase :List[str] = past_user_inputs
lowercase :List[str] = generated_responses
lowercase :Optional[str] = text
def __eq__( self : Optional[Any] , snake_case__ : str ):
'''simple docstring'''
if not isinstance(snake_case__ , snake_case__ ):
return False
if self.uuid == other.uuid:
return True
return (
self.new_user_input == other.new_user_input
and self.past_user_inputs == other.past_user_inputs
and self.generated_responses == other.generated_responses
)
def __snake_case ( self : Optional[int] , snake_case__ : str , snake_case__ : bool = False ):
'''simple docstring'''
if self.new_user_input:
if overwrite:
logger.warning(
f"""User input added while unprocessed input was existing: \"{self.new_user_input}\" was overwritten """
f"""with: \"{text}\".""" )
lowercase :List[str] = text
else:
logger.warning(
f"""User input added while unprocessed input was existing: \"{self.new_user_input}\" new input """
f"""ignored: \"{text}\". Set `overwrite` to True to overwrite unprocessed user input""" )
else:
lowercase :Optional[int] = text
def __snake_case ( self : Any ):
'''simple docstring'''
if self.new_user_input:
self.past_user_inputs.append(self.new_user_input )
lowercase :Tuple = None
def __snake_case ( self : Tuple , snake_case__ : str ):
'''simple docstring'''
self.generated_responses.append(snake_case__ )
def __snake_case ( self : Tuple ):
'''simple docstring'''
for user_input, generated_response in zip(self.past_user_inputs , self.generated_responses ):
yield True, user_input
yield False, generated_response
if self.new_user_input:
yield True, self.new_user_input
def __repr__( self : Dict ):
'''simple docstring'''
lowercase :int = f"""Conversation id: {self.uuid} \n"""
for is_user, text in self.iter_texts():
lowercase :Dict = '''user''' if is_user else '''bot'''
output += f"""{name} >> {text} \n"""
return output
@add_end_docstrings(
__UpperCAmelCase , R"\n min_length_for_response (`int`, *optional*, defaults to 32):\n The minimum length (in number of tokens) for a response.\n minimum_tokens (`int`, *optional*, defaults to 10):\n The minimum length of tokens to leave for a response.\n " , )
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Optional[Any] , *snake_case__ : Optional[Any] , **snake_case__ : List[Any] ):
'''simple docstring'''
super().__init__(*snake_case__ , **snake_case__ )
if self.tokenizer.pad_token_id is None:
lowercase :Any = self.tokenizer.eos_token
def __snake_case ( self : List[Any] , snake_case__ : Optional[int]=None , snake_case__ : Union[str, Any]=None , snake_case__ : List[str]=None , **snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase :str = {}
lowercase :List[str] = {}
lowercase :Tuple = {}
if min_length_for_response is not None:
lowercase :Dict = min_length_for_response
if minimum_tokens is not None:
lowercase :Union[str, Any] = minimum_tokens
if "max_length" in generate_kwargs:
lowercase :List[Any] = generate_kwargs['''max_length''']
# self.max_length = generate_kwargs.get("max_length", self.model.config.max_length)
if clean_up_tokenization_spaces is not None:
lowercase :Dict = clean_up_tokenization_spaces
if generate_kwargs:
forward_params.update(snake_case__ )
return preprocess_params, forward_params, postprocess_params
def __call__( self : List[Any] , snake_case__ : Union[Conversation, List[Conversation]] , snake_case__ : int=0 , **snake_case__ : int ):
'''simple docstring'''
lowercase :int = super().__call__(snake_case__ , num_workers=snake_case__ , **snake_case__ )
if isinstance(snake_case__ , snake_case__ ) and len(snake_case__ ) == 1:
return outputs[0]
return outputs
def __snake_case ( self : List[Any] , snake_case__ : Conversation , snake_case__ : Any=3_2 ):
'''simple docstring'''
if not isinstance(snake_case__ , snake_case__ ):
raise ValueError('''ConversationalPipeline, expects Conversation as inputs''' )
if conversation.new_user_input is None:
raise ValueError(
f"""Conversation with UUID {type(conversation.uuid )} does not contain new user input to process. """
'''Add user inputs with the conversation\'s `add_user_input` method''' )
if hasattr(self.tokenizer , '''_build_conversation_input_ids''' ):
lowercase :List[str] = self.tokenizer._build_conversation_input_ids(snake_case__ )
else:
# If the tokenizer cannot handle conversations, we default to only the old version
lowercase :List[str] = self._legacy_parse_and_tokenize(snake_case__ )
if self.framework == "pt":
lowercase :int = torch.LongTensor([input_ids] )
elif self.framework == "tf":
lowercase :Any = tf.constant([input_ids] )
return {"input_ids": input_ids, "conversation": conversation}
def __snake_case ( self : int , snake_case__ : Union[str, Any] , snake_case__ : Any=1_0 , **snake_case__ : int ):
'''simple docstring'''
lowercase :Dict = generate_kwargs.get('''max_length''' , self.model.config.max_length )
lowercase :Optional[Any] = model_inputs['''input_ids'''].shape[1]
if max_length - minimum_tokens < n:
logger.warning(f"""Conversation input is to long ({n}), trimming it to ({max_length} - {minimum_tokens})""" )
lowercase :int = max_length - minimum_tokens
lowercase :int = model_inputs['''input_ids'''][:, -trim:]
if "attention_mask" in model_inputs:
lowercase :int = model_inputs['''attention_mask'''][:, -trim:]
lowercase :int = model_inputs.pop('''conversation''' )
lowercase :Union[str, Any] = max_length
lowercase :Dict = self.model.generate(**snake_case__ , **snake_case__ )
if self.model.config.is_encoder_decoder:
lowercase :List[Any] = 1
else:
lowercase :Optional[Any] = n
return {"output_ids": output_ids[:, start_position:], "conversation": conversation}
def __snake_case ( self : Optional[int] , snake_case__ : List[Any] , snake_case__ : Optional[Any]=True ):
'''simple docstring'''
lowercase :Dict = model_outputs['''output_ids''']
lowercase :Dict = self.tokenizer.decode(
output_ids[0] , skip_special_tokens=snake_case__ , clean_up_tokenization_spaces=snake_case__ , )
lowercase :Optional[int] = model_outputs['''conversation''']
conversation.mark_processed()
conversation.append_response(snake_case__ )
return conversation
def __snake_case ( self : List[Any] , snake_case__ : Conversation ):
'''simple docstring'''
lowercase :str = self.tokenizer.eos_token_id
lowercase :List[Any] = []
for is_user, text in conversation.iter_texts():
if eos_token_id is not None:
input_ids.extend(self.tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ ) + [eos_token_id] )
else:
input_ids.extend(self.tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ ) )
if len(snake_case__ ) > self.tokenizer.model_max_length:
lowercase :List[Any] = input_ids[-self.tokenizer.model_max_length :]
return input_ids
| 677 |
"""simple docstring"""
UpperCAmelCase = {
'''A''': ['''B''', '''C''', '''E'''],
'''B''': ['''A''', '''D''', '''E'''],
'''C''': ['''A''', '''F''', '''G'''],
'''D''': ['''B'''],
'''E''': ['''A''', '''B''', '''D'''],
'''F''': ['''C'''],
'''G''': ['''C'''],
}
def lowerCamelCase (a_ :dict , a_ :List[str] , a_ :Tuple) -> list[str]:
lowercase :str = set()
# keep track of all the paths to be checked
lowercase :Dict = [[start]]
# return path if start is goal
if start == goal:
return [start]
# keeps looping until all possible paths have been checked
while queue:
# pop the first path from the queue
lowercase :Optional[int] = queue.pop(0)
# get the last node from the path
lowercase :Any = path[-1]
if node not in explored:
lowercase :int = graph[node]
# go through all neighbour nodes, construct a new path and
# push it into the queue
for neighbour in neighbours:
lowercase :List[Any] = list(a_)
new_path.append(a_)
queue.append(a_)
# return path if neighbour is goal
if neighbour == goal:
return new_path
# mark node as explored
explored.add(a_)
# in case there's no path between the 2 nodes
return []
def lowerCamelCase (a_ :dict , a_ :List[Any] , a_ :List[Any]) -> int:
if not graph or start not in graph or target not in graph:
return -1
if start == target:
return 0
lowercase :List[str] = [start]
lowercase :Optional[Any] = set(a_)
# Keep tab on distances from `start` node.
lowercase :Union[str, Any] = {start: 0, target: -1}
while queue:
lowercase :Union[str, Any] = queue.pop(0)
if node == target:
lowercase :Any = (
dist[node] if dist[target] == -1 else min(dist[target] , dist[node])
)
for adjacent in graph[node]:
if adjacent not in visited:
visited.add(a_)
queue.append(a_)
lowercase :Dict = dist[node] + 1
return dist[target]
if __name__ == "__main__":
print(bfs_shortest_path(demo_graph, '''G''', '''D''')) # returns ['G', 'C', 'A', 'B', 'D']
print(bfs_shortest_path_distance(demo_graph, '''G''', '''D''')) # returns 4
| 677 | 1 |
"""simple docstring"""
from __future__ import annotations
def lowerCamelCase (a_ :int | str) -> bool:
lowercase :int = str(a_)
return n == n[::-1]
def lowerCamelCase (a_ :int = 100_0000) -> Tuple:
lowercase :Dict = 0
for i in range(1 , a_):
if is_palindrome(a_) and is_palindrome(bin(a_).split('''b''')[1]):
total += i
return total
if __name__ == "__main__":
print(solution(int(str(input().strip()))))
| 677 |
"""simple docstring"""
import logging
import os
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from tempfile import TemporaryDirectory
from typing import List, Optional
import faiss
import torch
from datasets import Features, Sequence, Value, load_dataset
from transformers import DPRContextEncoder, DPRContextEncoderTokenizerFast, HfArgumentParser
UpperCAmelCase = logging.getLogger(__name__)
torch.set_grad_enabled(False)
UpperCAmelCase = '''cuda''' if torch.cuda.is_available() else '''cpu'''
def lowerCamelCase (a_ :str , a_ :List[str]=100 , a_ :Optional[Any]=" ") -> List[str]:
lowercase :str = text.split(a_)
return [character.join(text[i : i + n]).strip() for i in range(0 , len(a_) , a_)]
def lowerCamelCase (a_ :dict) -> dict:
lowercase , lowercase :str = [], []
for title, text in zip(documents['''title'''] , documents['''text''']):
if text is not None:
for passage in split_text(a_):
titles.append(title if title is not None else '''''')
texts.append(a_)
return {"title": titles, "text": texts}
def lowerCamelCase (a_ :dict , a_ :DPRContextEncoder , a_ :DPRContextEncoderTokenizerFast) -> dict:
lowercase :Tuple = ctx_tokenizer(
documents['''title'''] , documents['''text'''] , truncation=a_ , padding='''longest''' , return_tensors='''pt''')['''input_ids''']
lowercase :Optional[Any] = ctx_encoder(input_ids.to(device=a_) , return_dict=a_).pooler_output
return {"embeddings": embeddings.detach().cpu().numpy()}
def lowerCamelCase (a_ :"RagExampleArguments" , a_ :"ProcessingArguments" , a_ :"IndexHnswArguments" , ) -> Any:
######################################
logger.info('''Step 1 - Create the dataset''')
######################################
# The dataset needed for RAG must have three columns:
# - title (string): title of the document
# - text (string): text of a passage of the document
# - embeddings (array of dimension d): DPR representation of the passage
# Let's say you have documents in tab-separated csv files with columns "title" and "text"
assert os.path.isfile(rag_example_args.csv_path), "Please provide a valid path to a csv file"
# You can load a Dataset object this way
lowercase :List[Any] = load_dataset(
'''csv''' , data_files=[rag_example_args.csv_path] , split='''train''' , delimiter='''\t''' , column_names=['''title''', '''text'''])
# More info about loading csv files in the documentation: https://huggingface.co/docs/datasets/loading_datasets.html?highlight=csv#csv-files
# Then split the documents into passages of 100 words
lowercase :Optional[Any] = dataset.map(a_ , batched=a_ , num_proc=processing_args.num_proc)
# And compute the embeddings
lowercase :str = DPRContextEncoder.from_pretrained(rag_example_args.dpr_ctx_encoder_model_name).to(device=a_)
lowercase :Dict = DPRContextEncoderTokenizerFast.from_pretrained(rag_example_args.dpr_ctx_encoder_model_name)
lowercase :str = Features(
{'''text''': Value('''string'''), '''title''': Value('''string'''), '''embeddings''': Sequence(Value('''float32'''))}) # optional, save as float32 instead of float64 to save space
lowercase :Optional[Any] = dataset.map(
partial(a_ , ctx_encoder=a_ , ctx_tokenizer=a_) , batched=a_ , batch_size=processing_args.batch_size , features=a_ , )
# And finally save your dataset
lowercase :str = os.path.join(rag_example_args.output_dir , '''my_knowledge_dataset''')
dataset.save_to_disk(a_)
# from datasets import load_from_disk
# dataset = load_from_disk(passages_path) # to reload the dataset
######################################
logger.info('''Step 2 - Index the dataset''')
######################################
# Let's use the Faiss implementation of HNSW for fast approximate nearest neighbor search
lowercase :str = faiss.IndexHNSWFlat(index_hnsw_args.d , index_hnsw_args.m , faiss.METRIC_INNER_PRODUCT)
dataset.add_faiss_index('''embeddings''' , custom_index=a_)
# And save the index
lowercase :Optional[Any] = os.path.join(rag_example_args.output_dir , '''my_knowledge_dataset_hnsw_index.faiss''')
dataset.get_index('''embeddings''').save(a_)
# dataset.load_faiss_index("embeddings", index_path) # to reload the index
@dataclass
class __magic_name__ :
__A : str = field(
default=str(Path(__UpperCAmelCase ).parent / "test_run" / "dummy-kb" / "my_knowledge_dataset.csv" ) , metadata={"help": "Path to a tab-separated csv file with columns 'title' and 'text'"} , )
__A : Optional[str] = field(
default=__UpperCAmelCase , metadata={"help": "Question that is passed as input to RAG. Default is 'What does Moses' rod turn into ?'."} , )
__A : str = field(
default="facebook/rag-sequence-nq" , metadata={"help": "The RAG model to use. Either 'facebook/rag-sequence-nq' or 'facebook/rag-token-nq'"} , )
__A : str = field(
default="facebook/dpr-ctx_encoder-multiset-base" , metadata={
"help": (
"The DPR context encoder model to use. Either 'facebook/dpr-ctx_encoder-single-nq-base' or"
" 'facebook/dpr-ctx_encoder-multiset-base'"
)
} , )
__A : Optional[str] = field(
default=str(Path(__UpperCAmelCase ).parent / "test_run" / "dummy-kb" ) , metadata={"help": "Path to a directory where the dataset passages and the index will be saved"} , )
@dataclass
class __magic_name__ :
__A : Optional[int] = field(
default=__UpperCAmelCase , metadata={
"help": "The number of processes to use to split the documents into passages. Default is single process."
} , )
__A : int = field(
default=16 , metadata={
"help": "The batch size to use when computing the passages embeddings using the DPR context encoder."
} , )
@dataclass
class __magic_name__ :
__A : int = field(
default=7_68 , metadata={"help": "The dimension of the embeddings to pass to the HNSW Faiss index."} , )
__A : int = field(
default=1_28 , metadata={
"help": (
"The number of bi-directional links created for every new element during the HNSW index construction."
)
} , )
if __name__ == "__main__":
logging.basicConfig(level=logging.WARNING)
logger.setLevel(logging.INFO)
UpperCAmelCase = HfArgumentParser((RagExampleArguments, ProcessingArguments, IndexHnswArguments))
UpperCAmelCase , UpperCAmelCase , UpperCAmelCase = parser.parse_args_into_dataclasses()
with TemporaryDirectory() as tmp_dir:
UpperCAmelCase = rag_example_args.output_dir or tmp_dir
main(rag_example_args, processing_args, index_hnsw_args)
| 677 | 1 |
"""simple docstring"""
import argparse
import os
from transformers.utils import direct_transformers_import
# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_task_guides.py
UpperCAmelCase = '''src/transformers'''
UpperCAmelCase = '''docs/source/en/tasks'''
def lowerCamelCase (a_ :List[Any] , a_ :Optional[int] , a_ :List[str]) -> int:
with open(a_ , '''r''' , encoding='''utf-8''' , newline='''\n''') as f:
lowercase :int = f.readlines()
# Find the start prompt.
lowercase :List[str] = 0
while not lines[start_index].startswith(a_):
start_index += 1
start_index += 1
lowercase :Optional[int] = start_index
while not lines[end_index].startswith(a_):
end_index += 1
end_index -= 1
while len(lines[start_index]) <= 1:
start_index += 1
while len(lines[end_index]) <= 1:
end_index -= 1
end_index += 1
return "".join(lines[start_index:end_index]), start_index, end_index, lines
# This is to make sure the transformers module imported is the one in the repo.
UpperCAmelCase = direct_transformers_import(TRANSFORMERS_PATH)
UpperCAmelCase = {
'''asr.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_CTC_MAPPING_NAMES,
'''audio_classification.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES,
'''language_modeling.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_CAUSAL_LM_MAPPING_NAMES,
'''image_classification.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES,
'''masked_language_modeling.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_MASKED_LM_MAPPING_NAMES,
'''multiple_choice.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES,
'''object_detection.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_OBJECT_DETECTION_MAPPING_NAMES,
'''question_answering.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES,
'''semantic_segmentation.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING_NAMES,
'''sequence_classification.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES,
'''summarization.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES,
'''token_classification.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES,
'''translation.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES,
'''video_classification.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING_NAMES,
'''document_question_answering.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING_NAMES,
'''monocular_depth_estimation.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_DEPTH_ESTIMATION_MAPPING_NAMES,
}
# This list contains model types used in some task guides that are not in `CONFIG_MAPPING_NAMES` (therefore not in any
# `MODEL_MAPPING_NAMES` or any `MODEL_FOR_XXX_MAPPING_NAMES`).
UpperCAmelCase = {
'''summarization.md''': ('''nllb''',),
'''translation.md''': ('''nllb''',),
}
def lowerCamelCase (a_ :Any) -> Any:
lowercase :int = TASK_GUIDE_TO_MODELS[task_guide]
lowercase :Optional[Any] = SPECIAL_TASK_GUIDE_TO_MODEL_TYPES.get(a_ , set())
lowercase :Tuple = {
code: name
for code, name in transformers_module.MODEL_NAMES_MAPPING.items()
if (code in model_maping_names or code in special_model_types)
}
return ", ".join([F"""[{name}](../model_doc/{code})""" for code, name in model_names.items()]) + "\n"
def lowerCamelCase (a_ :List[Any] , a_ :List[Any]=False) -> List[str]:
lowercase , lowercase , lowercase , lowercase :Optional[int] = _find_text_in_file(
filename=os.path.join(a_ , a_) , start_prompt='''<!--This tip is automatically generated by `make fix-copies`, do not fill manually!-->''' , end_prompt='''<!--End of the generated tip-->''' , )
lowercase :List[str] = get_model_list_for_task(a_)
if current_list != new_list:
if overwrite:
with open(os.path.join(a_ , a_) , '''w''' , encoding='''utf-8''' , newline='''\n''') as f:
f.writelines(lines[:start_index] + [new_list] + lines[end_index:])
else:
raise ValueError(
F"""The list of models that can be used in the {task_guide} guide needs an update. Run `make fix-copies`"""
''' to fix this.''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
parser.add_argument('''--fix_and_overwrite''', action='''store_true''', help='''Whether to fix inconsistencies.''')
UpperCAmelCase = parser.parse_args()
for task_guide in TASK_GUIDE_TO_MODELS.keys():
check_model_list_for_task(task_guide, args.fix_and_overwrite)
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available
UpperCAmelCase = {
'''configuration_longt5''': ['''LONGT5_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''LongT5Config''', '''LongT5OnnxConfig'''],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''LONGT5_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''LongT5EncoderModel''',
'''LongT5ForConditionalGeneration''',
'''LongT5Model''',
'''LongT5PreTrainedModel''',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxLongT5ForConditionalGeneration''',
'''FlaxLongT5Model''',
'''FlaxLongT5PreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_longta import LONGT5_PRETRAINED_CONFIG_ARCHIVE_MAP, LongTaConfig, LongTaOnnxConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_longta import (
LONGT5_PRETRAINED_MODEL_ARCHIVE_LIST,
LongTaEncoderModel,
LongTaForConditionalGeneration,
LongTaModel,
LongTaPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_longta import (
FlaxLongTaForConditionalGeneration,
FlaxLongTaModel,
FlaxLongTaPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
import qiskit
def lowerCamelCase (a_ :int , a_ :int) -> qiskit.result.counts.Counts:
lowercase :int = qiskit.Aer.get_backend('''aer_simulator''')
# Create a Quantum Circuit acting on the q register
lowercase :Dict = qiskit.QuantumCircuit(a_ , a_)
# Apply X (NOT) Gate to Qubits 0 & 1
circuit.x(0)
circuit.x(1)
# Map the quantum measurement to the classical bits
circuit.measure([0, 1] , [0, 1])
# Execute the circuit on the qasm simulator
lowercase :Any = qiskit.execute(a_ , a_ , shots=1000)
# Return the histogram data of the results of the experiment.
return job.result().get_counts(a_)
if __name__ == "__main__":
UpperCAmelCase = single_qubit_measure(2, 2)
print(F"""Total count for various states are: {counts}""")
| 677 |
"""simple docstring"""
import uuid
from typing import Any, Dict, List, Optional, Union
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline
if is_tf_available():
import tensorflow as tf
if is_torch_available():
import torch
UpperCAmelCase = logging.get_logger(__name__)
class __magic_name__ :
def __init__( self : Tuple , snake_case__ : str = None , snake_case__ : uuid.UUID = None , snake_case__ : Optional[int]=None , snake_case__ : Tuple=None ):
'''simple docstring'''
if not conversation_id:
lowercase :List[Any] = uuid.uuida()
if past_user_inputs is None:
lowercase :Union[str, Any] = []
if generated_responses is None:
lowercase :List[str] = []
lowercase :uuid.UUID = conversation_id
lowercase :List[str] = past_user_inputs
lowercase :List[str] = generated_responses
lowercase :Optional[str] = text
def __eq__( self : Optional[Any] , snake_case__ : str ):
'''simple docstring'''
if not isinstance(snake_case__ , snake_case__ ):
return False
if self.uuid == other.uuid:
return True
return (
self.new_user_input == other.new_user_input
and self.past_user_inputs == other.past_user_inputs
and self.generated_responses == other.generated_responses
)
def __snake_case ( self : Optional[int] , snake_case__ : str , snake_case__ : bool = False ):
'''simple docstring'''
if self.new_user_input:
if overwrite:
logger.warning(
f"""User input added while unprocessed input was existing: \"{self.new_user_input}\" was overwritten """
f"""with: \"{text}\".""" )
lowercase :List[str] = text
else:
logger.warning(
f"""User input added while unprocessed input was existing: \"{self.new_user_input}\" new input """
f"""ignored: \"{text}\". Set `overwrite` to True to overwrite unprocessed user input""" )
else:
lowercase :Optional[int] = text
def __snake_case ( self : Any ):
'''simple docstring'''
if self.new_user_input:
self.past_user_inputs.append(self.new_user_input )
lowercase :Tuple = None
def __snake_case ( self : Tuple , snake_case__ : str ):
'''simple docstring'''
self.generated_responses.append(snake_case__ )
def __snake_case ( self : Tuple ):
'''simple docstring'''
for user_input, generated_response in zip(self.past_user_inputs , self.generated_responses ):
yield True, user_input
yield False, generated_response
if self.new_user_input:
yield True, self.new_user_input
def __repr__( self : Dict ):
'''simple docstring'''
lowercase :int = f"""Conversation id: {self.uuid} \n"""
for is_user, text in self.iter_texts():
lowercase :Dict = '''user''' if is_user else '''bot'''
output += f"""{name} >> {text} \n"""
return output
@add_end_docstrings(
__UpperCAmelCase , R"\n min_length_for_response (`int`, *optional*, defaults to 32):\n The minimum length (in number of tokens) for a response.\n minimum_tokens (`int`, *optional*, defaults to 10):\n The minimum length of tokens to leave for a response.\n " , )
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Optional[Any] , *snake_case__ : Optional[Any] , **snake_case__ : List[Any] ):
'''simple docstring'''
super().__init__(*snake_case__ , **snake_case__ )
if self.tokenizer.pad_token_id is None:
lowercase :Any = self.tokenizer.eos_token
def __snake_case ( self : List[Any] , snake_case__ : Optional[int]=None , snake_case__ : Union[str, Any]=None , snake_case__ : List[str]=None , **snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase :str = {}
lowercase :List[str] = {}
lowercase :Tuple = {}
if min_length_for_response is not None:
lowercase :Dict = min_length_for_response
if minimum_tokens is not None:
lowercase :Union[str, Any] = minimum_tokens
if "max_length" in generate_kwargs:
lowercase :List[Any] = generate_kwargs['''max_length''']
# self.max_length = generate_kwargs.get("max_length", self.model.config.max_length)
if clean_up_tokenization_spaces is not None:
lowercase :Dict = clean_up_tokenization_spaces
if generate_kwargs:
forward_params.update(snake_case__ )
return preprocess_params, forward_params, postprocess_params
def __call__( self : List[Any] , snake_case__ : Union[Conversation, List[Conversation]] , snake_case__ : int=0 , **snake_case__ : int ):
'''simple docstring'''
lowercase :int = super().__call__(snake_case__ , num_workers=snake_case__ , **snake_case__ )
if isinstance(snake_case__ , snake_case__ ) and len(snake_case__ ) == 1:
return outputs[0]
return outputs
def __snake_case ( self : List[Any] , snake_case__ : Conversation , snake_case__ : Any=3_2 ):
'''simple docstring'''
if not isinstance(snake_case__ , snake_case__ ):
raise ValueError('''ConversationalPipeline, expects Conversation as inputs''' )
if conversation.new_user_input is None:
raise ValueError(
f"""Conversation with UUID {type(conversation.uuid )} does not contain new user input to process. """
'''Add user inputs with the conversation\'s `add_user_input` method''' )
if hasattr(self.tokenizer , '''_build_conversation_input_ids''' ):
lowercase :List[str] = self.tokenizer._build_conversation_input_ids(snake_case__ )
else:
# If the tokenizer cannot handle conversations, we default to only the old version
lowercase :List[str] = self._legacy_parse_and_tokenize(snake_case__ )
if self.framework == "pt":
lowercase :int = torch.LongTensor([input_ids] )
elif self.framework == "tf":
lowercase :Any = tf.constant([input_ids] )
return {"input_ids": input_ids, "conversation": conversation}
def __snake_case ( self : int , snake_case__ : Union[str, Any] , snake_case__ : Any=1_0 , **snake_case__ : int ):
'''simple docstring'''
lowercase :Dict = generate_kwargs.get('''max_length''' , self.model.config.max_length )
lowercase :Optional[Any] = model_inputs['''input_ids'''].shape[1]
if max_length - minimum_tokens < n:
logger.warning(f"""Conversation input is to long ({n}), trimming it to ({max_length} - {minimum_tokens})""" )
lowercase :int = max_length - minimum_tokens
lowercase :int = model_inputs['''input_ids'''][:, -trim:]
if "attention_mask" in model_inputs:
lowercase :int = model_inputs['''attention_mask'''][:, -trim:]
lowercase :int = model_inputs.pop('''conversation''' )
lowercase :Union[str, Any] = max_length
lowercase :Dict = self.model.generate(**snake_case__ , **snake_case__ )
if self.model.config.is_encoder_decoder:
lowercase :List[Any] = 1
else:
lowercase :Optional[Any] = n
return {"output_ids": output_ids[:, start_position:], "conversation": conversation}
def __snake_case ( self : Optional[int] , snake_case__ : List[Any] , snake_case__ : Optional[Any]=True ):
'''simple docstring'''
lowercase :Dict = model_outputs['''output_ids''']
lowercase :Dict = self.tokenizer.decode(
output_ids[0] , skip_special_tokens=snake_case__ , clean_up_tokenization_spaces=snake_case__ , )
lowercase :Optional[int] = model_outputs['''conversation''']
conversation.mark_processed()
conversation.append_response(snake_case__ )
return conversation
def __snake_case ( self : List[Any] , snake_case__ : Conversation ):
'''simple docstring'''
lowercase :str = self.tokenizer.eos_token_id
lowercase :List[Any] = []
for is_user, text in conversation.iter_texts():
if eos_token_id is not None:
input_ids.extend(self.tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ ) + [eos_token_id] )
else:
input_ids.extend(self.tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ ) )
if len(snake_case__ ) > self.tokenizer.model_max_length:
lowercase :List[Any] = input_ids[-self.tokenizer.model_max_length :]
return input_ids
| 677 | 1 |
"""simple docstring"""
from collections import OrderedDict
from typing import Mapping
from packaging import version
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''google/vit-base-patch16-224''': '''https://huggingface.co/vit-base-patch16-224/resolve/main/config.json''',
# See all ViT models at https://huggingface.co/models?filter=vit
}
class __magic_name__ ( __UpperCAmelCase ):
__A : List[Any] = "vit"
def __init__( self : List[str] , snake_case__ : List[Any]=7_6_8 , snake_case__ : List[Any]=1_2 , snake_case__ : Union[str, Any]=1_2 , snake_case__ : Union[str, Any]=3_0_7_2 , snake_case__ : Any="gelu" , snake_case__ : Optional[int]=0.0 , snake_case__ : int=0.0 , snake_case__ : str=0.02 , snake_case__ : Any=1e-1_2 , snake_case__ : str=2_2_4 , snake_case__ : List[Any]=1_6 , snake_case__ : List[Any]=3 , snake_case__ : Tuple=True , snake_case__ : List[str]=1_6 , **snake_case__ : str , ):
'''simple docstring'''
super().__init__(**snake_case__ )
lowercase :Optional[Any] = hidden_size
lowercase :Any = num_hidden_layers
lowercase :List[Any] = num_attention_heads
lowercase :Union[str, Any] = intermediate_size
lowercase :Any = hidden_act
lowercase :List[Any] = hidden_dropout_prob
lowercase :Union[str, Any] = attention_probs_dropout_prob
lowercase :Union[str, Any] = initializer_range
lowercase :Optional[int] = layer_norm_eps
lowercase :List[str] = image_size
lowercase :Dict = patch_size
lowercase :List[str] = num_channels
lowercase :str = qkv_bias
lowercase :Any = encoder_stride
class __magic_name__ ( __UpperCAmelCase ):
__A : int = version.parse("1.11" )
@property
def __snake_case ( self : List[str] ):
'''simple docstring'''
return OrderedDict(
[
('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
] )
@property
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
return 1e-4
| 677 |
"""simple docstring"""
def lowerCamelCase (a_ :int = 100) -> int:
lowercase :Union[str, Any] = set()
lowercase :List[Any] = 0
lowercase :Dict = n + 1 # maximum limit
for a in range(2 , a_):
for b in range(2 , a_):
lowercase :Tuple = a**b # calculates the current power
collect_powers.add(a_) # adds the result to the set
return len(a_)
if __name__ == "__main__":
print('''Number of terms ''', solution(int(str(input()).strip())))
| 677 | 1 |
"""simple docstring"""
import time
from contextlib import contextmanager
from pathlib import Path
import pytest
import requests
from huggingface_hub.hf_api import HfApi, HfFolder
UpperCAmelCase = '''__DUMMY_TRANSFORMERS_USER__'''
UpperCAmelCase = '''Dummy User'''
UpperCAmelCase = '''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'''
UpperCAmelCase = '''https://hub-ci.huggingface.co'''
UpperCAmelCase = CI_HUB_ENDPOINT + '''/datasets/{repo_id}/resolve/{revision}/{path}'''
UpperCAmelCase = CI_HUB_ENDPOINT + '''/{repo_id}/resolve/{revision}/{filename}'''
UpperCAmelCase = Path('''~/.huggingface/hub_ci_token''').expanduser()
@pytest.fixture
def lowerCamelCase (a_ :Any) -> List[str]:
monkeypatch.setattr(
'''huggingface_hub.file_download.HUGGINGFACE_CO_URL_TEMPLATE''' , a_)
@pytest.fixture
def lowerCamelCase (a_ :Any) -> Any:
monkeypatch.setattr('''datasets.config.HF_ENDPOINT''' , a_)
monkeypatch.setattr('''datasets.config.HUB_DATASETS_URL''' , a_)
@pytest.fixture
def lowerCamelCase (a_ :Any) -> Tuple:
monkeypatch.setattr('''huggingface_hub.hf_api.HfFolder.path_token''' , a_)
@pytest.fixture
def lowerCamelCase (a_ :List[str] , a_ :Optional[Any]) -> List[str]:
HfFolder.save_token(a_)
yield
HfFolder.delete_token()
@pytest.fixture(scope='''session''')
def lowerCamelCase () -> Any:
return HfApi(endpoint=a_)
@pytest.fixture(scope='''session''')
def lowerCamelCase (a_ :HfApi) -> Tuple:
lowercase :Any = HfFolder.get_token()
HfFolder.save_token(a_)
yield CI_HUB_USER_TOKEN
if previous_token is not None:
HfFolder.save_token(a_)
@pytest.fixture
def lowerCamelCase (a_ :int) -> List[Any]:
def _cleanup_repo(a_ :Any):
hf_api.delete_repo(a_ , token=a_ , repo_type='''dataset''')
return _cleanup_repo
@pytest.fixture
def lowerCamelCase (a_ :Union[str, Any]) -> int:
@contextmanager
def _temporary_repo(a_ :Any):
try:
yield repo_id
finally:
cleanup_repo(a_)
return _temporary_repo
@pytest.fixture(scope='''session''')
def lowerCamelCase (a_ :HfApi , a_ :List[str] , a_ :Optional[int]) -> List[str]:
lowercase :Dict = F"""repo_txt_data-{int(time.time() * 10E3)}"""
lowercase :Optional[Any] = F"""{CI_HUB_USER}/{repo_name}"""
hf_api.create_repo(a_ , token=a_ , repo_type='''dataset''' , private=a_)
hf_api.upload_file(
token=a_ , path_or_fileobj=str(a_) , path_in_repo='''data/text_data.txt''' , repo_id=a_ , repo_type='''dataset''' , )
yield repo_id
try:
hf_api.delete_repo(a_ , token=a_ , repo_type='''dataset''')
except (requests.exceptions.HTTPError, ValueError): # catch http error and token invalid error
pass
@pytest.fixture()
def lowerCamelCase (a_ :Any , a_ :Any , a_ :List[Any]) -> Optional[int]:
return hf_private_dataset_repo_txt_data_
@pytest.fixture(scope='''session''')
def lowerCamelCase (a_ :HfApi , a_ :List[Any] , a_ :Optional[int]) -> str:
lowercase :Union[str, Any] = F"""repo_zipped_txt_data-{int(time.time() * 10E3)}"""
lowercase :Optional[Any] = F"""{CI_HUB_USER}/{repo_name}"""
hf_api.create_repo(a_ , token=a_ , repo_type='''dataset''' , private=a_)
hf_api.upload_file(
token=a_ , path_or_fileobj=str(a_) , path_in_repo='''data.zip''' , repo_id=a_ , repo_type='''dataset''' , )
yield repo_id
try:
hf_api.delete_repo(a_ , token=a_ , repo_type='''dataset''')
except (requests.exceptions.HTTPError, ValueError): # catch http error and token invalid error
pass
@pytest.fixture()
def lowerCamelCase (a_ :Optional[Any] , a_ :Optional[int] , a_ :Optional[int]) -> str:
return hf_private_dataset_repo_zipped_txt_data_
@pytest.fixture(scope='''session''')
def lowerCamelCase (a_ :HfApi , a_ :Any , a_ :Union[str, Any]) -> str:
lowercase :Optional[int] = F"""repo_zipped_img_data-{int(time.time() * 10E3)}"""
lowercase :Any = F"""{CI_HUB_USER}/{repo_name}"""
hf_api.create_repo(a_ , token=a_ , repo_type='''dataset''' , private=a_)
hf_api.upload_file(
token=a_ , path_or_fileobj=str(a_) , path_in_repo='''data.zip''' , repo_id=a_ , repo_type='''dataset''' , )
yield repo_id
try:
hf_api.delete_repo(a_ , token=a_ , repo_type='''dataset''')
except (requests.exceptions.HTTPError, ValueError): # catch http error and token invalid error
pass
@pytest.fixture()
def lowerCamelCase (a_ :List[Any] , a_ :Dict , a_ :Any) -> Optional[Any]:
return hf_private_dataset_repo_zipped_img_data_
| 677 |
"""simple docstring"""
from typing import Callable, Optional, Union
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''microsoft/xprophetnet-large-wiki100-cased''': (
'''https://huggingface.co/microsoft/xprophetnet-large-wiki100-cased/resolve/main/config.json'''
),
}
class __magic_name__ ( __UpperCAmelCase ):
__A : Optional[Any] = "xlm-prophetnet"
__A : List[str] = ["past_key_values"]
__A : int = {
"num_attention_heads": "num_encoder_attention_heads",
}
def __init__( self : Any , snake_case__ : Optional[float] = 0.1 , snake_case__ : Optional[Union[str, Callable]] = "gelu" , snake_case__ : Optional[int] = 3_0_5_2_2 , snake_case__ : Optional[int] = 1_0_2_4 , snake_case__ : Optional[int] = 4_0_9_6 , snake_case__ : Optional[int] = 1_2 , snake_case__ : Optional[int] = 1_6 , snake_case__ : Optional[int] = 4_0_9_6 , snake_case__ : Optional[int] = 1_2 , snake_case__ : Optional[int] = 1_6 , snake_case__ : Optional[float] = 0.1 , snake_case__ : Optional[float] = 0.1 , snake_case__ : Optional[int] = 5_1_2 , snake_case__ : Optional[float] = 0.02 , snake_case__ : Optional[bool] = True , snake_case__ : Optional[bool] = True , snake_case__ : Optional[int] = 0 , snake_case__ : Optional[int] = 2 , snake_case__ : Optional[int] = 3_2 , snake_case__ : Optional[int] = 1_2_8 , snake_case__ : Optional[bool] = False , snake_case__ : Optional[float] = 0.0 , snake_case__ : Optional[bool] = True , snake_case__ : Optional[int] = 0 , snake_case__ : Optional[int] = 1 , snake_case__ : Optional[int] = 2 , **snake_case__ : List[str] , ):
'''simple docstring'''
lowercase :Tuple = vocab_size
lowercase :Optional[int] = hidden_size
lowercase :Optional[int] = encoder_ffn_dim
lowercase :Optional[int] = num_encoder_layers
lowercase :Dict = num_encoder_attention_heads
lowercase :List[str] = decoder_ffn_dim
lowercase :Dict = num_decoder_layers
lowercase :List[Any] = num_decoder_attention_heads
lowercase :Optional[int] = max_position_embeddings
lowercase :Tuple = init_std # Normal(0, this parameter)
lowercase :int = activation_function
# parameters for xlmprophetnet
lowercase :Dict = ngram
lowercase :Optional[Any] = num_buckets
lowercase :Dict = relative_max_distance
lowercase :List[Any] = disable_ngram_loss
lowercase :Optional[Any] = eps
# 3 Types of Dropout
lowercase :Any = attention_dropout
lowercase :List[str] = activation_dropout
lowercase :List[str] = dropout
lowercase :List[str] = use_cache
super().__init__(
pad_token_id=snake_case__ , bos_token_id=snake_case__ , eos_token_id=snake_case__ , is_encoder_decoder=snake_case__ , add_cross_attention=snake_case__ , decoder_start_token_id=snake_case__ , **snake_case__ , )
@property
def __snake_case ( self : Any ):
'''simple docstring'''
return self.num_encoder_layers + self.num_decoder_layers
@num_hidden_layers.setter
def __snake_case ( self : Optional[Any] , snake_case__ : Optional[Any] ):
'''simple docstring'''
raise NotImplementedError(
'''This model does not support the setting of `num_hidden_layers`. Please set `num_encoder_layers` and'''
''' `num_decoder_layers`.''' )
| 677 | 1 |
"""simple docstring"""
import json
import os
import tempfile
import unittest
import numpy as np
from datasets import load_dataset
from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin
if is_torch_available():
import torch
if is_vision_available():
from PIL import Image
from transformers import ImageGPTImageProcessor
class __magic_name__ ( unittest.TestCase ):
def __init__( self : List[Any] , snake_case__ : Union[str, Any] , snake_case__ : Any=7 , snake_case__ : Tuple=3 , snake_case__ : List[Any]=1_8 , snake_case__ : List[str]=3_0 , snake_case__ : Optional[int]=4_0_0 , snake_case__ : Union[str, Any]=True , snake_case__ : List[Any]=None , snake_case__ : str=True , ):
'''simple docstring'''
lowercase :List[Any] = size if size is not None else {'''height''': 1_8, '''width''': 1_8}
lowercase :Any = parent
lowercase :Any = batch_size
lowercase :str = num_channels
lowercase :List[Any] = image_size
lowercase :Optional[Any] = min_resolution
lowercase :Any = max_resolution
lowercase :Optional[int] = do_resize
lowercase :int = size
lowercase :Tuple = do_normalize
def __snake_case ( self : int ):
'''simple docstring'''
return {
# here we create 2 clusters for the sake of simplicity
"clusters": np.asarray(
[
[0.88_66_44_36_34_03_32_03, 0.66_18_82_93_69_54_49_83, 0.38_91_74_64_01_78_68_04],
[-0.60_42_55_91_46_88_11_04, -0.0_22_95_00_88_60_52_84_69, 0.54_23_79_73_69_00_32_96],
] ),
"do_resize": self.do_resize,
"size": self.size,
"do_normalize": self.do_normalize,
}
@require_torch
@require_vision
class __magic_name__ ( __UpperCAmelCase , unittest.TestCase ):
__A : Optional[int] = ImageGPTImageProcessor if is_vision_available() else None
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase :Union[str, Any] = ImageGPTImageProcessingTester(self )
@property
def __snake_case ( self : List[Any] ):
'''simple docstring'''
return self.image_processor_tester.prepare_image_processor_dict()
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :Dict = self.image_processing_class(**self.image_processor_dict )
self.assertTrue(hasattr(snake_case__ , '''clusters''' ) )
self.assertTrue(hasattr(snake_case__ , '''do_resize''' ) )
self.assertTrue(hasattr(snake_case__ , '''size''' ) )
self.assertTrue(hasattr(snake_case__ , '''do_normalize''' ) )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :List[Any] = self.image_processing_class.from_dict(self.image_processor_dict )
self.assertEqual(image_processor.size , {'''height''': 1_8, '''width''': 1_8} )
lowercase :str = self.image_processing_class.from_dict(self.image_processor_dict , size=4_2 )
self.assertEqual(image_processor.size , {'''height''': 4_2, '''width''': 4_2} )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :Optional[Any] = self.image_processing_class(**self.image_processor_dict )
lowercase :Union[str, Any] = json.loads(image_processor.to_json_string() )
for key, value in self.image_processor_dict.items():
if key == "clusters":
self.assertTrue(np.array_equal(snake_case__ , obj[key] ) )
else:
self.assertEqual(obj[key] , snake_case__ )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :Optional[int] = self.image_processing_class(**self.image_processor_dict )
with tempfile.TemporaryDirectory() as tmpdirname:
lowercase :str = os.path.join(snake_case__ , '''image_processor.json''' )
image_processor_first.to_json_file(snake_case__ )
lowercase :Tuple = self.image_processing_class.from_json_file(snake_case__ ).to_dict()
lowercase :Any = image_processor_first.to_dict()
for key, value in image_processor_first.items():
if key == "clusters":
self.assertTrue(np.array_equal(snake_case__ , image_processor_second[key] ) )
else:
self.assertEqual(image_processor_first[key] , snake_case__ )
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :List[Any] = self.image_processing_class(**self.image_processor_dict )
with tempfile.TemporaryDirectory() as tmpdirname:
image_processor_first.save_pretrained(snake_case__ )
lowercase :Tuple = self.image_processing_class.from_pretrained(snake_case__ ).to_dict()
lowercase :Optional[Any] = image_processor_first.to_dict()
for key, value in image_processor_first.items():
if key == "clusters":
self.assertTrue(np.array_equal(snake_case__ , image_processor_second[key] ) )
else:
self.assertEqual(image_processor_first[key] , snake_case__ )
@unittest.skip('''ImageGPT requires clusters at initialization''' )
def __snake_case ( self : Dict ):
'''simple docstring'''
pass
def lowerCamelCase () -> int:
lowercase :Any = load_dataset('''hf-internal-testing/fixtures_image_utils''' , split='''test''')
lowercase :str = Image.open(dataset[4]['''file'''])
lowercase :int = Image.open(dataset[5]['''file'''])
lowercase :str = [imagea, imagea]
return images
@require_vision
@require_torch
class __magic_name__ ( unittest.TestCase ):
@slow
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :Tuple = ImageGPTImageProcessor.from_pretrained('''openai/imagegpt-small''' )
lowercase :Any = prepare_images()
# test non-batched
lowercase :List[str] = image_processing(images[0] , return_tensors='''pt''' )
self.assertIsInstance(encoding.input_ids , torch.LongTensor )
self.assertEqual(encoding.input_ids.shape , (1, 1_0_2_4) )
lowercase :List[str] = [3_0_6, 1_9_1, 1_9_1]
self.assertEqual(encoding.input_ids[0, :3].tolist() , snake_case__ )
# test batched
lowercase :List[Any] = image_processing(snake_case__ , return_tensors='''pt''' )
self.assertIsInstance(encoding.input_ids , torch.LongTensor )
self.assertEqual(encoding.input_ids.shape , (2, 1_0_2_4) )
lowercase :Optional[Any] = [3_0_3, 1_3, 1_3]
self.assertEqual(encoding.input_ids[1, -3:].tolist() , snake_case__ )
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tensorflow_text_available,
is_tf_available,
is_tokenizers_available,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_bert''': ['''BERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BertConfig''', '''BertOnnxConfig'''],
'''tokenization_bert''': ['''BasicTokenizer''', '''BertTokenizer''', '''WordpieceTokenizer'''],
}
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''BertTokenizerFast''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''BertForMaskedLM''',
'''BertForMultipleChoice''',
'''BertForNextSentencePrediction''',
'''BertForPreTraining''',
'''BertForQuestionAnswering''',
'''BertForSequenceClassification''',
'''BertForTokenClassification''',
'''BertLayer''',
'''BertLMHeadModel''',
'''BertModel''',
'''BertPreTrainedModel''',
'''load_tf_weights_in_bert''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''TFBertEmbeddings''',
'''TFBertForMaskedLM''',
'''TFBertForMultipleChoice''',
'''TFBertForNextSentencePrediction''',
'''TFBertForPreTraining''',
'''TFBertForQuestionAnswering''',
'''TFBertForSequenceClassification''',
'''TFBertForTokenClassification''',
'''TFBertLMHeadModel''',
'''TFBertMainLayer''',
'''TFBertModel''',
'''TFBertPreTrainedModel''',
]
try:
if not is_tensorflow_text_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''TFBertTokenizer''']
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxBertForCausalLM''',
'''FlaxBertForMaskedLM''',
'''FlaxBertForMultipleChoice''',
'''FlaxBertForNextSentencePrediction''',
'''FlaxBertForPreTraining''',
'''FlaxBertForQuestionAnswering''',
'''FlaxBertForSequenceClassification''',
'''FlaxBertForTokenClassification''',
'''FlaxBertModel''',
'''FlaxBertPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_bert import BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BertConfig, BertOnnxConfig
from .tokenization_bert import BasicTokenizer, BertTokenizer, WordpieceTokenizer
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_bert_fast import BertTokenizerFast
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_bert import (
BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
BertForMaskedLM,
BertForMultipleChoice,
BertForNextSentencePrediction,
BertForPreTraining,
BertForQuestionAnswering,
BertForSequenceClassification,
BertForTokenClassification,
BertLayer,
BertLMHeadModel,
BertModel,
BertPreTrainedModel,
load_tf_weights_in_bert,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_bert import (
TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
TFBertEmbeddings,
TFBertForMaskedLM,
TFBertForMultipleChoice,
TFBertForNextSentencePrediction,
TFBertForPreTraining,
TFBertForQuestionAnswering,
TFBertForSequenceClassification,
TFBertForTokenClassification,
TFBertLMHeadModel,
TFBertMainLayer,
TFBertModel,
TFBertPreTrainedModel,
)
try:
if not is_tensorflow_text_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_bert_tf import TFBertTokenizer
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_bert import (
FlaxBertForCausalLM,
FlaxBertForMaskedLM,
FlaxBertForMultipleChoice,
FlaxBertForNextSentencePrediction,
FlaxBertForPreTraining,
FlaxBertForQuestionAnswering,
FlaxBertForSequenceClassification,
FlaxBertForTokenClassification,
FlaxBertModel,
FlaxBertPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
import logging
import torch
from torch import nn
from torch.nn import CrossEntropyLoss, MSELoss
from transformers.file_utils import add_start_docstrings, add_start_docstrings_to_model_forward
from transformers.models.bert.modeling_bert import (
BERT_INPUTS_DOCSTRING,
BERT_START_DOCSTRING,
BertEncoder,
BertModel,
BertPreTrainedModel,
)
UpperCAmelCase = logging.getLogger(__name__)
class __magic_name__ ( __UpperCAmelCase ):
def __snake_case ( self : Optional[int] , snake_case__ : Tuple , snake_case__ : List[str] , snake_case__ : Dict=None , snake_case__ : List[Any]=None ):
'''simple docstring'''
lowercase :List[Any] = self.layer[current_layer](snake_case__ , snake_case__ , head_mask[current_layer] )
lowercase :Dict = layer_outputs[0]
return hidden_states
@add_start_docstrings(
"The bare Bert Model transformer with PABEE outputting raw hidden-states without any specific head on top." , __UpperCAmelCase , )
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Optional[int] , snake_case__ : str ):
'''simple docstring'''
super().__init__(snake_case__ )
lowercase :Union[str, Any] = BertEncoderWithPabee(snake_case__ )
self.init_weights()
lowercase :List[str] = 0
lowercase :Optional[Any] = 0
lowercase :str = 0
lowercase :Optional[int] = 0
def __snake_case ( self : Any , snake_case__ : str ):
'''simple docstring'''
lowercase :Optional[int] = threshold
def __snake_case ( self : List[str] , snake_case__ : Any ):
'''simple docstring'''
lowercase :List[str] = patience
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :List[Any] = 0
lowercase :Tuple = 0
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :Any = self.inference_layers_num / self.inference_instances_num
lowercase :int = (
f"""*** Patience = {self.patience} Avg. Inference Layers = {avg_inf_layers:.2f} Speed Up ="""
f""" {1 - avg_inf_layers / self.config.num_hidden_layers:.2f} ***"""
)
print(snake_case__ )
@add_start_docstrings_to_model_forward(snake_case__ )
def __snake_case ( self : Union[str, Any] , snake_case__ : Tuple=None , snake_case__ : int=None , snake_case__ : Optional[Any]=None , snake_case__ : Tuple=None , snake_case__ : Tuple=None , snake_case__ : Dict=None , snake_case__ : Optional[Any]=None , snake_case__ : List[str]=None , snake_case__ : Union[str, Any]=None , snake_case__ : List[str]=None , snake_case__ : List[str]=False , ):
'''simple docstring'''
if input_ids is not None and inputs_embeds is not None:
raise ValueError('''You cannot specify both input_ids and inputs_embeds at the same time''' )
elif input_ids is not None:
lowercase :Dict = input_ids.size()
elif inputs_embeds is not None:
lowercase :List[str] = inputs_embeds.size()[:-1]
else:
raise ValueError('''You have to specify either input_ids or inputs_embeds''' )
lowercase :Optional[int] = input_ids.device if input_ids is not None else inputs_embeds.device
if attention_mask is None:
lowercase :Optional[Any] = torch.ones(snake_case__ , device=snake_case__ )
if token_type_ids is None:
lowercase :Dict = torch.zeros(snake_case__ , dtype=torch.long , device=snake_case__ )
# We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
# ourselves in which case we just need to make it broadcastable to all heads.
lowercase :torch.Tensor = self.get_extended_attention_mask(snake_case__ , snake_case__ , snake_case__ )
# If a 2D ou 3D attention mask is provided for the cross-attention
# we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
if self.config.is_decoder and encoder_hidden_states is not None:
lowercase , lowercase , lowercase :Union[str, Any] = encoder_hidden_states.size()
lowercase :int = (encoder_batch_size, encoder_sequence_length)
if encoder_attention_mask is None:
lowercase :List[str] = torch.ones(snake_case__ , device=snake_case__ )
lowercase :str = self.invert_attention_mask(snake_case__ )
else:
lowercase :int = None
# Prepare head mask if needed
# 1.0 in head_mask indicate we keep the head
# attention_probs has shape bsz x n_heads x N x N
# input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
# and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
lowercase :Union[str, Any] = self.get_head_mask(snake_case__ , self.config.num_hidden_layers )
lowercase :int = self.embeddings(
input_ids=snake_case__ , position_ids=snake_case__ , token_type_ids=snake_case__ , inputs_embeds=snake_case__ )
lowercase :str = embedding_output
if self.training:
lowercase :Union[str, Any] = []
for i in range(self.config.num_hidden_layers ):
lowercase :Dict = self.encoder.adaptive_forward(
snake_case__ , current_layer=snake_case__ , attention_mask=snake_case__ , head_mask=snake_case__ )
lowercase :Optional[int] = self.pooler(snake_case__ )
lowercase :Optional[Any] = output_layers[i](output_dropout(snake_case__ ) )
res.append(snake_case__ )
elif self.patience == 0: # Use all layers for inference
lowercase :List[str] = self.encoder(
snake_case__ , attention_mask=snake_case__ , head_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , )
lowercase :Dict = self.pooler(encoder_outputs[0] )
lowercase :Any = [output_layers[self.config.num_hidden_layers - 1](snake_case__ )]
else:
lowercase :Optional[Any] = 0
lowercase :List[str] = None
lowercase :List[Any] = 0
for i in range(self.config.num_hidden_layers ):
calculated_layer_num += 1
lowercase :Union[str, Any] = self.encoder.adaptive_forward(
snake_case__ , current_layer=snake_case__ , attention_mask=snake_case__ , head_mask=snake_case__ )
lowercase :List[str] = self.pooler(snake_case__ )
lowercase :Optional[Any] = output_layers[i](snake_case__ )
if regression:
lowercase :Union[str, Any] = logits.detach()
if patient_result is not None:
lowercase :List[str] = patient_result.detach()
if (patient_result is not None) and torch.abs(patient_result - labels ) < self.regression_threshold:
patient_counter += 1
else:
lowercase :str = 0
else:
lowercase :Optional[Any] = logits.detach().argmax(dim=1 )
if patient_result is not None:
lowercase :Tuple = patient_result.detach().argmax(dim=1 )
if (patient_result is not None) and torch.all(labels.eq(snake_case__ ) ):
patient_counter += 1
else:
lowercase :Optional[Any] = 0
lowercase :Any = logits
if patient_counter == self.patience:
break
lowercase :List[Any] = [patient_result]
self.inference_layers_num += calculated_layer_num
self.inference_instances_num += 1
return res
@add_start_docstrings(
"Bert Model transformer with PABEE and a sequence classification/regression head on top (a linear layer on top of\n the pooled output) e.g. for GLUE tasks. " , __UpperCAmelCase , )
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Optional[int] , snake_case__ : Dict ):
'''simple docstring'''
super().__init__(snake_case__ )
lowercase :str = config.num_labels
lowercase :str = BertModelWithPabee(snake_case__ )
lowercase :Dict = nn.Dropout(config.hidden_dropout_prob )
lowercase :Tuple = nn.ModuleList(
[nn.Linear(config.hidden_size , self.config.num_labels ) for _ in range(config.num_hidden_layers )] )
self.init_weights()
@add_start_docstrings_to_model_forward(snake_case__ )
def __snake_case ( self : str , snake_case__ : Optional[int]=None , snake_case__ : List[Any]=None , snake_case__ : Any=None , snake_case__ : List[str]=None , snake_case__ : int=None , snake_case__ : List[str]=None , snake_case__ : Any=None , ):
'''simple docstring'''
lowercase :List[Any] = self.bert(
input_ids=snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , position_ids=snake_case__ , head_mask=snake_case__ , inputs_embeds=snake_case__ , output_dropout=self.dropout , output_layers=self.classifiers , regression=self.num_labels == 1 , )
lowercase :Optional[Any] = (logits[-1],)
if labels is not None:
lowercase :Optional[int] = None
lowercase :Tuple = 0
for ix, logits_item in enumerate(snake_case__ ):
if self.num_labels == 1:
# We are doing regression
lowercase :List[str] = MSELoss()
lowercase :Optional[int] = loss_fct(logits_item.view(-1 ) , labels.view(-1 ) )
else:
lowercase :Dict = CrossEntropyLoss()
lowercase :Dict = loss_fct(logits_item.view(-1 , self.num_labels ) , labels.view(-1 ) )
if total_loss is None:
lowercase :Tuple = loss
else:
total_loss += loss * (ix + 1)
total_weights += ix + 1
lowercase :Dict = (total_loss / total_weights,) + outputs
return outputs
| 677 |
"""simple docstring"""
from typing import List, Optional, Union
from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
class __magic_name__ ( __UpperCAmelCase ):
__A : Tuple = ["image_processor", "tokenizer"]
__A : Dict = "BlipImageProcessor"
__A : Dict = "AutoTokenizer"
def __init__( self : Any , snake_case__ : Union[str, Any] , snake_case__ : str ):
'''simple docstring'''
lowercase :Dict = False
super().__init__(snake_case__ , snake_case__ )
lowercase :Union[str, Any] = self.image_processor
def __call__( self : Optional[int] , snake_case__ : ImageInput = None , snake_case__ : Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None , snake_case__ : bool = True , snake_case__ : Union[bool, str, PaddingStrategy] = False , snake_case__ : Union[bool, str, TruncationStrategy] = None , snake_case__ : Optional[int] = None , snake_case__ : int = 0 , snake_case__ : Optional[int] = None , snake_case__ : Optional[bool] = None , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = True , snake_case__ : Optional[Union[str, TensorType]] = None , **snake_case__ : Optional[Any] , ):
'''simple docstring'''
if images is None and text is None:
raise ValueError('''You have to specify either images or text.''' )
# Get only text
if images is None:
lowercase :List[Any] = self.tokenizer
lowercase :str = self.tokenizer(
text=snake_case__ , add_special_tokens=snake_case__ , padding=snake_case__ , truncation=snake_case__ , max_length=snake_case__ , stride=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , return_overflowing_tokens=snake_case__ , return_special_tokens_mask=snake_case__ , return_offsets_mapping=snake_case__ , return_token_type_ids=snake_case__ , return_length=snake_case__ , verbose=snake_case__ , return_tensors=snake_case__ , **snake_case__ , )
return text_encoding
# add pixel_values
lowercase :Union[str, Any] = self.image_processor(snake_case__ , return_tensors=snake_case__ )
if text is not None:
lowercase :int = self.tokenizer(
text=snake_case__ , add_special_tokens=snake_case__ , padding=snake_case__ , truncation=snake_case__ , max_length=snake_case__ , stride=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , return_overflowing_tokens=snake_case__ , return_special_tokens_mask=snake_case__ , return_offsets_mapping=snake_case__ , return_token_type_ids=snake_case__ , return_length=snake_case__ , verbose=snake_case__ , return_tensors=snake_case__ , **snake_case__ , )
else:
lowercase :Optional[int] = None
if text_encoding is not None:
encoding_image_processor.update(snake_case__ )
return encoding_image_processor
def __snake_case ( self : Tuple , *snake_case__ : List[Any] , **snake_case__ : Tuple ):
'''simple docstring'''
return self.tokenizer.batch_decode(*snake_case__ , **snake_case__ )
def __snake_case ( self : List[str] , *snake_case__ : Dict , **snake_case__ : List[Any] ):
'''simple docstring'''
return self.tokenizer.decode(*snake_case__ , **snake_case__ )
@property
# Copied from transformers.models.blip.processing_blip.BlipProcessor.model_input_names
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase :List[Any] = self.tokenizer.model_input_names
lowercase :List[Any] = self.image_processor.model_input_names
return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) )
| 677 | 1 |
"""simple docstring"""
# NOTE: This file is deprecated and will be removed in a future version.
# It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works
from ...utils import deprecate
from ..controlnet.multicontrolnet import MultiControlNetModel # noqa: F401
from ..controlnet.pipeline_controlnet import StableDiffusionControlNetPipeline # noqa: F401
deprecate(
'''stable diffusion controlnet''',
'''0.22.0''',
'''Importing `StableDiffusionControlNetPipeline` or `MultiControlNetModel` from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet is deprecated. Please import `from diffusers import StableDiffusionControlNetPipeline` instead.''',
standard_warn=False,
stacklevel=3,
)
| 677 |
"""simple docstring"""
import subprocess
import sys
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch
class __magic_name__ ( __UpperCAmelCase ):
@require_torch
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Optional[Any] = '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
'''
lowercase :Any = '''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
'''
lowercase :Tuple = '''
import socket
def offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")
socket.socket = offline_socket
'''
# Force fetching the files so that we can use the cache
lowercase :str = '''hf-internal-testing/tiny-random-bert'''
BertConfig.from_pretrained(snake_case__ )
BertModel.from_pretrained(snake_case__ )
BertTokenizer.from_pretrained(snake_case__ )
pipeline(task='''fill-mask''' , model=snake_case__ )
# baseline - just load from_pretrained with normal network
lowercase :Union[str, Any] = [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]
# should succeed
lowercase :Any = self.get_env()
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :List[Any] = '''1'''
lowercase :List[str] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :List[str] = '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
'''
lowercase :Dict = '''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
'''
lowercase :List[Any] = '''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")
socket.socket = offline_socket
'''
# Force fetching the files so that we can use the cache
lowercase :str = '''hf-internal-testing/tiny-random-bert'''
BertConfig.from_pretrained(snake_case__ )
BertModel.from_pretrained(snake_case__ )
BertTokenizer.from_pretrained(snake_case__ )
pipeline(task='''fill-mask''' , model=snake_case__ )
# baseline - just load from_pretrained with normal network
lowercase :List[str] = [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]
# should succeed
lowercase :str = self.get_env()
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : int ):
'''simple docstring'''
lowercase :str = '''
from transformers import BertConfig, BertModel, BertTokenizer
'''
lowercase :Union[str, Any] = '''
mname = "hf-internal-testing/tiny-random-bert-sharded"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
print("success")
'''
lowercase :Optional[int] = '''
import socket
def offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")
socket.socket = offline_socket
'''
# baseline - just load from_pretrained with normal network
lowercase :Optional[Any] = [sys.executable, '''-c''', '''\n'''.join([load, run] )]
# should succeed
lowercase :Union[str, Any] = self.get_env()
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
# next emulate no network
lowercase :Tuple = [sys.executable, '''-c''', '''\n'''.join([load, mock, run] )]
# Doesn't fail anymore since the model is in the cache due to other tests, so commenting this.
# env["TRANSFORMERS_OFFLINE"] = "0"
# result = subprocess.run(cmd, env=env, check=False, capture_output=True)
# self.assertEqual(result.returncode, 1, result.stderr)
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :Any = '''1'''
lowercase :Optional[Any] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :Dict = '''
from transformers import pipeline
'''
lowercase :Optional[Any] = '''
mname = "hf-internal-testing/tiny-random-bert"
pipe = pipeline(model=mname)
'''
lowercase :Dict = '''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")
socket.socket = offline_socket
'''
lowercase :Tuple = self.get_env()
lowercase :Optional[Any] = '''1'''
lowercase :Optional[int] = [sys.executable, '''-c''', '''\n'''.join([load, mock, run] )]
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 1 , result.stderr )
self.assertIn(
'''You cannot infer task automatically within `pipeline` when using offline mode''' , result.stderr.decode().replace('''\n''' , '''''' ) , )
@require_torch
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = '''
from transformers import AutoModel
'''
lowercase :Union[str, Any] = '''
mname = "hf-internal-testing/test_dynamic_model"
AutoModel.from_pretrained(mname, trust_remote_code=True)
print("success")
'''
# baseline - just load from_pretrained with normal network
lowercase :Union[str, Any] = [sys.executable, '''-c''', '''\n'''.join([load, run] )]
# should succeed
lowercase :List[str] = self.get_env()
lowercase :Optional[int] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :List[Any] = '''1'''
lowercase :Tuple = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
| 677 | 1 |
"""simple docstring"""
# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer
from .base import PipelineTool
class __magic_name__ ( __UpperCAmelCase ):
__A : str = "philschmid/bart-large-cnn-samsum"
__A : Dict = (
"This is a tool that summarizes an English text. It takes an input `text` containing the text to summarize, "
"and returns a summary of the text."
)
__A : List[Any] = "summarizer"
__A : List[Any] = AutoTokenizer
__A : Optional[Any] = AutoModelForSeqaSeqLM
__A : List[str] = ["text"]
__A : Optional[Any] = ["text"]
def __snake_case ( self : List[Any] , snake_case__ : Union[str, Any] ):
'''simple docstring'''
return self.pre_processor(snake_case__ , return_tensors='''pt''' , truncation=snake_case__ )
def __snake_case ( self : Any , snake_case__ : Optional[Any] ):
'''simple docstring'''
return self.model.generate(**snake_case__ )[0]
def __snake_case ( self : Union[str, Any] , snake_case__ : str ):
'''simple docstring'''
return self.pre_processor.decode(snake_case__ , skip_special_tokens=snake_case__ , clean_up_tokenization_spaces=snake_case__ )
| 677 |
"""simple docstring"""
import argparse
import json
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from typing import List
import timm
import torch
import torch.nn as nn
from huggingface_hub import hf_hub_download
from torch import Tensor
from transformers import AutoImageProcessor, ResNetConfig, ResNetForImageClassification
from transformers.utils import logging
logging.set_verbosity_info()
UpperCAmelCase = logging.get_logger()
@dataclass
class __magic_name__ :
__A : nn.Module
__A : List[nn.Module] = field(default_factory=__UpperCAmelCase )
__A : list = field(default_factory=__UpperCAmelCase )
def __snake_case ( self : List[str] , snake_case__ : List[str] , snake_case__ : Tensor , snake_case__ : Tensor ):
'''simple docstring'''
lowercase :List[str] = len(list(m.modules() ) ) == 1 or isinstance(snake_case__ , nn.Convad ) or isinstance(snake_case__ , nn.BatchNormad )
if has_not_submodules:
self.traced.append(snake_case__ )
def __call__( self : int , snake_case__ : Tensor ):
'''simple docstring'''
for m in self.module.modules():
self.handles.append(m.register_forward_hook(self._forward_hook ) )
self.module(snake_case__ )
[x.remove() for x in self.handles]
return self
@property
def __snake_case ( self : int ):
'''simple docstring'''
return list(filter(lambda snake_case__ : len(list(x.state_dict().keys() ) ) > 0 , self.traced ) )
@dataclass
class __magic_name__ :
__A : nn.Module
__A : nn.Module
__A : int = 0
__A : List = field(default_factory=__UpperCAmelCase )
__A : List = field(default_factory=__UpperCAmelCase )
def __call__( self : Dict , snake_case__ : Tensor ):
'''simple docstring'''
lowercase :Dict = Tracker(self.dest )(snake_case__ ).parametrized
lowercase :Optional[Any] = Tracker(self.src )(snake_case__ ).parametrized
lowercase :List[str] = list(filter(lambda snake_case__ : type(snake_case__ ) not in self.src_skip , snake_case__ ) )
lowercase :Tuple = list(filter(lambda snake_case__ : type(snake_case__ ) not in self.dest_skip , snake_case__ ) )
if len(snake_case__ ) != len(snake_case__ ):
raise Exception(
f"""Numbers of operations are different. Source module has {len(snake_case__ )} operations while"""
f""" destination module has {len(snake_case__ )}.""" )
for dest_m, src_m in zip(snake_case__ , snake_case__ ):
dest_m.load_state_dict(src_m.state_dict() )
if self.verbose == 1:
print(f"""Transfered from={src_m} to={dest_m}""" )
def lowerCamelCase (a_ :str , a_ :ResNetConfig , a_ :Path , a_ :bool = True) -> Optional[Any]:
print(F"""Converting {name}...""")
with torch.no_grad():
lowercase :Union[str, Any] = timm.create_model(a_ , pretrained=a_).eval()
lowercase :Tuple = ResNetForImageClassification(a_).eval()
lowercase :int = ModuleTransfer(src=a_ , dest=a_)
lowercase :List[Any] = torch.randn((1, 3, 224, 224))
module_transfer(a_)
assert torch.allclose(from_model(a_) , our_model(a_).logits), "The model logits don't match the original one."
lowercase :List[Any] = F"""resnet{'-'.join(name.split('resnet'))}"""
print(a_)
if push_to_hub:
our_model.push_to_hub(
repo_path_or_name=save_directory / checkpoint_name , commit_message='''Add model''' , use_temp_dir=a_ , )
# we can use the convnext one
lowercase :Any = AutoImageProcessor.from_pretrained('''facebook/convnext-base-224-22k-1k''')
image_processor.push_to_hub(
repo_path_or_name=save_directory / checkpoint_name , commit_message='''Add image processor''' , use_temp_dir=a_ , )
print(F"""Pushed {checkpoint_name}""")
def lowerCamelCase (a_ :Path , a_ :str = None , a_ :bool = True) -> int:
lowercase :Optional[Any] = '''imagenet-1k-id2label.json'''
lowercase :Union[str, Any] = 1000
lowercase :Any = (1, num_labels)
lowercase :Tuple = '''huggingface/label-files'''
lowercase :List[str] = num_labels
lowercase :Union[str, Any] = json.load(open(hf_hub_download(a_ , a_ , repo_type='''dataset''') , '''r'''))
lowercase :Any = {int(a_): v for k, v in idalabel.items()}
lowercase :str = idalabel
lowercase :Any = {v: k for k, v in idalabel.items()}
lowercase :Union[str, Any] = partial(a_ , num_labels=a_ , idalabel=a_ , labelaid=a_)
lowercase :Optional[int] = {
'''resnet18''': ImageNetPreTrainedConfig(
depths=[2, 2, 2, 2] , hidden_sizes=[64, 128, 256, 512] , layer_type='''basic'''),
'''resnet26''': ImageNetPreTrainedConfig(
depths=[2, 2, 2, 2] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet34''': ImageNetPreTrainedConfig(
depths=[3, 4, 6, 3] , hidden_sizes=[64, 128, 256, 512] , layer_type='''basic'''),
'''resnet50''': ImageNetPreTrainedConfig(
depths=[3, 4, 6, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet101''': ImageNetPreTrainedConfig(
depths=[3, 4, 23, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet152''': ImageNetPreTrainedConfig(
depths=[3, 8, 36, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
}
if model_name:
convert_weight_and_push(a_ , names_to_config[model_name] , a_ , a_)
else:
for model_name, config in names_to_config.items():
convert_weight_and_push(a_ , a_ , a_ , a_)
return config, expected_shape
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'''--model_name''',
default=None,
type=str,
help=(
'''The name of the model you wish to convert, it must be one of the supported resnet* architecture,'''
''' currently: resnet18,26,34,50,101,152. If `None`, all of them will the converted.'''
),
)
parser.add_argument(
'''--pytorch_dump_folder_path''',
default=None,
type=Path,
required=True,
help='''Path to the output PyTorch model directory.''',
)
parser.add_argument(
'''--push_to_hub''',
default=True,
type=bool,
required=False,
help='''If True, push model and image processor to the hub.''',
)
UpperCAmelCase = parser.parse_args()
UpperCAmelCase = args.pytorch_dump_folder_path
pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
| 677 | 1 |
"""simple docstring"""
import unittest
from typing import Tuple
import torch
from diffusers.utils import floats_tensor, randn_tensor, torch_all_close, torch_device
from diffusers.utils.testing_utils import require_torch
@require_torch
class __magic_name__ :
@property
def __snake_case ( self : Dict ):
'''simple docstring'''
return self.get_dummy_input()
@property
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
if self.block_type == "down":
return (4, 3_2, 1_6, 1_6)
elif self.block_type == "mid":
return (4, 3_2, 3_2, 3_2)
elif self.block_type == "up":
return (4, 3_2, 6_4, 6_4)
raise ValueError(f"""'{self.block_type}' is not a supported block_type. Set it to 'up', 'mid', or 'down'.""" )
def __snake_case ( self : str , snake_case__ : Any=True , snake_case__ : Any=False , snake_case__ : Optional[Any]=False , snake_case__ : List[str]=False , ):
'''simple docstring'''
lowercase :Optional[int] = 4
lowercase :Tuple = 3_2
lowercase :Optional[int] = (3_2, 3_2)
lowercase :Optional[int] = torch.manual_seed(0 )
lowercase :int = torch.device(snake_case__ )
lowercase :Optional[Any] = (batch_size, num_channels) + sizes
lowercase :int = randn_tensor(snake_case__ , generator=snake_case__ , device=snake_case__ )
lowercase :Optional[int] = {'''hidden_states''': hidden_states}
if include_temb:
lowercase :Any = 1_2_8
lowercase :List[Any] = randn_tensor((batch_size, temb_channels) , generator=snake_case__ , device=snake_case__ )
if include_res_hidden_states_tuple:
lowercase :Dict = torch.manual_seed(1 )
lowercase :int = (randn_tensor(snake_case__ , generator=snake_case__ , device=snake_case__ ),)
if include_encoder_hidden_states:
lowercase :Optional[Any] = floats_tensor((batch_size, 3_2, 3_2) ).to(snake_case__ )
if include_skip_sample:
lowercase :List[Any] = randn_tensor(((batch_size, 3) + sizes) , generator=snake_case__ , device=snake_case__ )
return dummy_input
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :List[Any] = {
'''in_channels''': 3_2,
'''out_channels''': 3_2,
'''temb_channels''': 1_2_8,
}
if self.block_type == "up":
lowercase :int = 3_2
if self.block_type == "mid":
init_dict.pop('''out_channels''' )
lowercase :Dict = self.dummy_input
return init_dict, inputs_dict
def __snake_case ( self : str , snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase , lowercase :Optional[Any] = self.prepare_init_args_and_inputs_for_common()
lowercase :Any = self.block_class(**snake_case__ )
unet_block.to(snake_case__ )
unet_block.eval()
with torch.no_grad():
lowercase :List[str] = unet_block(**snake_case__ )
if isinstance(snake_case__ , snake_case__ ):
lowercase :int = output[0]
self.assertEqual(output.shape , self.output_shape )
lowercase :int = output[0, -1, -3:, -3:]
lowercase :Tuple = torch.tensor(snake_case__ ).to(snake_case__ )
assert torch_all_close(output_slice.flatten() , snake_case__ , atol=5e-3 )
@unittest.skipIf(torch_device == '''mps''' , '''Training is not supported in mps''' )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase , lowercase :Dict = self.prepare_init_args_and_inputs_for_common()
lowercase :Optional[int] = self.block_class(**snake_case__ )
model.to(snake_case__ )
model.train()
lowercase :Dict = model(**snake_case__ )
if isinstance(snake_case__ , snake_case__ ):
lowercase :Union[str, Any] = output[0]
lowercase :Optional[Any] = torch.device(snake_case__ )
lowercase :List[Any] = randn_tensor(output.shape , device=snake_case__ )
lowercase :Tuple = torch.nn.functional.mse_loss(snake_case__ , snake_case__ )
loss.backward()
| 677 |
"""simple docstring"""
from __future__ import annotations
import unittest
from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin
if is_tf_available():
import tensorflow as tf
from transformers import (
TF_MODEL_FOR_PRETRAINING_MAPPING,
TFMobileBertForMaskedLM,
TFMobileBertForMultipleChoice,
TFMobileBertForNextSentencePrediction,
TFMobileBertForPreTraining,
TFMobileBertForQuestionAnswering,
TFMobileBertForSequenceClassification,
TFMobileBertForTokenClassification,
TFMobileBertModel,
)
@require_tf
class __magic_name__ ( __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
__A : Any = (
(
TFMobileBertModel,
TFMobileBertForMaskedLM,
TFMobileBertForNextSentencePrediction,
TFMobileBertForPreTraining,
TFMobileBertForQuestionAnswering,
TFMobileBertForSequenceClassification,
TFMobileBertForTokenClassification,
TFMobileBertForMultipleChoice,
)
if is_tf_available()
else ()
)
__A : List[Any] = (
{
"feature-extraction": TFMobileBertModel,
"fill-mask": TFMobileBertForMaskedLM,
"question-answering": TFMobileBertForQuestionAnswering,
"text-classification": TFMobileBertForSequenceClassification,
"token-classification": TFMobileBertForTokenClassification,
"zero-shot": TFMobileBertForSequenceClassification,
}
if is_tf_available()
else {}
)
__A : List[str] = False
__A : int = False
def __snake_case ( self : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Any , snake_case__ : int=False ):
'''simple docstring'''
lowercase :Union[str, Any] = super()._prepare_for_class(snake_case__ , snake_case__ , return_labels=snake_case__ )
if return_labels:
if model_class in get_values(snake_case__ ):
lowercase :Tuple = tf.zeros(self.model_tester.batch_size , dtype=tf.intaa )
return inputs_dict
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Any , snake_case__ : Dict , snake_case__ : Dict=1_3 , snake_case__ : Tuple=7 , snake_case__ : Optional[Any]=True , snake_case__ : Union[str, Any]=True , snake_case__ : str=True , snake_case__ : Optional[Any]=True , snake_case__ : Any=9_9 , snake_case__ : Optional[Any]=3_2 , snake_case__ : Optional[Any]=3_2 , snake_case__ : Any=2 , snake_case__ : Optional[int]=4 , snake_case__ : List[Any]=3_7 , snake_case__ : Optional[int]="gelu" , snake_case__ : List[Any]=0.1 , snake_case__ : str=0.1 , snake_case__ : List[Any]=5_1_2 , snake_case__ : List[str]=1_6 , snake_case__ : Union[str, Any]=2 , snake_case__ : Optional[Any]=0.02 , snake_case__ : Optional[Any]=3 , snake_case__ : Dict=4 , snake_case__ : int=None , ):
'''simple docstring'''
lowercase :Tuple = parent
lowercase :Tuple = batch_size
lowercase :Optional[Any] = seq_length
lowercase :Optional[Any] = is_training
lowercase :Optional[Any] = use_input_mask
lowercase :List[Any] = use_token_type_ids
lowercase :str = use_labels
lowercase :List[str] = vocab_size
lowercase :str = hidden_size
lowercase :Optional[int] = num_hidden_layers
lowercase :Dict = num_attention_heads
lowercase :Any = intermediate_size
lowercase :List[str] = hidden_act
lowercase :Optional[Any] = hidden_dropout_prob
lowercase :List[Any] = attention_probs_dropout_prob
lowercase :List[Any] = max_position_embeddings
lowercase :List[Any] = type_vocab_size
lowercase :Union[str, Any] = type_sequence_label_size
lowercase :Union[str, Any] = initializer_range
lowercase :Any = num_labels
lowercase :int = num_choices
lowercase :Dict = scope
lowercase :Dict = embedding_size
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :Optional[int] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size )
lowercase :int = None
if self.use_input_mask:
lowercase :int = random_attention_mask([self.batch_size, self.seq_length] )
lowercase :Tuple = None
if self.use_token_type_ids:
lowercase :int = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size )
lowercase :Union[str, Any] = None
lowercase :int = None
lowercase :str = None
if self.use_labels:
lowercase :int = ids_tensor([self.batch_size] , self.type_sequence_label_size )
lowercase :str = ids_tensor([self.batch_size, self.seq_length] , self.num_labels )
lowercase :Dict = ids_tensor([self.batch_size] , self.num_choices )
lowercase :Optional[int] = MobileBertConfig(
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 , embedding_size=self.embedding_size , )
return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
def __snake_case ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Any , snake_case__ : Tuple , snake_case__ : Tuple ):
'''simple docstring'''
lowercase :Dict = TFMobileBertModel(config=snake_case__ )
lowercase :Union[str, Any] = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
lowercase :Optional[int] = [input_ids, input_mask]
lowercase :Optional[int] = model(snake_case__ )
lowercase :Union[str, Any] = model(snake_case__ )
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 : List[Any] , snake_case__ : Dict , snake_case__ : Optional[int] , snake_case__ : int , snake_case__ : str , snake_case__ : Dict , snake_case__ : Tuple , snake_case__ : Optional[int] ):
'''simple docstring'''
lowercase :Any = TFMobileBertForMaskedLM(config=snake_case__ )
lowercase :Any = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :int = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) )
def __snake_case ( self : Tuple , snake_case__ : Any , snake_case__ : Optional[Any] , snake_case__ : List[Any] , snake_case__ : Dict , snake_case__ : str , snake_case__ : List[Any] , snake_case__ : Tuple ):
'''simple docstring'''
lowercase :Optional[Any] = TFMobileBertForNextSentencePrediction(config=snake_case__ )
lowercase :Tuple = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :Optional[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, 2) )
def __snake_case ( self : Dict , snake_case__ : Optional[Any] , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : Optional[int] , snake_case__ : int , snake_case__ : Union[str, Any] , snake_case__ : Dict ):
'''simple docstring'''
lowercase :int = TFMobileBertForPreTraining(config=snake_case__ )
lowercase :Any = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
self.parent.assertEqual(
result.prediction_logits.shape , (self.batch_size, self.seq_length, self.vocab_size) )
self.parent.assertEqual(result.seq_relationship_logits.shape , (self.batch_size, 2) )
def __snake_case ( self : Optional[Any] , snake_case__ : Tuple , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Optional[Any] , snake_case__ : List[str] , snake_case__ : Dict , snake_case__ : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = self.num_labels
lowercase :List[Any] = TFMobileBertForSequenceClassification(config=snake_case__ )
lowercase :Dict = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def __snake_case ( self : Any , snake_case__ : Optional[int] , snake_case__ : Tuple , snake_case__ : Union[str, Any] , snake_case__ : List[Any] , snake_case__ : List[Any] , snake_case__ : List[Any] , snake_case__ : Optional[Any] ):
'''simple docstring'''
lowercase :Tuple = self.num_choices
lowercase :Any = TFMobileBertForMultipleChoice(config=snake_case__ )
lowercase :Any = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :Union[str, Any] = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :List[Any] = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :Dict = {
'''input_ids''': multiple_choice_inputs_ids,
'''attention_mask''': multiple_choice_input_mask,
'''token_type_ids''': multiple_choice_token_type_ids,
}
lowercase :Optional[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) )
def __snake_case ( self : Any , snake_case__ : str , snake_case__ : Tuple , snake_case__ : int , snake_case__ : Tuple , snake_case__ : Dict , snake_case__ : Optional[Any] , snake_case__ : Dict ):
'''simple docstring'''
lowercase :List[Any] = self.num_labels
lowercase :List[str] = TFMobileBertForTokenClassification(config=snake_case__ )
lowercase :int = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :int = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) )
def __snake_case ( self : List[str] , snake_case__ : List[Any] , snake_case__ : Optional[int] , snake_case__ : Optional[int] , snake_case__ : List[Any] , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : str ):
'''simple docstring'''
lowercase :Union[str, Any] = TFMobileBertForQuestionAnswering(config=snake_case__ )
lowercase :List[Any] = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :str = model(snake_case__ )
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 : List[Any] ):
'''simple docstring'''
lowercase :Dict = self.prepare_config_and_inputs()
(
(
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) ,
) :Dict = config_and_inputs
lowercase :Optional[Any] = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
return config, inputs_dict
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = TFMobileBertModelTest.TFMobileBertModelTester(self )
lowercase :List[str] = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
self.config_tester.run_common_tests()
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :List[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_model(*snake_case__ )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :List[str] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_masked_lm(*snake_case__ )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :str = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_multiple_choice(*snake_case__ )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :Tuple = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*snake_case__ )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :int = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_pretraining(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Tuple = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_question_answering(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Optional[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_sequence_classification(*snake_case__ )
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_token_classification(*snake_case__ )
@slow
def __snake_case ( self : int ):
'''simple docstring'''
for model_name in ["google/mobilebert-uncased"]:
lowercase :List[str] = TFMobileBertModel.from_pretrained(snake_case__ )
self.assertIsNotNone(snake_case__ )
@require_tf
class __magic_name__ ( unittest.TestCase ):
@slow
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :int = TFMobileBertForPreTraining.from_pretrained('''google/mobilebert-uncased''' )
lowercase :Optional[Any] = tf.constant([[0, 1, 2, 3, 4, 5]] )
lowercase :List[Any] = model(snake_case__ )[0]
lowercase :Union[str, Any] = [1, 6, 3_0_5_2_2]
self.assertEqual(output.shape , snake_case__ )
lowercase :Optional[int] = tf.constant(
[
[
[-4.5_91_95_47, -9.24_82_95, -9.64_52_56],
[-6.7_30_61_75, -6.44_02_84, -6.6_05_28_37],
[-7.2_74_35_06, -6.7_84_79_15, -6.02_46_73],
]
] )
tf.debugging.assert_near(output[:, :3, :3] , snake_case__ , atol=1e-4 )
| 677 | 1 |
"""simple docstring"""
import subprocess
import sys
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch
class __magic_name__ ( __UpperCAmelCase ):
@require_torch
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Optional[Any] = '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
'''
lowercase :Any = '''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
'''
lowercase :Tuple = '''
import socket
def offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")
socket.socket = offline_socket
'''
# Force fetching the files so that we can use the cache
lowercase :str = '''hf-internal-testing/tiny-random-bert'''
BertConfig.from_pretrained(snake_case__ )
BertModel.from_pretrained(snake_case__ )
BertTokenizer.from_pretrained(snake_case__ )
pipeline(task='''fill-mask''' , model=snake_case__ )
# baseline - just load from_pretrained with normal network
lowercase :Union[str, Any] = [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]
# should succeed
lowercase :Any = self.get_env()
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :List[Any] = '''1'''
lowercase :List[str] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :List[str] = '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
'''
lowercase :Dict = '''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
'''
lowercase :List[Any] = '''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")
socket.socket = offline_socket
'''
# Force fetching the files so that we can use the cache
lowercase :str = '''hf-internal-testing/tiny-random-bert'''
BertConfig.from_pretrained(snake_case__ )
BertModel.from_pretrained(snake_case__ )
BertTokenizer.from_pretrained(snake_case__ )
pipeline(task='''fill-mask''' , model=snake_case__ )
# baseline - just load from_pretrained with normal network
lowercase :List[str] = [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]
# should succeed
lowercase :str = self.get_env()
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : int ):
'''simple docstring'''
lowercase :str = '''
from transformers import BertConfig, BertModel, BertTokenizer
'''
lowercase :Union[str, Any] = '''
mname = "hf-internal-testing/tiny-random-bert-sharded"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
print("success")
'''
lowercase :Optional[int] = '''
import socket
def offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")
socket.socket = offline_socket
'''
# baseline - just load from_pretrained with normal network
lowercase :Optional[Any] = [sys.executable, '''-c''', '''\n'''.join([load, run] )]
# should succeed
lowercase :Union[str, Any] = self.get_env()
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
# next emulate no network
lowercase :Tuple = [sys.executable, '''-c''', '''\n'''.join([load, mock, run] )]
# Doesn't fail anymore since the model is in the cache due to other tests, so commenting this.
# env["TRANSFORMERS_OFFLINE"] = "0"
# result = subprocess.run(cmd, env=env, check=False, capture_output=True)
# self.assertEqual(result.returncode, 1, result.stderr)
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :Any = '''1'''
lowercase :Optional[Any] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :Dict = '''
from transformers import pipeline
'''
lowercase :Optional[Any] = '''
mname = "hf-internal-testing/tiny-random-bert"
pipe = pipeline(model=mname)
'''
lowercase :Dict = '''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")
socket.socket = offline_socket
'''
lowercase :Tuple = self.get_env()
lowercase :Optional[Any] = '''1'''
lowercase :Optional[int] = [sys.executable, '''-c''', '''\n'''.join([load, mock, run] )]
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 1 , result.stderr )
self.assertIn(
'''You cannot infer task automatically within `pipeline` when using offline mode''' , result.stderr.decode().replace('''\n''' , '''''' ) , )
@require_torch
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = '''
from transformers import AutoModel
'''
lowercase :Union[str, Any] = '''
mname = "hf-internal-testing/test_dynamic_model"
AutoModel.from_pretrained(mname, trust_remote_code=True)
print("success")
'''
# baseline - just load from_pretrained with normal network
lowercase :Union[str, Any] = [sys.executable, '''-c''', '''\n'''.join([load, run] )]
# should succeed
lowercase :List[str] = self.get_env()
lowercase :Optional[int] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :List[Any] = '''1'''
lowercase :Tuple = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
| 677 |
"""simple docstring"""
import contextlib
import copy
import random
from typing import Any, Dict, Iterable, Optional, Union
import numpy as np
import torch
from .utils import deprecate, is_transformers_available
if is_transformers_available():
import transformers
def lowerCamelCase (a_ :int) -> List[str]:
random.seed(a_)
np.random.seed(a_)
torch.manual_seed(a_)
torch.cuda.manual_seed_all(a_)
# ^^ safe to call this function even if cuda is not available
class __magic_name__ :
def __init__( self : Optional[Any] , snake_case__ : Iterable[torch.nn.Parameter] , snake_case__ : float = 0.99_99 , snake_case__ : float = 0.0 , snake_case__ : int = 0 , snake_case__ : bool = False , snake_case__ : Union[float, int] = 1.0 , snake_case__ : Union[float, int] = 2 / 3 , snake_case__ : Optional[Any] = None , snake_case__ : Dict[str, Any] = None , **snake_case__ : Tuple , ):
'''simple docstring'''
if isinstance(snake_case__ , torch.nn.Module ):
lowercase :int = (
'''Passing a `torch.nn.Module` to `ExponentialMovingAverage` is deprecated. '''
'''Please pass the parameters of the module instead.'''
)
deprecate(
'''passing a `torch.nn.Module` to `ExponentialMovingAverage`''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ , )
lowercase :Dict = parameters.parameters()
# set use_ema_warmup to True if a torch.nn.Module is passed for backwards compatibility
lowercase :Optional[Any] = True
if kwargs.get('''max_value''' , snake_case__ ) is not None:
lowercase :Optional[Any] = '''The `max_value` argument is deprecated. Please use `decay` instead.'''
deprecate('''max_value''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
lowercase :Optional[int] = kwargs['''max_value''']
if kwargs.get('''min_value''' , snake_case__ ) is not None:
lowercase :List[Any] = '''The `min_value` argument is deprecated. Please use `min_decay` instead.'''
deprecate('''min_value''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
lowercase :str = kwargs['''min_value''']
lowercase :Any = list(snake_case__ )
lowercase :Optional[Any] = [p.clone().detach() for p in parameters]
if kwargs.get('''device''' , snake_case__ ) is not None:
lowercase :str = '''The `device` argument is deprecated. Please use `to` instead.'''
deprecate('''device''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
self.to(device=kwargs['''device'''] )
lowercase :int = None
lowercase :int = decay
lowercase :Union[str, Any] = min_decay
lowercase :List[Any] = update_after_step
lowercase :Union[str, Any] = use_ema_warmup
lowercase :Any = inv_gamma
lowercase :Any = power
lowercase :str = 0
lowercase :int = None # set in `step()`
lowercase :List[str] = model_cls
lowercase :Any = model_config
@classmethod
def __snake_case ( cls : int , snake_case__ : Tuple , snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase , lowercase :int = model_cls.load_config(snake_case__ , return_unused_kwargs=snake_case__ )
lowercase :List[Any] = model_cls.from_pretrained(snake_case__ )
lowercase :Optional[int] = cls(model.parameters() , model_cls=snake_case__ , model_config=model.config )
ema_model.load_state_dict(snake_case__ )
return ema_model
def __snake_case ( self : int , snake_case__ : Union[str, Any] ):
'''simple docstring'''
if self.model_cls is None:
raise ValueError('''`save_pretrained` can only be used if `model_cls` was defined at __init__.''' )
if self.model_config is None:
raise ValueError('''`save_pretrained` can only be used if `model_config` was defined at __init__.''' )
lowercase :Dict = self.model_cls.from_config(self.model_config )
lowercase :Tuple = self.state_dict()
state_dict.pop('''shadow_params''' , snake_case__ )
model.register_to_config(**snake_case__ )
self.copy_to(model.parameters() )
model.save_pretrained(snake_case__ )
def __snake_case ( self : int , snake_case__ : int ):
'''simple docstring'''
lowercase :Union[str, Any] = max(0 , optimization_step - self.update_after_step - 1 )
if step <= 0:
return 0.0
if self.use_ema_warmup:
lowercase :int = 1 - (1 + step / self.inv_gamma) ** -self.power
else:
lowercase :Dict = (1 + step) / (1_0 + step)
lowercase :Optional[int] = min(snake_case__ , self.decay )
# make sure decay is not smaller than min_decay
lowercase :Optional[int] = max(snake_case__ , self.min_decay )
return cur_decay_value
@torch.no_grad()
def __snake_case ( self : Any , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
if isinstance(snake_case__ , torch.nn.Module ):
lowercase :Tuple = (
'''Passing a `torch.nn.Module` to `ExponentialMovingAverage.step` is deprecated. '''
'''Please pass the parameters of the module instead.'''
)
deprecate(
'''passing a `torch.nn.Module` to `ExponentialMovingAverage.step`''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ , )
lowercase :Union[str, Any] = parameters.parameters()
lowercase :Optional[Any] = list(snake_case__ )
self.optimization_step += 1
# Compute the decay factor for the exponential moving average.
lowercase :List[Any] = self.get_decay(self.optimization_step )
lowercase :Optional[Any] = decay
lowercase :List[Any] = 1 - decay
lowercase :List[str] = contextlib.nullcontext
if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
import deepspeed
for s_param, param in zip(self.shadow_params , snake_case__ ):
if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
lowercase :Union[str, Any] = deepspeed.zero.GatheredParameters(snake_case__ , modifier_rank=snake_case__ )
with context_manager():
if param.requires_grad:
s_param.sub_(one_minus_decay * (s_param - param) )
else:
s_param.copy_(snake_case__ )
def __snake_case ( self : str , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
lowercase :Optional[Any] = list(snake_case__ )
for s_param, param in zip(self.shadow_params , snake_case__ ):
param.data.copy_(s_param.to(param.device ).data )
def __snake_case ( self : Optional[int] , snake_case__ : Dict=None , snake_case__ : Dict=None ):
'''simple docstring'''
lowercase :str = [
p.to(device=snake_case__ , dtype=snake_case__ ) if p.is_floating_point() else p.to(device=snake_case__ )
for p in self.shadow_params
]
def __snake_case ( self : Dict ):
'''simple docstring'''
return {
"decay": self.decay,
"min_decay": self.min_decay,
"optimization_step": self.optimization_step,
"update_after_step": self.update_after_step,
"use_ema_warmup": self.use_ema_warmup,
"inv_gamma": self.inv_gamma,
"power": self.power,
"shadow_params": self.shadow_params,
}
def __snake_case ( self : Optional[int] , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
lowercase :str = [param.detach().cpu().clone() for param in parameters]
def __snake_case ( self : List[Any] , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
if self.temp_stored_params is None:
raise RuntimeError('''This ExponentialMovingAverage has no `store()`ed weights ''' '''to `restore()`''' )
for c_param, param in zip(self.temp_stored_params , snake_case__ ):
param.data.copy_(c_param.data )
# Better memory-wise.
lowercase :Dict = None
def __snake_case ( self : Union[str, Any] , snake_case__ : dict ):
'''simple docstring'''
lowercase :List[str] = copy.deepcopy(snake_case__ )
lowercase :Any = state_dict.get('''decay''' , self.decay )
if self.decay < 0.0 or self.decay > 1.0:
raise ValueError('''Decay must be between 0 and 1''' )
lowercase :int = state_dict.get('''min_decay''' , self.min_decay )
if not isinstance(self.min_decay , snake_case__ ):
raise ValueError('''Invalid min_decay''' )
lowercase :List[Any] = state_dict.get('''optimization_step''' , self.optimization_step )
if not isinstance(self.optimization_step , snake_case__ ):
raise ValueError('''Invalid optimization_step''' )
lowercase :int = state_dict.get('''update_after_step''' , self.update_after_step )
if not isinstance(self.update_after_step , snake_case__ ):
raise ValueError('''Invalid update_after_step''' )
lowercase :Optional[int] = state_dict.get('''use_ema_warmup''' , self.use_ema_warmup )
if not isinstance(self.use_ema_warmup , snake_case__ ):
raise ValueError('''Invalid use_ema_warmup''' )
lowercase :Any = state_dict.get('''inv_gamma''' , self.inv_gamma )
if not isinstance(self.inv_gamma , (float, int) ):
raise ValueError('''Invalid inv_gamma''' )
lowercase :Dict = state_dict.get('''power''' , self.power )
if not isinstance(self.power , (float, int) ):
raise ValueError('''Invalid power''' )
lowercase :Optional[int] = state_dict.get('''shadow_params''' , snake_case__ )
if shadow_params is not None:
lowercase :List[Any] = shadow_params
if not isinstance(self.shadow_params , snake_case__ ):
raise ValueError('''shadow_params must be a list''' )
if not all(isinstance(snake_case__ , torch.Tensor ) for p in self.shadow_params ):
raise ValueError('''shadow_params must all be Tensors''' )
| 677 | 1 |
"""simple docstring"""
from argparse import ArgumentParser
from . import BaseTransformersCLICommand
def lowerCamelCase (a_ :str) -> Dict:
return DownloadCommand(args.model , args.cache_dir , args.force , args.trust_remote_code)
class __magic_name__ ( __UpperCAmelCase ):
@staticmethod
def __snake_case ( snake_case__ : ArgumentParser ):
'''simple docstring'''
lowercase :Any = parser.add_parser('''download''' )
download_parser.add_argument(
'''--cache-dir''' , type=snake_case__ , default=snake_case__ , help='''Path to location to store the models''' )
download_parser.add_argument(
'''--force''' , action='''store_true''' , help='''Force the model to be download even if already in cache-dir''' )
download_parser.add_argument(
'''--trust-remote-code''' , action='''store_true''' , help='''Whether or not to allow for custom models defined on the Hub in their own modeling files. Use only if you\'ve reviewed the code as it will execute on your local machine''' , )
download_parser.add_argument('''model''' , type=snake_case__ , help='''Name of the model to download''' )
download_parser.set_defaults(func=snake_case__ )
def __init__( self : Optional[int] , snake_case__ : str , snake_case__ : str , snake_case__ : bool , snake_case__ : bool ):
'''simple docstring'''
lowercase :str = model
lowercase :int = cache
lowercase :List[str] = force
lowercase :int = trust_remote_code
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
from ..models.auto import AutoModel, AutoTokenizer
AutoModel.from_pretrained(
self._model , cache_dir=self._cache , force_download=self._force , trust_remote_code=self._trust_remote_code )
AutoTokenizer.from_pretrained(
self._model , cache_dir=self._cache , force_download=self._force , trust_remote_code=self._trust_remote_code )
| 677 |
"""simple docstring"""
import argparse
import collections
import numpy as np
import torch
from flax import traverse_util
from tax import checkpoints
from transformers import MTaConfig, UMTaEncoderModel, UMTaForConditionalGeneration
from transformers.utils import logging
logging.set_verbosity_info()
def lowerCamelCase (a_ :int , a_ :Union[str, Any] , a_ :List[Any]) -> List[str]:
return params[F"""{prefix}/{prefix}/relpos_bias/rel_embedding"""][:, i, :]
def lowerCamelCase (a_ :Optional[Any] , a_ :Optional[int] , a_ :str , a_ :Any="attention") -> Optional[int]:
lowercase :Tuple = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/key/kernel"""][:, i, :, :])
lowercase :int = k_tmp.reshape(k_tmp.shape[0] , k_tmp.shape[1] * k_tmp.shape[2])
lowercase :str = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/out/kernel"""][:, i, :, :])
lowercase :Any = o_tmp.reshape(o_tmp.shape[0] * o_tmp.shape[1] , o_tmp.shape[2])
lowercase :int = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/query/kernel"""][:, i, :, :])
lowercase :List[str] = q_tmp.reshape(q_tmp.shape[0] , q_tmp.shape[1] * q_tmp.shape[2])
lowercase :List[Any] = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/value/kernel"""][:, i, :, :])
lowercase :Optional[int] = v_tmp.reshape(v_tmp.shape[0] , v_tmp.shape[1] * v_tmp.shape[2])
return k, o, q, v
def lowerCamelCase (a_ :Any , a_ :Union[str, Any] , a_ :Union[str, Any] , a_ :Union[str, Any]=False) -> List[Any]:
if split_mlp_wi:
lowercase :List[Any] = params[F"""{prefix}/{prefix}/mlp/wi_0/kernel"""][:, i, :]
lowercase :Optional[int] = params[F"""{prefix}/{prefix}/mlp/wi_1/kernel"""][:, i, :]
lowercase :Dict = (wi_a, wi_a)
else:
lowercase :Optional[Any] = params[F"""{prefix}/{prefix}/mlp/wi/kernel"""][:, i, :]
lowercase :Union[str, Any] = params[F"""{prefix}/{prefix}/mlp/wo/kernel"""][:, i, :]
return wi, wo
def lowerCamelCase (a_ :Any , a_ :Optional[Any] , a_ :Optional[Any] , a_ :Union[str, Any]) -> Optional[Any]:
return params[F"""{prefix}/{prefix}/{layer_name}/scale"""][:, i]
def lowerCamelCase (a_ :dict , *, a_ :int , a_ :bool , a_ :bool = False) -> int:
lowercase :Dict = traverse_util.flatten_dict(variables['''target'''])
lowercase :Optional[Any] = {'''/'''.join(a_): v for k, v in old.items()}
# v1.1 models have a gated GeLU with wi_0 and wi_1 instead of wi
lowercase :str = '''encoder/encoder/mlp/wi_0/kernel''' in old
print('''Split MLP:''' , a_)
lowercase :str = collections.OrderedDict()
# Shared embeddings.
lowercase :int = old['''token_embedder/embedding''']
# Encoder.
for i in range(a_):
# Block i, layer 0 (Self Attention).
lowercase :Union[str, Any] = tax_layer_norm_lookup(a_ , a_ , '''encoder''' , '''pre_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :Tuple = tax_attention_lookup(a_ , a_ , '''encoder''' , '''attention''')
lowercase :Dict = layer_norm
lowercase :Dict = k.T
lowercase :Union[str, Any] = o.T
lowercase :List[Any] = q.T
lowercase :int = v.T
# Block i, layer 1 (MLP).
lowercase :Optional[int] = tax_layer_norm_lookup(a_ , a_ , '''encoder''' , '''pre_mlp_layer_norm''')
lowercase , lowercase :str = tax_mlp_lookup(a_ , a_ , '''encoder''' , a_)
lowercase :int = layer_norm
if split_mlp_wi:
lowercase :Tuple = wi[0].T
lowercase :Tuple = wi[1].T
else:
lowercase :int = wi.T
lowercase :Tuple = wo.T
if scalable_attention:
# convert the rel_embedding of each layer
lowercase :Dict = tax_relpos_bias_lookup(
a_ , a_ , '''encoder''').T
lowercase :str = old['''encoder/encoder_norm/scale''']
if not scalable_attention:
lowercase :str = tax_relpos_bias_lookup(
a_ , 0 , '''encoder''').T
lowercase :List[Any] = tax_relpos_bias_lookup(
a_ , 0 , '''decoder''').T
if not is_encoder_only:
# Decoder.
for i in range(a_):
# Block i, layer 0 (Self Attention).
lowercase :Any = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_self_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :str = tax_attention_lookup(a_ , a_ , '''decoder''' , '''self_attention''')
lowercase :List[str] = layer_norm
lowercase :Dict = k.T
lowercase :List[Any] = o.T
lowercase :List[Any] = q.T
lowercase :Any = v.T
# Block i, layer 1 (Cross Attention).
lowercase :Tuple = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_cross_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :int = tax_attention_lookup(a_ , a_ , '''decoder''' , '''encoder_decoder_attention''')
lowercase :int = layer_norm
lowercase :Dict = k.T
lowercase :int = o.T
lowercase :List[Any] = q.T
lowercase :Tuple = v.T
# Block i, layer 2 (MLP).
lowercase :Any = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_mlp_layer_norm''')
lowercase , lowercase :Tuple = tax_mlp_lookup(a_ , a_ , '''decoder''' , a_)
lowercase :Any = layer_norm
if split_mlp_wi:
lowercase :int = wi[0].T
lowercase :Union[str, Any] = wi[1].T
else:
lowercase :int = wi.T
lowercase :List[Any] = wo.T
if scalable_attention:
# convert the rel_embedding of each layer
lowercase :Union[str, Any] = tax_relpos_bias_lookup(a_ , a_ , '''decoder''').T
lowercase :Union[str, Any] = old['''decoder/decoder_norm/scale''']
# LM Head (only in v1.1 checkpoints, in v1.0 embeddings are used instead)
if "decoder/logits_dense/kernel" in old:
lowercase :int = old['''decoder/logits_dense/kernel'''].T
return new
def lowerCamelCase (a_ :Dict , a_ :bool) -> Tuple:
lowercase :str = collections.OrderedDict([(k, torch.from_numpy(v.copy())) for (k, v) in converted_params.items()])
# Add what is missing.
if "encoder.embed_tokens.weight" not in state_dict:
lowercase :Any = state_dict['''shared.weight''']
if not is_encoder_only:
if "decoder.embed_tokens.weight" not in state_dict:
lowercase :Optional[Any] = state_dict['''shared.weight''']
if "lm_head.weight" not in state_dict: # For old 1.0 models.
print('''Using shared word embeddings as lm_head.''')
lowercase :Optional[int] = state_dict['''shared.weight''']
return state_dict
def lowerCamelCase (a_ :List[str] , a_ :List[str] , a_ :Tuple , a_ :Optional[int] , a_ :List[str]) -> List[str]:
lowercase :Optional[Any] = checkpoints.load_tax_checkpoint(a_)
lowercase :Optional[int] = convert_tax_to_pytorch(
a_ , num_layers=config.num_layers , is_encoder_only=a_ , scalable_attention=a_)
lowercase :Union[str, Any] = make_state_dict(a_ , a_)
model.load_state_dict(a_ , strict=a_)
def lowerCamelCase (a_ :str , a_ :Optional[int] , a_ :Any , a_ :bool = False , a_ :bool = False , ) -> Tuple:
lowercase :Optional[int] = MTaConfig.from_json_file(a_)
print(F"""Building PyTorch model from configuration: {config}""")
# Non-v1.1 checkpoints could also use T5Model, but this works for all.
# The v1.0 checkpoints will simply have an LM head that is the word embeddings.
if is_encoder_only:
lowercase :Union[str, Any] = UMTaEncoderModel(a_)
else:
lowercase :int = UMTaForConditionalGeneration(a_)
# Load weights from tf checkpoint
load_tax_weights_in_ta(a_ , a_ , a_ , a_ , a_)
# Save pytorch-model
print(F"""Save PyTorch model to {pytorch_dump_path}""")
model.save_pretrained(a_)
# Verify that we can load the checkpoint.
model.from_pretrained(a_)
print('''Done''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser(description='''Converts a native T5X checkpoint into a PyTorch checkpoint.''')
# Required parameters
parser.add_argument(
'''--t5x_checkpoint_path''', default=None, type=str, required=True, help='''Path to the T5X checkpoint.'''
)
parser.add_argument(
'''--config_file''',
default=None,
type=str,
required=True,
help='''The config json file corresponding to the pre-trained T5 model.\nThis specifies the model architecture.''',
)
parser.add_argument(
'''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
)
parser.add_argument(
'''--is_encoder_only''', action='''store_true''', help='''Check if the model is encoder-decoder model''', default=False
)
parser.add_argument(
'''--scalable_attention''',
action='''store_true''',
help='''Whether the model uses scaled attention (umt5 model)''',
default=False,
)
UpperCAmelCase = parser.parse_args()
convert_tax_checkpoint_to_pytorch(
args.tax_checkpoint_path,
args.config_file,
args.pytorch_dump_path,
args.is_encoder_only,
args.scalable_attention,
)
| 677 | 1 |
"""simple docstring"""
def lowerCamelCase (a_ :list) -> list:
def merge(a_ :list , a_ :list) -> list:
def _merge():
while left and right:
yield (left if left[0] <= right[0] else right).pop(0)
yield from left
yield from right
return list(_merge())
if len(a_) <= 1:
return collection
lowercase :Tuple = len(a_) // 2
return merge(merge_sort(collection[:mid]) , merge_sort(collection[mid:]))
if __name__ == "__main__":
import doctest
doctest.testmod()
UpperCAmelCase = input('''Enter numbers separated by a comma:\n''').strip()
UpperCAmelCase = [int(item) for item in user_input.split(''',''')]
print(*merge_sort(unsorted), sep=''',''')
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tf_available,
is_tokenizers_available,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_blenderbot''': [
'''BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''BlenderbotConfig''',
'''BlenderbotOnnxConfig''',
],
'''tokenization_blenderbot''': ['''BlenderbotTokenizer'''],
}
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''BlenderbotTokenizerFast''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''BlenderbotForCausalLM''',
'''BlenderbotForConditionalGeneration''',
'''BlenderbotModel''',
'''BlenderbotPreTrainedModel''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TFBlenderbotForConditionalGeneration''',
'''TFBlenderbotModel''',
'''TFBlenderbotPreTrainedModel''',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxBlenderbotForConditionalGeneration''',
'''FlaxBlenderbotModel''',
'''FlaxBlenderbotPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_blenderbot import (
BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP,
BlenderbotConfig,
BlenderbotOnnxConfig,
)
from .tokenization_blenderbot import BlenderbotTokenizer
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_blenderbot_fast import BlenderbotTokenizerFast
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_blenderbot import (
BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST,
BlenderbotForCausalLM,
BlenderbotForConditionalGeneration,
BlenderbotModel,
BlenderbotPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_blenderbot import (
TFBlenderbotForConditionalGeneration,
TFBlenderbotModel,
TFBlenderbotPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_blenderbot import (
FlaxBlenderbotForConditionalGeneration,
FlaxBlenderbotModel,
FlaxBlenderbotPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
import socket
def lowerCamelCase () -> Tuple:
lowercase :Any = socket.socket(socket.AF_INET , socket.SOCK_STREAM)
lowercase :List[Any] = socket.gethostname()
lowercase :Optional[Any] = 1_2312
sock.connect((host, port))
sock.send(b'''Hello server!''')
with open('''Received_file''' , '''wb''') as out_file:
print('''File opened''')
print('''Receiving data...''')
while True:
lowercase :List[Any] = sock.recv(1024)
if not data:
break
out_file.write(a_)
print('''Successfully received the file''')
sock.close()
print('''Connection closed''')
if __name__ == "__main__":
main()
| 677 |
"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''naver-clova-ix/donut-base''': '''https://huggingface.co/naver-clova-ix/donut-base/resolve/main/config.json''',
# See all Donut models at https://huggingface.co/models?filter=donut-swin
}
class __magic_name__ ( __UpperCAmelCase ):
__A : Tuple = "donut-swin"
__A : Optional[Any] = {
"num_attention_heads": "num_heads",
"num_hidden_layers": "num_layers",
}
def __init__( self : List[str] , snake_case__ : Any=2_2_4 , snake_case__ : Tuple=4 , snake_case__ : str=3 , snake_case__ : Dict=9_6 , snake_case__ : Optional[Any]=[2, 2, 6, 2] , snake_case__ : Any=[3, 6, 1_2, 2_4] , snake_case__ : List[str]=7 , snake_case__ : Dict=4.0 , snake_case__ : str=True , snake_case__ : Optional[int]=0.0 , snake_case__ : Tuple=0.0 , snake_case__ : Any=0.1 , snake_case__ : List[str]="gelu" , snake_case__ : Tuple=False , snake_case__ : int=0.02 , snake_case__ : Optional[Any]=1e-5 , **snake_case__ : Any , ):
'''simple docstring'''
super().__init__(**snake_case__ )
lowercase :Union[str, Any] = image_size
lowercase :Optional[Any] = patch_size
lowercase :List[str] = num_channels
lowercase :Optional[int] = embed_dim
lowercase :Optional[Any] = depths
lowercase :List[Any] = len(snake_case__ )
lowercase :Optional[Any] = num_heads
lowercase :int = window_size
lowercase :str = mlp_ratio
lowercase :Optional[int] = qkv_bias
lowercase :Dict = hidden_dropout_prob
lowercase :Any = attention_probs_dropout_prob
lowercase :Any = drop_path_rate
lowercase :int = hidden_act
lowercase :int = use_absolute_embeddings
lowercase :List[str] = layer_norm_eps
lowercase :Union[str, Any] = initializer_range
# we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
# this indicates the channel dimension after the last stage of the model
lowercase :str = int(embed_dim * 2 ** (len(snake_case__ ) - 1) )
| 677 | 1 |
"""simple docstring"""
import functools
import operator
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''asapp/sew-d-tiny-100k''': '''https://huggingface.co/asapp/sew-d-tiny-100k/resolve/main/config.json''',
# See all SEW-D models at https://huggingface.co/models?filter=sew-d
}
class __magic_name__ ( __UpperCAmelCase ):
__A : str = "sew-d"
def __init__( self : int , snake_case__ : str=3_2 , snake_case__ : Optional[Any]=7_6_8 , snake_case__ : Dict=1_2 , snake_case__ : Tuple=1_2 , snake_case__ : str=3_0_7_2 , snake_case__ : Dict=2 , snake_case__ : Optional[Any]=5_1_2 , snake_case__ : str=2_5_6 , snake_case__ : List[str]=True , snake_case__ : List[str]=True , snake_case__ : int=("p2c", "c2p") , snake_case__ : str="layer_norm" , snake_case__ : List[str]="gelu_python" , snake_case__ : Dict=0.1 , snake_case__ : List[str]=0.1 , snake_case__ : Tuple=0.1 , snake_case__ : Any=0.0 , snake_case__ : int=0.1 , snake_case__ : List[Any]=0.02 , snake_case__ : Optional[int]=1e-7 , snake_case__ : Tuple=1e-5 , snake_case__ : List[str]="group" , snake_case__ : str="gelu" , snake_case__ : Union[str, Any]=(6_4, 1_2_8, 1_2_8, 1_2_8, 1_2_8, 2_5_6, 2_5_6, 2_5_6, 2_5_6, 5_1_2, 5_1_2, 5_1_2, 5_1_2) , snake_case__ : List[str]=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1) , snake_case__ : List[Any]=(1_0, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1) , snake_case__ : Union[str, Any]=False , snake_case__ : str=1_2_8 , snake_case__ : int=1_6 , snake_case__ : Optional[int]=True , snake_case__ : Union[str, Any]=0.05 , snake_case__ : List[str]=1_0 , snake_case__ : str=2 , snake_case__ : Dict=0.0 , snake_case__ : Any=1_0 , snake_case__ : Optional[Any]=0 , snake_case__ : Tuple="mean" , snake_case__ : List[Any]=False , snake_case__ : Tuple=False , snake_case__ : Optional[int]=2_5_6 , snake_case__ : List[Any]=0 , snake_case__ : List[str]=1 , snake_case__ : Optional[Any]=2 , **snake_case__ : int , ):
'''simple docstring'''
super().__init__(**snake_case__ , pad_token_id=snake_case__ , bos_token_id=snake_case__ , eos_token_id=snake_case__ )
lowercase :List[str] = hidden_size
lowercase :Dict = feat_extract_norm
lowercase :str = feat_extract_activation
lowercase :int = list(snake_case__ )
lowercase :Any = list(snake_case__ )
lowercase :Optional[int] = list(snake_case__ )
lowercase :str = conv_bias
lowercase :Dict = num_conv_pos_embeddings
lowercase :Dict = num_conv_pos_embedding_groups
lowercase :List[str] = len(self.conv_dim )
lowercase :Optional[Any] = num_hidden_layers
lowercase :List[str] = intermediate_size
lowercase :Dict = squeeze_factor
lowercase :str = max_position_embeddings
lowercase :List[str] = position_buckets
lowercase :Dict = share_att_key
lowercase :List[Any] = relative_attention
lowercase :Union[str, Any] = norm_rel_ebd
lowercase :Optional[Any] = list(snake_case__ )
lowercase :Any = hidden_act
lowercase :Optional[Any] = num_attention_heads
lowercase :Any = hidden_dropout
lowercase :str = attention_dropout
lowercase :int = activation_dropout
lowercase :Tuple = feat_proj_dropout
lowercase :Optional[int] = final_dropout
lowercase :Optional[int] = layer_norm_eps
lowercase :Tuple = feature_layer_norm_eps
lowercase :Optional[int] = initializer_range
lowercase :Any = vocab_size
if (
(len(self.conv_stride ) != self.num_feat_extract_layers)
or (len(self.conv_kernel ) != self.num_feat_extract_layers)
or (len(self.conv_dim ) != self.num_feat_extract_layers)
):
raise ValueError(
'''Configuration for convolutional layers is incorrect.'''
'''It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,'''
f"""but is `len(config.conv_dim) = {len(self.conv_dim )}`, `len(config.conv_stride)"""
f"""= {len(self.conv_stride )}`, `len(config.conv_kernel) = {len(self.conv_kernel )}`.""" )
# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
lowercase :List[Any] = apply_spec_augment
lowercase :str = mask_time_prob
lowercase :str = mask_time_length
lowercase :int = mask_time_min_masks
lowercase :Optional[int] = mask_feature_prob
lowercase :str = mask_feature_length
lowercase :int = mask_feature_min_masks
# ctc loss
lowercase :List[Any] = ctc_loss_reduction
lowercase :Any = ctc_zero_infinity
# sequence classification
lowercase :Optional[Any] = use_weighted_layer_sum
lowercase :str = classifier_proj_size
@property
def __snake_case ( self : int ):
'''simple docstring'''
return functools.reduce(operator.mul , self.conv_stride , 1 )
| 677 |
"""simple docstring"""
import argparse
import os
import shutil
from pathlib import Path
import onnx
import torch
from packaging import version
from torch.onnx import export
from diffusers import OnnxRuntimeModel, OnnxStableDiffusionPipeline, StableDiffusionPipeline
UpperCAmelCase = version.parse(version.parse(torch.__version__).base_version) < version.parse('''1.11''')
def lowerCamelCase (a_ :Optional[int] , a_ :tuple , a_ :Path , a_ :str , a_ :int , a_ :List[Any] , a_ :Any , a_ :Union[str, Any]=False , ) -> Dict:
output_path.parent.mkdir(parents=a_ , exist_ok=a_)
# PyTorch deprecated the `enable_onnx_checker` and `use_external_data_format` arguments in v1.11,
# so we check the torch version for backwards compatibility
if is_torch_less_than_1_11:
export(
a_ , a_ , f=output_path.as_posix() , input_names=a_ , output_names=a_ , dynamic_axes=a_ , do_constant_folding=a_ , use_external_data_format=a_ , enable_onnx_checker=a_ , opset_version=a_ , )
else:
export(
a_ , a_ , f=output_path.as_posix() , input_names=a_ , output_names=a_ , dynamic_axes=a_ , do_constant_folding=a_ , opset_version=a_ , )
@torch.no_grad()
def lowerCamelCase (a_ :str , a_ :str , a_ :int , a_ :bool = False) -> Union[str, Any]:
lowercase :Any = torch.floataa if fpaa else torch.floataa
if fpaa and torch.cuda.is_available():
lowercase :Union[str, Any] = '''cuda'''
elif fpaa and not torch.cuda.is_available():
raise ValueError('''`float16` model export is only supported on GPUs with CUDA''')
else:
lowercase :List[str] = '''cpu'''
lowercase :List[str] = StableDiffusionPipeline.from_pretrained(a_ , torch_dtype=a_).to(a_)
lowercase :List[Any] = Path(a_)
# TEXT ENCODER
lowercase :List[Any] = pipeline.text_encoder.config.max_position_embeddings
lowercase :Dict = pipeline.text_encoder.config.hidden_size
lowercase :Union[str, Any] = pipeline.tokenizer(
'''A sample prompt''' , padding='''max_length''' , max_length=pipeline.tokenizer.model_max_length , truncation=a_ , return_tensors='''pt''' , )
onnx_export(
pipeline.text_encoder , model_args=(text_input.input_ids.to(device=a_ , dtype=torch.intaa)) , output_path=output_path / '''text_encoder''' / '''model.onnx''' , ordered_input_names=['''input_ids'''] , output_names=['''last_hidden_state''', '''pooler_output'''] , dynamic_axes={
'''input_ids''': {0: '''batch''', 1: '''sequence'''},
} , opset=a_ , )
del pipeline.text_encoder
# UNET
lowercase :Any = pipeline.unet.config.in_channels
lowercase :List[Any] = pipeline.unet.config.sample_size
lowercase :Optional[int] = output_path / '''unet''' / '''model.onnx'''
onnx_export(
pipeline.unet , model_args=(
torch.randn(2 , a_ , a_ , a_).to(device=a_ , dtype=a_),
torch.randn(2).to(device=a_ , dtype=a_),
torch.randn(2 , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=a_ , ordered_input_names=['''sample''', '''timestep''', '''encoder_hidden_states''', '''return_dict'''] , output_names=['''out_sample'''] , dynamic_axes={
'''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
'''timestep''': {0: '''batch'''},
'''encoder_hidden_states''': {0: '''batch''', 1: '''sequence'''},
} , opset=a_ , use_external_data_format=a_ , )
lowercase :List[Any] = str(unet_path.absolute().as_posix())
lowercase :str = os.path.dirname(a_)
lowercase :Optional[Any] = onnx.load(a_)
# clean up existing tensor files
shutil.rmtree(a_)
os.mkdir(a_)
# collate external tensor files into one
onnx.save_model(
a_ , a_ , save_as_external_data=a_ , all_tensors_to_one_file=a_ , location='''weights.pb''' , convert_attribute=a_ , )
del pipeline.unet
# VAE ENCODER
lowercase :Tuple = pipeline.vae
lowercase :Optional[Any] = vae_encoder.config.in_channels
lowercase :Any = vae_encoder.config.sample_size
# need to get the raw tensor output (sample) from the encoder
lowercase :Any = lambda a_ , a_: vae_encoder.encode(a_ , a_)[0].sample()
onnx_export(
a_ , model_args=(
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=output_path / '''vae_encoder''' / '''model.onnx''' , ordered_input_names=['''sample''', '''return_dict'''] , output_names=['''latent_sample'''] , dynamic_axes={
'''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
} , opset=a_ , )
# VAE DECODER
lowercase :Any = pipeline.vae
lowercase :Dict = vae_decoder.config.latent_channels
lowercase :Union[str, Any] = vae_decoder.config.out_channels
# forward only through the decoder part
lowercase :List[Any] = vae_encoder.decode
onnx_export(
a_ , model_args=(
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=output_path / '''vae_decoder''' / '''model.onnx''' , ordered_input_names=['''latent_sample''', '''return_dict'''] , output_names=['''sample'''] , dynamic_axes={
'''latent_sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
} , opset=a_ , )
del pipeline.vae
# SAFETY CHECKER
if pipeline.safety_checker is not None:
lowercase :Dict = pipeline.safety_checker
lowercase :str = safety_checker.config.vision_config.num_channels
lowercase :str = safety_checker.config.vision_config.image_size
lowercase :List[str] = safety_checker.forward_onnx
onnx_export(
pipeline.safety_checker , model_args=(
torch.randn(
1 , a_ , a_ , a_ , ).to(device=a_ , dtype=a_),
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
) , output_path=output_path / '''safety_checker''' / '''model.onnx''' , ordered_input_names=['''clip_input''', '''images'''] , output_names=['''out_images''', '''has_nsfw_concepts'''] , dynamic_axes={
'''clip_input''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
'''images''': {0: '''batch''', 1: '''height''', 2: '''width''', 3: '''channels'''},
} , opset=a_ , )
del pipeline.safety_checker
lowercase :Tuple = OnnxRuntimeModel.from_pretrained(output_path / '''safety_checker''')
lowercase :Optional[Any] = pipeline.feature_extractor
else:
lowercase :int = None
lowercase :Union[str, Any] = None
lowercase :Optional[int] = OnnxStableDiffusionPipeline(
vae_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_encoder''') , vae_decoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_decoder''') , text_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''text_encoder''') , tokenizer=pipeline.tokenizer , unet=OnnxRuntimeModel.from_pretrained(output_path / '''unet''') , scheduler=pipeline.scheduler , safety_checker=a_ , feature_extractor=a_ , requires_safety_checker=safety_checker is not None , )
onnx_pipeline.save_pretrained(a_)
print('''ONNX pipeline saved to''' , a_)
del pipeline
del onnx_pipeline
lowercase :Tuple = OnnxStableDiffusionPipeline.from_pretrained(a_ , provider='''CPUExecutionProvider''')
print('''ONNX pipeline is loadable''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
parser.add_argument(
'''--model_path''',
type=str,
required=True,
help='''Path to the `diffusers` checkpoint to convert (either a local directory or on the Hub).''',
)
parser.add_argument('''--output_path''', type=str, required=True, help='''Path to the output model.''')
parser.add_argument(
'''--opset''',
default=14,
type=int,
help='''The version of the ONNX operator set to use.''',
)
parser.add_argument('''--fp16''', action='''store_true''', default=False, help='''Export the models in `float16` mode''')
UpperCAmelCase = parser.parse_args()
convert_models(args.model_path, args.output_path, args.opset, args.fpaa)
| 677 | 1 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_tokenizers_available,
is_torch_available,
is_vision_available,
)
UpperCAmelCase = {
'''configuration_perceiver''': ['''PERCEIVER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''PerceiverConfig''', '''PerceiverOnnxConfig'''],
'''tokenization_perceiver''': ['''PerceiverTokenizer'''],
}
try:
if not is_vision_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''PerceiverFeatureExtractor''']
UpperCAmelCase = ['''PerceiverImageProcessor''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''PERCEIVER_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''PerceiverForImageClassificationConvProcessing''',
'''PerceiverForImageClassificationFourier''',
'''PerceiverForImageClassificationLearned''',
'''PerceiverForMaskedLM''',
'''PerceiverForMultimodalAutoencoding''',
'''PerceiverForOpticalFlow''',
'''PerceiverForSequenceClassification''',
'''PerceiverLayer''',
'''PerceiverModel''',
'''PerceiverPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_perceiver import PERCEIVER_PRETRAINED_CONFIG_ARCHIVE_MAP, PerceiverConfig, PerceiverOnnxConfig
from .tokenization_perceiver import PerceiverTokenizer
try:
if not is_vision_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .feature_extraction_perceiver import PerceiverFeatureExtractor
from .image_processing_perceiver import PerceiverImageProcessor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_perceiver import (
PERCEIVER_PRETRAINED_MODEL_ARCHIVE_LIST,
PerceiverForImageClassificationConvProcessing,
PerceiverForImageClassificationFourier,
PerceiverForImageClassificationLearned,
PerceiverForMaskedLM,
PerceiverForMultimodalAutoencoding,
PerceiverForOpticalFlow,
PerceiverForSequenceClassification,
PerceiverLayer,
PerceiverModel,
PerceiverPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 |
"""simple docstring"""
import itertools
import json
import linecache
import os
import pickle
import re
import socket
import string
from collections import Counter
from logging import getLogger
from pathlib import Path
from typing import Callable, Dict, Iterable, List
import git
import torch
from torch.utils.data import Dataset
from transformers import BartTokenizer, RagTokenizer, TaTokenizer
def lowerCamelCase (a_ :List[Any] , a_ :Union[str, Any] , a_ :Tuple , a_ :List[str] , a_ :str=True , a_ :str="pt") -> List[str]:
lowercase :Optional[int] = {'''add_prefix_space''': True} if isinstance(a_ , a_) and not line.startswith(''' ''') else {}
lowercase :Optional[int] = padding_side
return tokenizer(
[line] , max_length=a_ , padding='''max_length''' if pad_to_max_length else None , truncation=a_ , return_tensors=a_ , add_special_tokens=a_ , **a_ , )
def lowerCamelCase (a_ :str , a_ :Tuple , a_ :Optional[Any]=None , ) -> Tuple:
lowercase :Optional[Any] = input_ids.ne(a_).any(dim=0)
if attention_mask is None:
return input_ids[:, keep_column_mask]
else:
return (input_ids[:, keep_column_mask], attention_mask[:, keep_column_mask])
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Union[str, Any] , snake_case__ : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : str="train" , snake_case__ : Optional[Any]=None , snake_case__ : Tuple=None , snake_case__ : Any=None , snake_case__ : Dict="" , ):
'''simple docstring'''
super().__init__()
lowercase :Tuple = Path(snake_case__ ).joinpath(type_path + '''.source''' )
lowercase :Union[str, Any] = Path(snake_case__ ).joinpath(type_path + '''.target''' )
lowercase :List[Any] = self.get_char_lens(self.src_file )
lowercase :Tuple = max_source_length
lowercase :Optional[int] = max_target_length
assert min(self.src_lens ) > 0, f"""found empty line in {self.src_file}"""
lowercase :Any = tokenizer
lowercase :Tuple = prefix
if n_obs is not None:
lowercase :List[str] = self.src_lens[:n_obs]
lowercase :List[Any] = src_lang
lowercase :str = tgt_lang
def __len__( self : Any ):
'''simple docstring'''
return len(self.src_lens )
def __getitem__( self : str , snake_case__ : Any ):
'''simple docstring'''
lowercase :Optional[int] = index + 1 # linecache starts at 1
lowercase :Optional[Any] = self.prefix + linecache.getline(str(self.src_file ) , snake_case__ ).rstrip('''\n''' )
lowercase :Dict = linecache.getline(str(self.tgt_file ) , snake_case__ ).rstrip('''\n''' )
assert source_line, f"""empty source line for index {index}"""
assert tgt_line, f"""empty tgt line for index {index}"""
# Need to add eos token manually for T5
if isinstance(self.tokenizer , snake_case__ ):
source_line += self.tokenizer.eos_token
tgt_line += self.tokenizer.eos_token
# Pad source and target to the right
lowercase :Dict = (
self.tokenizer.question_encoder if isinstance(self.tokenizer , snake_case__ ) else self.tokenizer
)
lowercase :Optional[int] = self.tokenizer.generator if isinstance(self.tokenizer , snake_case__ ) else self.tokenizer
lowercase :Optional[int] = encode_line(snake_case__ , snake_case__ , self.max_source_length , '''right''' )
lowercase :Tuple = encode_line(snake_case__ , snake_case__ , self.max_target_length , '''right''' )
lowercase :List[str] = source_inputs['''input_ids'''].squeeze()
lowercase :Optional[Any] = target_inputs['''input_ids'''].squeeze()
lowercase :List[str] = source_inputs['''attention_mask'''].squeeze()
return {
"input_ids": source_ids,
"attention_mask": src_mask,
"decoder_input_ids": target_ids,
}
@staticmethod
def __snake_case ( snake_case__ : Optional[int] ):
'''simple docstring'''
return [len(snake_case__ ) for x in Path(snake_case__ ).open().readlines()]
def __snake_case ( self : Tuple , snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase :Optional[Any] = torch.stack([x['''input_ids'''] for x in batch] )
lowercase :Tuple = torch.stack([x['''attention_mask'''] for x in batch] )
lowercase :Tuple = torch.stack([x['''decoder_input_ids'''] for x in batch] )
lowercase :str = (
self.tokenizer.generator.pad_token_id
if isinstance(self.tokenizer , snake_case__ )
else self.tokenizer.pad_token_id
)
lowercase :Optional[int] = (
self.tokenizer.question_encoder.pad_token_id
if isinstance(self.tokenizer , snake_case__ )
else self.tokenizer.pad_token_id
)
lowercase :List[Any] = trim_batch(snake_case__ , snake_case__ )
lowercase , lowercase :List[str] = trim_batch(snake_case__ , snake_case__ , attention_mask=snake_case__ )
lowercase :Optional[int] = {
'''input_ids''': source_ids,
'''attention_mask''': source_mask,
'''decoder_input_ids''': y,
}
return batch
UpperCAmelCase = getLogger(__name__)
def lowerCamelCase (a_ :List[List]) -> Tuple:
return list(itertools.chain.from_iterable(a_))
def lowerCamelCase (a_ :str) -> None:
lowercase :List[str] = get_git_info()
save_json(a_ , os.path.join(a_ , '''git_log.json'''))
def lowerCamelCase (a_ :Optional[int] , a_ :Optional[int] , a_ :Optional[Any]=4 , **a_ :Optional[Any]) -> str:
with open(a_ , '''w''') as f:
json.dump(a_ , a_ , indent=a_ , **a_)
def lowerCamelCase (a_ :Dict) -> Union[str, Any]:
with open(a_) as f:
return json.load(a_)
def lowerCamelCase () -> List[str]:
lowercase :Dict = git.Repo(search_parent_directories=a_)
lowercase :int = {
'''repo_id''': str(a_),
'''repo_sha''': str(repo.head.object.hexsha),
'''repo_branch''': str(repo.active_branch),
'''hostname''': str(socket.gethostname()),
}
return repo_infos
def lowerCamelCase (a_ :Callable , a_ :Iterable) -> List:
return list(map(a_ , a_))
def lowerCamelCase (a_ :Optional[Any] , a_ :str) -> Any:
with open(a_ , '''wb''') as f:
return pickle.dump(a_ , a_)
def lowerCamelCase (a_ :List[str]) -> List[str]:
def remove_articles(a_ :Union[str, Any]):
return re.sub(R'''\b(a|an|the)\b''' , ''' ''' , a_)
def white_space_fix(a_ :Tuple):
return " ".join(text.split())
def remove_punc(a_ :int):
lowercase :List[Any] = set(string.punctuation)
return "".join(ch for ch in text if ch not in exclude)
def lower(a_ :int):
return text.lower()
return white_space_fix(remove_articles(remove_punc(lower(a_))))
def lowerCamelCase (a_ :List[str] , a_ :Any) -> List[str]:
lowercase :Dict = normalize_answer(a_).split()
lowercase :int = normalize_answer(a_).split()
lowercase :List[Any] = Counter(a_) & Counter(a_)
lowercase :Optional[int] = sum(common.values())
if num_same == 0:
return 0
lowercase :str = 1.0 * num_same / len(a_)
lowercase :Tuple = 1.0 * num_same / len(a_)
lowercase :Tuple = (2 * precision * recall) / (precision + recall)
return fa
def lowerCamelCase (a_ :Tuple , a_ :Optional[Any]) -> List[Any]:
return normalize_answer(a_) == normalize_answer(a_)
def lowerCamelCase (a_ :List[str] , a_ :List[str]) -> Dict:
assert len(a_) == len(a_)
lowercase :Any = 0
for hypo, pred in zip(a_ , a_):
em += exact_match_score(a_ , a_)
if len(a_) > 0:
em /= len(a_)
return {"em": em}
def lowerCamelCase (a_ :Union[str, Any]) -> Optional[Any]:
return model_prefix.startswith('''rag''')
def lowerCamelCase (a_ :List[str] , a_ :Tuple , a_ :List[str]) -> Any:
lowercase :List[str] = {p: p for p in extra_params}
# T5 models don't have `dropout` param, they have `dropout_rate` instead
lowercase :str = '''dropout_rate'''
for p in extra_params:
if getattr(a_ , a_ , a_):
if not hasattr(a_ , a_) and not hasattr(a_ , equivalent_param[p]):
logger.info('''config doesn\'t have a `{}` attribute'''.format(a_))
delattr(a_ , a_)
continue
lowercase :List[str] = p if hasattr(a_ , a_) else equivalent_param[p]
setattr(a_ , a_ , getattr(a_ , a_))
delattr(a_ , a_)
return hparams, config
| 677 | 1 |
"""simple docstring"""
import warnings
from ...utils import logging
from .image_processing_flava import FlavaImageProcessor
UpperCAmelCase = logging.get_logger(__name__)
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Any , *snake_case__ : str , **snake_case__ : Optional[int] ):
'''simple docstring'''
warnings.warn(
'''The class FlavaFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'''
''' use FlavaImageProcessor instead.''' , snake_case__ , )
super().__init__(*snake_case__ , **snake_case__ )
| 677 |
"""simple docstring"""
def lowerCamelCase (a_ :Tuple , a_ :int , a_ :Tuple , a_ :List[Any]) -> str:
if height >= 1:
move_tower(height - 1 , a_ , a_ , a_)
move_disk(a_ , a_)
move_tower(height - 1 , a_ , a_ , a_)
def lowerCamelCase (a_ :int , a_ :Union[str, Any]) -> str:
print('''moving disk from''' , a_ , '''to''' , a_)
def lowerCamelCase () -> Tuple:
lowercase :int = int(input('''Height of hanoi: ''').strip())
move_tower(a_ , '''A''' , '''B''' , '''C''')
if __name__ == "__main__":
main()
| 677 | 1 |
"""simple docstring"""
import json
import os
import re
import shutil
import tempfile
import unittest
from typing import Tuple
from transformers import AddedToken, BatchEncoding, PerceiverTokenizer
from transformers.utils import cached_property, is_tf_available, is_torch_available
from ...test_tokenization_common import TokenizerTesterMixin
if is_torch_available():
UpperCAmelCase = '''pt'''
elif is_tf_available():
UpperCAmelCase = '''tf'''
else:
UpperCAmelCase = '''jax'''
class __magic_name__ ( __UpperCAmelCase , unittest.TestCase ):
__A : List[str] = PerceiverTokenizer
__A : Optional[Any] = False
def __snake_case ( self : Any ):
'''simple docstring'''
super().setUp()
lowercase :Optional[Any] = PerceiverTokenizer()
tokenizer.save_pretrained(self.tmpdirname )
@cached_property
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
return PerceiverTokenizer.from_pretrained('''deepmind/language-perceiver''' )
def __snake_case ( self : Optional[Any] , **snake_case__ : Tuple ):
'''simple docstring'''
return self.tokenizer_class.from_pretrained(self.tmpdirname , **snake_case__ )
def __snake_case ( self : Any , snake_case__ : Dict , snake_case__ : Any=False , snake_case__ : int=2_0 , snake_case__ : Optional[Any]=5 ):
'''simple docstring'''
lowercase :List[Any] = []
for i in range(len(snake_case__ ) ):
try:
lowercase :Any = tokenizer.decode([i] , clean_up_tokenization_spaces=snake_case__ )
except UnicodeDecodeError:
pass
toks.append((i, tok) )
lowercase :str = list(filter(lambda snake_case__ : re.match(r'''^[ a-zA-Z]+$''' , t[1] ) , snake_case__ ) )
lowercase :Dict = list(filter(lambda snake_case__ : [t[0]] == tokenizer.encode(t[1] , add_special_tokens=snake_case__ ) , snake_case__ ) )
if max_length is not None and len(snake_case__ ) > max_length:
lowercase :Optional[Any] = toks[:max_length]
if min_length is not None and len(snake_case__ ) < min_length and len(snake_case__ ) > 0:
while len(snake_case__ ) < min_length:
lowercase :List[str] = toks + toks
# toks_str = [t[1] for t in toks]
lowercase :Any = [t[0] for t in toks]
# Ensure consistency
lowercase :Any = tokenizer.decode(snake_case__ , clean_up_tokenization_spaces=snake_case__ )
if " " not in output_txt and len(snake_case__ ) > 1:
lowercase :List[Any] = (
tokenizer.decode([toks_ids[0]] , clean_up_tokenization_spaces=snake_case__ )
+ ''' '''
+ tokenizer.decode(toks_ids[1:] , clean_up_tokenization_spaces=snake_case__ )
)
if with_prefix_space:
lowercase :List[str] = ''' ''' + output_txt
lowercase :Optional[Any] = tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ )
return output_txt, output_ids
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :str = self.perceiver_tokenizer
lowercase :str = '''Unicode €.'''
lowercase :Dict = tokenizer(snake_case__ )
lowercase :Any = [4, 9_1, 1_1_6, 1_1_1, 1_0_5, 1_1_7, 1_0_6, 1_0_7, 3_8, 2_3_2, 1_3_6, 1_7_8, 5_2, 5]
self.assertEqual(encoded['''input_ids'''] , snake_case__ )
# decoding
lowercase :Any = tokenizer.decode(snake_case__ )
self.assertEqual(snake_case__ , '''[CLS]Unicode €.[SEP]''' )
lowercase :List[Any] = tokenizer('''e è é ê ë''' )
lowercase :str = [4, 1_0_7, 3_8, 2_0_1, 1_7_4, 3_8, 2_0_1, 1_7_5, 3_8, 2_0_1, 1_7_6, 3_8, 2_0_1, 1_7_7, 5]
self.assertEqual(encoded['''input_ids'''] , snake_case__ )
# decoding
lowercase :Tuple = tokenizer.decode(snake_case__ )
self.assertEqual(snake_case__ , '''[CLS]e è é ê ë[SEP]''' )
# encode/decode, but with `encode` instead of `__call__`
self.assertEqual(tokenizer.decode(tokenizer.encode('''e è é ê ë''' ) ) , '''[CLS]e è é ê ë[SEP]''' )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :Union[str, Any] = self.perceiver_tokenizer
lowercase :int = ['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
# fmt: off
lowercase :List[str] = [4, 7_1, 3_8, 1_1_4, 1_1_7, 1_1_6, 1_0_9, 3_8, 1_1_8, 1_0_3, 1_2_0, 1_0_3, 1_0_9, 1_2_0, 1_0_3, 1_1_8, 1_1_0, 3_8, 1_0_8, 1_1_7, 1_2_0, 3_8, 1_2_1, 1_2_3, 1_1_5, 1_1_5, 1_0_3, 1_2_0, 1_1_1, 1_2_8, 1_0_3, 1_2_2, 1_1_1, 1_1_7, 1_1_6, 5_2, 5, 0]
# fmt: on
lowercase :List[str] = tokenizer(snake_case__ , padding=snake_case__ , return_tensors=snake_case__ )
self.assertIsInstance(snake_case__ , snake_case__ )
if FRAMEWORK != "jax":
lowercase :str = list(batch.input_ids.numpy()[0] )
else:
lowercase :Optional[int] = list(batch.input_ids.tolist()[0] )
self.assertListEqual(snake_case__ , snake_case__ )
self.assertEqual((2, 3_8) , batch.input_ids.shape )
self.assertEqual((2, 3_8) , batch.attention_mask.shape )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :Union[str, Any] = self.perceiver_tokenizer
lowercase :List[str] = ['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
lowercase :List[Any] = tokenizer(snake_case__ , padding=snake_case__ , return_tensors=snake_case__ )
# check if input_ids are returned and no decoder_input_ids
self.assertIn('''input_ids''' , snake_case__ )
self.assertIn('''attention_mask''' , snake_case__ )
self.assertNotIn('''decoder_input_ids''' , snake_case__ )
self.assertNotIn('''decoder_attention_mask''' , snake_case__ )
def __snake_case ( self : int ):
'''simple docstring'''
lowercase :Optional[int] = self.perceiver_tokenizer
lowercase :List[Any] = [
'''Summary of the text.''',
'''Another summary.''',
]
lowercase :Optional[Any] = tokenizer(
text_target=snake_case__ , max_length=3_2 , padding='''max_length''' , truncation=snake_case__ , return_tensors=snake_case__ )
self.assertEqual(3_2 , targets['''input_ids'''].shape[1] )
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :Optional[int] = self.get_tokenizers()
for tokenizer in tokenizers:
with self.subTest(f"""{tokenizer.__class__.__name__}""" ):
self.assertNotEqual(tokenizer.model_max_length , 4_2 )
# Now let's start the test
lowercase :Any = self.get_tokenizers()
for tokenizer in tokenizers:
with self.subTest(f"""{tokenizer.__class__.__name__}""" ):
# Isolate this from the other tests because we save additional tokens/etc
lowercase :List[Any] = tempfile.mkdtemp()
lowercase :Tuple = ''' He is very happy, UNwant\u00E9d,running'''
lowercase :Dict = tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ )
tokenizer.save_pretrained(snake_case__ )
lowercase :Union[str, Any] = tokenizer.__class__.from_pretrained(snake_case__ )
lowercase :Any = after_tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ )
self.assertListEqual(snake_case__ , snake_case__ )
shutil.rmtree(snake_case__ )
lowercase :str = self.get_tokenizers(model_max_length=4_2 )
for tokenizer in tokenizers:
with self.subTest(f"""{tokenizer.__class__.__name__}""" ):
# Isolate this from the other tests because we save additional tokens/etc
lowercase :Any = tempfile.mkdtemp()
lowercase :Any = ''' He is very happy, UNwant\u00E9d,running'''
tokenizer.add_tokens(['''bim''', '''bambam'''] )
lowercase :Union[str, Any] = tokenizer.additional_special_tokens
additional_special_tokens.append('''new_additional_special_token''' )
tokenizer.add_special_tokens({'''additional_special_tokens''': additional_special_tokens} )
lowercase :Union[str, Any] = tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ )
tokenizer.save_pretrained(snake_case__ )
lowercase :str = tokenizer.__class__.from_pretrained(snake_case__ )
lowercase :Tuple = after_tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ )
self.assertListEqual(snake_case__ , snake_case__ )
self.assertIn('''new_additional_special_token''' , after_tokenizer.additional_special_tokens )
self.assertEqual(after_tokenizer.model_max_length , 4_2 )
lowercase :Dict = tokenizer.__class__.from_pretrained(snake_case__ , model_max_length=4_3 )
self.assertEqual(tokenizer.model_max_length , 4_3 )
shutil.rmtree(snake_case__ )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :List[str] = []
if self.test_slow_tokenizer:
tokenizer_list.append((self.tokenizer_class, self.get_tokenizer()) )
if self.test_rust_tokenizer:
tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer()) )
for tokenizer_class, tokenizer_utils in tokenizer_list:
with tempfile.TemporaryDirectory() as tmp_dir:
tokenizer_utils.save_pretrained(snake_case__ )
with open(os.path.join(snake_case__ , '''special_tokens_map.json''' ) , encoding='''utf-8''' ) as json_file:
lowercase :Any = json.load(snake_case__ )
with open(os.path.join(snake_case__ , '''tokenizer_config.json''' ) , encoding='''utf-8''' ) as json_file:
lowercase :Any = json.load(snake_case__ )
lowercase :Tuple = [f"""<extra_id_{i}>""" for i in range(1_2_5 )]
lowercase :List[str] = added_tokens_extra_ids + [
'''an_additional_special_token'''
]
lowercase :List[str] = added_tokens_extra_ids + [
'''an_additional_special_token'''
]
with open(os.path.join(snake_case__ , '''special_tokens_map.json''' ) , '''w''' , encoding='''utf-8''' ) as outfile:
json.dump(snake_case__ , snake_case__ )
with open(os.path.join(snake_case__ , '''tokenizer_config.json''' ) , '''w''' , encoding='''utf-8''' ) as outfile:
json.dump(snake_case__ , snake_case__ )
# the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
# into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
# "special_tokens_map.json" files
lowercase :str = tokenizer_class.from_pretrained(
snake_case__ , )
self.assertIn(
'''an_additional_special_token''' , tokenizer_without_change_in_init.additional_special_tokens )
self.assertEqual(
['''an_additional_special_token'''] , tokenizer_without_change_in_init.convert_ids_to_tokens(
tokenizer_without_change_in_init.convert_tokens_to_ids(['''an_additional_special_token'''] ) ) , )
# Now we test that we can change the value of additional_special_tokens in the from_pretrained
lowercase :Optional[Any] = added_tokens_extra_ids + [AddedToken('''a_new_additional_special_token''' , lstrip=snake_case__ )]
lowercase :str = tokenizer_class.from_pretrained(
snake_case__ , additional_special_tokens=snake_case__ , )
self.assertIn('''a_new_additional_special_token''' , tokenizer.additional_special_tokens )
self.assertEqual(
['''a_new_additional_special_token'''] , tokenizer.convert_ids_to_tokens(
tokenizer.convert_tokens_to_ids(['''a_new_additional_special_token'''] ) ) , )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :Union[str, Any] = self.perceiver_tokenizer
self.assertEqual(tokenizer.decode([1_7_8] ) , '''�''' )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
pass
def __snake_case ( self : int ):
'''simple docstring'''
pass
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
pass
def __snake_case ( self : Tuple ):
'''simple docstring'''
pass
def __snake_case ( self : int ):
'''simple docstring'''
lowercase :List[str] = self.get_tokenizers(fast=snake_case__ , do_lower_case=snake_case__ )
for tokenizer in tokenizers:
with self.subTest(f"""{tokenizer.__class__.__name__}""" ):
lowercase :Dict = ['''[CLS]''', '''t''', '''h''', '''i''', '''s''', ''' ''', '''i''', '''s''', ''' ''', '''a''', ''' ''', '''t''', '''e''', '''s''', '''t''', '''[SEP]''']
lowercase :List[str] = tokenizer.convert_tokens_to_string(snake_case__ )
self.assertIsInstance(snake_case__ , snake_case__ )
| 677 |
"""simple docstring"""
from sklearn.metrics import mean_squared_error
import datasets
UpperCAmelCase = '''\
@article{scikit-learn,
title={Scikit-learn: Machine Learning in {P}ython},
author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
journal={Journal of Machine Learning Research},
volume={12},
pages={2825--2830},
year={2011}
}
'''
UpperCAmelCase = '''\
Mean Squared Error(MSE) is the average of the square of difference between the predicted
and actual values.
'''
UpperCAmelCase = '''
Args:
predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)
Estimated target values.
references: array-like of shape (n_samples,) or (n_samples, n_outputs)
Ground truth (correct) target values.
sample_weight: array-like of shape (n_samples,), default=None
Sample weights.
multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"
Defines aggregating of multiple output values. Array-like value defines weights used to average errors.
"raw_values" : Returns a full set of errors in case of multioutput input.
"uniform_average" : Errors of all outputs are averaged with uniform weight.
squared : bool, default=True
If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.
Returns:
mse : mean squared error.
Examples:
>>> mse_metric = datasets.load_metric("mse")
>>> predictions = [2.5, 0.0, 2, 8]
>>> references = [3, -0.5, 2, 7]
>>> results = mse_metric.compute(predictions=predictions, references=references)
>>> print(results)
{\'mse\': 0.375}
>>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)
>>> print(rmse_result)
{\'mse\': 0.6123724356957945}
If you\'re using multi-dimensional lists, then set the config as follows :
>>> mse_metric = datasets.load_metric("mse", "multilist")
>>> predictions = [[0.5, 1], [-1, 1], [7, -6]]
>>> references = [[0, 2], [-1, 2], [8, -5]]
>>> results = mse_metric.compute(predictions=predictions, references=references)
>>> print(results)
{\'mse\': 0.7083333333333334}
>>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')
>>> print(results) # doctest: +NORMALIZE_WHITESPACE
{\'mse\': array([0.41666667, 1. ])}
'''
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class __magic_name__ ( datasets.Metric ):
def __snake_case ( self : int ):
'''simple docstring'''
return datasets.MetricInfo(
description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(self._get_feature_types() ) , reference_urls=[
'''https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html'''
] , )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
if self.config_name == "multilist":
return {
"predictions": datasets.Sequence(datasets.Value('''float''' ) ),
"references": datasets.Sequence(datasets.Value('''float''' ) ),
}
else:
return {
"predictions": datasets.Value('''float''' ),
"references": datasets.Value('''float''' ),
}
def __snake_case ( self : List[Any] , snake_case__ : str , snake_case__ : int , snake_case__ : str=None , snake_case__ : List[Any]="uniform_average" , snake_case__ : Dict=True ):
'''simple docstring'''
lowercase :Dict = mean_squared_error(
snake_case__ , snake_case__ , sample_weight=snake_case__ , multioutput=snake_case__ , squared=snake_case__ )
return {"mse": mse}
| 677 | 1 |
"""simple docstring"""
from collections import OrderedDict
from typing import Mapping
from packaging import version
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''microsoft/resnet-50''': '''https://huggingface.co/microsoft/resnet-50/blob/main/config.json''',
}
class __magic_name__ ( __UpperCAmelCase , __UpperCAmelCase ):
__A : str = "resnet"
__A : Union[str, Any] = ["basic", "bottleneck"]
def __init__( self : Optional[Any] , snake_case__ : Tuple=3 , snake_case__ : Optional[Any]=6_4 , snake_case__ : int=[2_5_6, 5_1_2, 1_0_2_4, 2_0_4_8] , snake_case__ : Dict=[3, 4, 6, 3] , snake_case__ : str="bottleneck" , snake_case__ : Dict="relu" , snake_case__ : Union[str, Any]=False , snake_case__ : str=None , snake_case__ : Union[str, Any]=None , **snake_case__ : List[Any] , ):
'''simple docstring'''
super().__init__(**snake_case__ )
if layer_type not in self.layer_types:
raise ValueError(f"""layer_type={layer_type} is not one of {','.join(self.layer_types )}""" )
lowercase :List[str] = num_channels
lowercase :str = embedding_size
lowercase :int = hidden_sizes
lowercase :Dict = depths
lowercase :Any = layer_type
lowercase :Optional[int] = hidden_act
lowercase :Optional[Any] = downsample_in_first_stage
lowercase :Optional[int] = ['''stem'''] + [f"""stage{idx}""" for idx in range(1 , len(snake_case__ ) + 1 )]
lowercase , lowercase :int = get_aligned_output_features_output_indices(
out_features=snake_case__ , out_indices=snake_case__ , stage_names=self.stage_names )
class __magic_name__ ( __UpperCAmelCase ):
__A : Optional[Any] = version.parse("1.11" )
@property
def __snake_case ( self : Tuple ):
'''simple docstring'''
return OrderedDict(
[
('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
] )
@property
def __snake_case ( self : Tuple ):
'''simple docstring'''
return 1e-3
| 677 |
"""simple docstring"""
from abc import ABC, abstractmethod
from argparse import ArgumentParser
class __magic_name__ ( __UpperCAmelCase ):
@staticmethod
@abstractmethod
def __snake_case ( snake_case__ : ArgumentParser ):
'''simple docstring'''
raise NotImplementedError()
@abstractmethod
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
raise NotImplementedError()
| 677 | 1 |
"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
class __magic_name__ ( __UpperCAmelCase ):
__A : List[str] = "timm_backbone"
def __init__( self : str , snake_case__ : List[Any]=None , snake_case__ : int=3 , snake_case__ : int=True , snake_case__ : Dict=True , snake_case__ : List[str]=None , **snake_case__ : Optional[int] , ):
'''simple docstring'''
super().__init__(**snake_case__ )
lowercase :Any = backbone
lowercase :List[str] = num_channels
lowercase :str = features_only
lowercase :Optional[Any] = use_pretrained_backbone
lowercase :Any = True
lowercase :Optional[Any] = out_indices if out_indices is not None else (-1,)
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_encodec''': [
'''ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''EncodecConfig''',
],
'''feature_extraction_encodec''': ['''EncodecFeatureExtractor'''],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''EncodecModel''',
'''EncodecPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_encodec import (
ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP,
EncodecConfig,
)
from .feature_extraction_encodec import EncodecFeatureExtractor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_encodec import (
ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST,
EncodecModel,
EncodecPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
import enum
import os
from hashlib import shaaaa
from typing import Optional
from .. import config
from .logging import get_logger
UpperCAmelCase = get_logger(__name__)
class __magic_name__ ( enum.Enum ):
__A : Union[str, Any] = "all_checks"
__A : Any = "basic_checks"
__A : str = "no_checks"
class __magic_name__ ( __UpperCAmelCase ):
pass
class __magic_name__ ( __UpperCAmelCase ):
pass
class __magic_name__ ( __UpperCAmelCase ):
pass
class __magic_name__ ( __UpperCAmelCase ):
pass
def lowerCamelCase (a_ :Optional[dict] , a_ :dict , a_ :List[str]=None) -> Optional[Any]:
if expected_checksums is None:
logger.info('''Unable to verify checksums.''')
return
if len(set(a_) - set(a_)) > 0:
raise ExpectedMoreDownloadedFiles(str(set(a_) - set(a_)))
if len(set(a_) - set(a_)) > 0:
raise UnexpectedDownloadedFile(str(set(a_) - set(a_)))
lowercase :Tuple = [url for url in expected_checksums if expected_checksums[url] != recorded_checksums[url]]
lowercase :Optional[int] = ''' for ''' + verification_name if verification_name is not None else ''''''
if len(a_) > 0:
raise NonMatchingChecksumError(
F"""Checksums didn't match{for_verification_name}:\n"""
F"""{bad_urls}\n"""
'''Set `verification_mode=\'no_checks\'` to skip checksums verification and ignore this error''')
logger.info('''All the checksums matched successfully''' + for_verification_name)
class __magic_name__ ( __UpperCAmelCase ):
pass
class __magic_name__ ( __UpperCAmelCase ):
pass
class __magic_name__ ( __UpperCAmelCase ):
pass
class __magic_name__ ( __UpperCAmelCase ):
pass
def lowerCamelCase (a_ :Optional[dict] , a_ :dict) -> List[Any]:
if expected_splits is None:
logger.info('''Unable to verify splits sizes.''')
return
if len(set(a_) - set(a_)) > 0:
raise ExpectedMoreSplits(str(set(a_) - set(a_)))
if len(set(a_) - set(a_)) > 0:
raise UnexpectedSplits(str(set(a_) - set(a_)))
lowercase :List[str] = [
{'''expected''': expected_splits[name], '''recorded''': recorded_splits[name]}
for name in expected_splits
if expected_splits[name].num_examples != recorded_splits[name].num_examples
]
if len(a_) > 0:
raise NonMatchingSplitsSizesError(str(a_))
logger.info('''All the splits matched successfully.''')
def lowerCamelCase (a_ :str , a_ :bool = True) -> dict:
if record_checksum:
lowercase :List[str] = shaaaa()
with open(a_ , '''rb''') as f:
for chunk in iter(lambda: f.read(1 << 20) , b''''''):
m.update(a_)
lowercase :int = m.hexdigest()
else:
lowercase :int = None
return {"num_bytes": os.path.getsize(a_), "checksum": checksum}
def lowerCamelCase (a_ :Union[str, Any]) -> List[Any]:
if dataset_size and config.IN_MEMORY_MAX_SIZE:
return dataset_size < config.IN_MEMORY_MAX_SIZE
else:
return False
| 677 |
"""simple docstring"""
import inspect
import unittest
from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available
from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor
if is_flax_available():
import jax
import jax.numpy as jnp
from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel
if is_vision_available():
from PIL import Image
from transformers import AutoImageProcessor
class __magic_name__ ( unittest.TestCase ):
def __init__( self : List[Any] , snake_case__ : Optional[int] , snake_case__ : List[str]=3 , snake_case__ : int=3_2 , snake_case__ : int=3 , snake_case__ : str=1_0 , snake_case__ : str=[1_0, 2_0, 3_0, 4_0] , snake_case__ : int=[1, 1, 2, 1] , snake_case__ : List[Any]=True , snake_case__ : Tuple=True , snake_case__ : Optional[Any]="relu" , snake_case__ : Optional[int]=3 , snake_case__ : Optional[Any]=None , ):
'''simple docstring'''
lowercase :Union[str, Any] = parent
lowercase :Optional[Any] = batch_size
lowercase :Dict = image_size
lowercase :Any = num_channels
lowercase :List[str] = embeddings_size
lowercase :Union[str, Any] = hidden_sizes
lowercase :Any = depths
lowercase :Dict = is_training
lowercase :Any = use_labels
lowercase :Any = hidden_act
lowercase :List[str] = num_labels
lowercase :List[Any] = scope
lowercase :int = len(snake_case__ )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :Optional[int] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
lowercase :Union[str, Any] = self.get_config()
return config, pixel_values
def __snake_case ( self : Dict ):
'''simple docstring'''
return RegNetConfig(
num_channels=self.num_channels , embeddings_size=self.embeddings_size , hidden_sizes=self.hidden_sizes , depths=self.depths , hidden_act=self.hidden_act , num_labels=self.num_labels , image_size=self.image_size , )
def __snake_case ( self : str , snake_case__ : Tuple , snake_case__ : List[Any] ):
'''simple docstring'''
lowercase :Any = FlaxRegNetModel(config=snake_case__ )
lowercase :str = model(snake_case__ )
# Output shape (b, c, h, w)
self.parent.assertEqual(
result.last_hidden_state.shape , (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2) , )
def __snake_case ( self : List[str] , snake_case__ : Optional[int] , snake_case__ : str ):
'''simple docstring'''
lowercase :Tuple = self.num_labels
lowercase :str = FlaxRegNetForImageClassification(config=snake_case__ )
lowercase :Union[str, Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :int = self.prepare_config_and_inputs()
lowercase , lowercase :Tuple = config_and_inputs
lowercase :Union[str, Any] = {'''pixel_values''': pixel_values}
return config, inputs_dict
@require_flax
class __magic_name__ ( __UpperCAmelCase , unittest.TestCase ):
__A : List[Any] = (FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()
__A : str = False
__A : Tuple = False
__A : Dict = False
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :Dict = FlaxRegNetModelTester(self )
lowercase :Tuple = ConfigTester(self , config_class=snake_case__ , has_text_modality=snake_case__ )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
self.create_and_test_config_common_properties()
self.config_tester.create_and_test_config_to_json_string()
self.config_tester.create_and_test_config_to_json_file()
self.config_tester.create_and_test_config_from_and_save_pretrained()
self.config_tester.create_and_test_config_with_num_labels()
self.config_tester.check_config_can_be_init_without_params()
self.config_tester.check_config_arguments_init()
def __snake_case ( self : List[Any] ):
'''simple docstring'''
return
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :Dict = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_image_classification(*snake_case__ )
@unittest.skip(reason='''RegNet does not use inputs_embeds''' )
def __snake_case ( self : Tuple ):
'''simple docstring'''
pass
@unittest.skip(reason='''RegNet does not support input and output embeddings''' )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
pass
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :Union[str, Any] = model_class(snake_case__ )
lowercase :int = inspect.signature(model.__call__ )
# signature.parameters is an OrderedDict => so arg_names order is deterministic
lowercase :Tuple = [*signature.parameters.keys()]
lowercase :Tuple = ['''pixel_values''']
self.assertListEqual(arg_names[:1] , snake_case__ )
def __snake_case ( self : Tuple ):
'''simple docstring'''
def check_hidden_states_output(snake_case__ : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[int] ):
lowercase :int = model_class(snake_case__ )
lowercase :Tuple = model(**self._prepare_for_class(snake_case__ , snake_case__ ) )
lowercase :Any = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
lowercase :Dict = self.model_tester.num_stages
self.assertEqual(len(snake_case__ ) , expected_num_stages + 1 )
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :Optional[int] = True
check_hidden_states_output(snake_case__ , snake_case__ , snake_case__ )
# check that output_hidden_states also work using config
del inputs_dict["output_hidden_states"]
lowercase :str = True
check_hidden_states_output(snake_case__ , snake_case__ , snake_case__ )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
with self.subTest(model_class.__name__ ):
lowercase :Optional[Any] = self._prepare_for_class(snake_case__ , snake_case__ )
lowercase :List[Any] = model_class(snake_case__ )
@jax.jit
def model_jitted(snake_case__ : str , **snake_case__ : Optional[int] ):
return model(pixel_values=snake_case__ , **snake_case__ )
with self.subTest('''JIT Enabled''' ):
lowercase :Optional[int] = model_jitted(**snake_case__ ).to_tuple()
with self.subTest('''JIT Disabled''' ):
with jax.disable_jit():
lowercase :Optional[int] = model_jitted(**snake_case__ ).to_tuple()
self.assertEqual(len(snake_case__ ) , len(snake_case__ ) )
for jitted_output, output in zip(snake_case__ , snake_case__ ):
self.assertEqual(jitted_output.shape , output.shape )
def lowerCamelCase () -> Tuple:
lowercase :Tuple = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
return image
@require_flax
class __magic_name__ ( unittest.TestCase ):
@cached_property
def __snake_case ( self : int ):
'''simple docstring'''
return AutoImageProcessor.from_pretrained('''facebook/regnet-y-040''' ) if is_vision_available() else None
@slow
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :int = FlaxRegNetForImageClassification.from_pretrained('''facebook/regnet-y-040''' )
lowercase :Optional[Any] = self.default_image_processor
lowercase :Dict = prepare_img()
lowercase :Any = image_processor(images=snake_case__ , return_tensors='''np''' )
lowercase :List[str] = model(**snake_case__ )
# verify the logits
lowercase :Any = (1, 1_0_0_0)
self.assertEqual(outputs.logits.shape , snake_case__ )
lowercase :List[Any] = jnp.array([-0.41_80, -1.50_51, -3.48_36] )
self.assertTrue(jnp.allclose(outputs.logits[0, :3] , snake_case__ , atol=1e-4 ) )
| 677 | 1 |
"""simple docstring"""
import datetime
import platform
import subprocess
from typing import Optional, Tuple, Union
import numpy as np
def lowerCamelCase (a_ :bytes , a_ :int) -> np.array:
lowercase :Optional[Any] = F"""{sampling_rate}"""
lowercase :int = '''1'''
lowercase :List[str] = '''f32le'''
lowercase :Any = [
'''ffmpeg''',
'''-i''',
'''pipe:0''',
'''-ac''',
ac,
'''-ar''',
ar,
'''-f''',
format_for_conversion,
'''-hide_banner''',
'''-loglevel''',
'''quiet''',
'''pipe:1''',
]
try:
with subprocess.Popen(a_ , stdin=subprocess.PIPE , stdout=subprocess.PIPE) as ffmpeg_process:
lowercase :Union[str, Any] = ffmpeg_process.communicate(a_)
except FileNotFoundError as error:
raise ValueError('''ffmpeg was not found but is required to load audio files from filename''') from error
lowercase :Dict = output_stream[0]
lowercase :Tuple = np.frombuffer(a_ , np.floataa)
if audio.shape[0] == 0:
raise ValueError('''Malformed soundfile''')
return audio
def lowerCamelCase (a_ :int , a_ :float , a_ :str = "f32le" , ) -> Dict:
lowercase :Tuple = F"""{sampling_rate}"""
lowercase :List[Any] = '''1'''
if format_for_conversion == "s16le":
lowercase :List[str] = 2
elif format_for_conversion == "f32le":
lowercase :Optional[int] = 4
else:
raise ValueError(F"""Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`""")
lowercase :Union[str, Any] = platform.system()
if system == "Linux":
lowercase :str = '''alsa'''
lowercase :List[str] = '''default'''
elif system == "Darwin":
lowercase :Optional[int] = '''avfoundation'''
lowercase :Any = ''':0'''
elif system == "Windows":
lowercase :Tuple = '''dshow'''
lowercase :Optional[int] = '''default'''
lowercase :int = [
'''ffmpeg''',
'''-f''',
format_,
'''-i''',
input_,
'''-ac''',
ac,
'''-ar''',
ar,
'''-f''',
format_for_conversion,
'''-fflags''',
'''nobuffer''',
'''-hide_banner''',
'''-loglevel''',
'''quiet''',
'''pipe:1''',
]
lowercase :Dict = int(round(sampling_rate * chunk_length_s)) * size_of_sample
lowercase :int = _ffmpeg_stream(a_ , a_)
for item in iterator:
yield item
def lowerCamelCase (a_ :int , a_ :float , a_ :Optional[int] = None , a_ :Optional[Union[Tuple[float, float], float]] = None , a_ :str = "f32le" , ) -> List[str]:
if stream_chunk_s is not None:
lowercase :Tuple = stream_chunk_s
else:
lowercase :Any = chunk_length_s
lowercase :str = ffmpeg_microphone(a_ , a_ , format_for_conversion=a_)
if format_for_conversion == "s16le":
lowercase :Optional[int] = np.intaa
lowercase :Optional[int] = 2
elif format_for_conversion == "f32le":
lowercase :Dict = np.floataa
lowercase :List[Any] = 4
else:
raise ValueError(F"""Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`""")
if stride_length_s is None:
lowercase :List[Any] = chunk_length_s / 6
lowercase :Any = int(round(sampling_rate * chunk_length_s)) * size_of_sample
if isinstance(a_ , (int, float)):
lowercase :str = [stride_length_s, stride_length_s]
lowercase :Any = int(round(sampling_rate * stride_length_s[0])) * size_of_sample
lowercase :str = int(round(sampling_rate * stride_length_s[1])) * size_of_sample
lowercase :str = datetime.datetime.now()
lowercase :Union[str, Any] = datetime.timedelta(seconds=a_)
for item in chunk_bytes_iter(a_ , a_ , stride=(stride_left, stride_right) , stream=a_):
# Put everything back in numpy scale
lowercase :List[str] = np.frombuffer(item['''raw'''] , dtype=a_)
lowercase :Optional[Any] = (
item['''stride'''][0] // size_of_sample,
item['''stride'''][1] // size_of_sample,
)
lowercase :Dict = sampling_rate
audio_time += delta
if datetime.datetime.now() > audio_time + 10 * delta:
# We're late !! SKIP
continue
yield item
def lowerCamelCase (a_ :Tuple , a_ :int , a_ :Tuple[int, int] , a_ :bool = False) -> int:
lowercase :Dict = b''''''
lowercase , lowercase :str = stride
if stride_left + stride_right >= chunk_len:
raise ValueError(
F"""Stride needs to be strictly smaller than chunk_len: ({stride_left}, {stride_right}) vs {chunk_len}""")
lowercase :Optional[int] = 0
for raw in iterator:
acc += raw
if stream and len(a_) < chunk_len:
lowercase :Any = (_stride_left, 0)
yield {"raw": acc[:chunk_len], "stride": stride, "partial": True}
else:
while len(a_) >= chunk_len:
# We are flushing the accumulator
lowercase :List[str] = (_stride_left, stride_right)
lowercase :Any = {'''raw''': acc[:chunk_len], '''stride''': stride}
if stream:
lowercase :Optional[Any] = False
yield item
lowercase :Optional[Any] = stride_left
lowercase :Union[str, Any] = acc[chunk_len - stride_left - stride_right :]
# Last chunk
if len(a_) > stride_left:
lowercase :Optional[Any] = {'''raw''': acc, '''stride''': (_stride_left, 0)}
if stream:
lowercase :str = False
yield item
def lowerCamelCase (a_ :Optional[Any] , a_ :int) -> Dict:
lowercase :str = 2**24 # 16Mo
try:
with subprocess.Popen(a_ , stdout=subprocess.PIPE , bufsize=a_) as ffmpeg_process:
while True:
lowercase :List[str] = ffmpeg_process.stdout.read(a_)
if raw == b"":
break
yield raw
except FileNotFoundError as error:
raise ValueError('''ffmpeg was not found but is required to stream audio files from filename''') from error
| 677 |
"""simple docstring"""
UpperCAmelCase = {
'''A''': ['''B''', '''C''', '''E'''],
'''B''': ['''A''', '''D''', '''E'''],
'''C''': ['''A''', '''F''', '''G'''],
'''D''': ['''B'''],
'''E''': ['''A''', '''B''', '''D'''],
'''F''': ['''C'''],
'''G''': ['''C'''],
}
def lowerCamelCase (a_ :dict , a_ :List[str] , a_ :Tuple) -> list[str]:
lowercase :str = set()
# keep track of all the paths to be checked
lowercase :Dict = [[start]]
# return path if start is goal
if start == goal:
return [start]
# keeps looping until all possible paths have been checked
while queue:
# pop the first path from the queue
lowercase :Optional[int] = queue.pop(0)
# get the last node from the path
lowercase :Any = path[-1]
if node not in explored:
lowercase :int = graph[node]
# go through all neighbour nodes, construct a new path and
# push it into the queue
for neighbour in neighbours:
lowercase :List[Any] = list(a_)
new_path.append(a_)
queue.append(a_)
# return path if neighbour is goal
if neighbour == goal:
return new_path
# mark node as explored
explored.add(a_)
# in case there's no path between the 2 nodes
return []
def lowerCamelCase (a_ :dict , a_ :List[Any] , a_ :List[Any]) -> int:
if not graph or start not in graph or target not in graph:
return -1
if start == target:
return 0
lowercase :List[str] = [start]
lowercase :Optional[Any] = set(a_)
# Keep tab on distances from `start` node.
lowercase :Union[str, Any] = {start: 0, target: -1}
while queue:
lowercase :Union[str, Any] = queue.pop(0)
if node == target:
lowercase :Any = (
dist[node] if dist[target] == -1 else min(dist[target] , dist[node])
)
for adjacent in graph[node]:
if adjacent not in visited:
visited.add(a_)
queue.append(a_)
lowercase :Dict = dist[node] + 1
return dist[target]
if __name__ == "__main__":
print(bfs_shortest_path(demo_graph, '''G''', '''D''')) # returns ['G', 'C', 'A', 'B', 'D']
print(bfs_shortest_path_distance(demo_graph, '''G''', '''D''')) # returns 4
| 677 | 1 |
"""simple docstring"""
import argparse
import json
import logging
import os
import sys
from unittest.mock import patch
from transformers.testing_utils import TestCasePlus, get_gpu_count, slow
UpperCAmelCase = [
os.path.join(os.path.dirname(__file__), dirname)
for dirname in [
'''text-classification''',
'''language-modeling''',
'''summarization''',
'''token-classification''',
'''question-answering''',
]
]
sys.path.extend(SRC_DIRS)
if SRC_DIRS is not None:
import run_clm_flax
import run_flax_glue
import run_flax_ner
import run_mlm_flax
import run_qa
import run_summarization_flax
import run_ta_mlm_flax
logging.basicConfig(level=logging.DEBUG)
UpperCAmelCase = logging.getLogger()
def lowerCamelCase () -> List[Any]:
lowercase :List[Any] = argparse.ArgumentParser()
parser.add_argument('''-f''')
lowercase :int = parser.parse_args()
return args.f
def lowerCamelCase (a_ :Optional[int] , a_ :Dict="eval") -> Optional[Any]:
lowercase :Optional[int] = os.path.join(a_ , F"""{split}_results.json""")
if os.path.exists(a_):
with open(a_ , '''r''') as f:
return json.load(a_)
raise ValueError(F"""can't find {path}""")
UpperCAmelCase = logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)
class __magic_name__ ( __UpperCAmelCase ):
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :Union[str, Any] = self.get_auto_remove_tmp_dir()
lowercase :Dict = f"""
run_glue.py
--model_name_or_path distilbert-base-uncased
--output_dir {tmp_dir}
--train_file ./tests/fixtures/tests_samples/MRPC/train.csv
--validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv
--per_device_train_batch_size=2
--per_device_eval_batch_size=1
--learning_rate=1e-4
--eval_steps=2
--warmup_steps=2
--seed=42
--max_seq_length=128
""".split()
with patch.object(snake_case__ , '''argv''' , snake_case__ ):
run_flax_glue.main()
lowercase :Any = get_results(snake_case__ )
self.assertGreaterEqual(result['''eval_accuracy'''] , 0.75 )
@slow
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :Optional[int] = self.get_auto_remove_tmp_dir()
lowercase :Any = f"""
run_clm_flax.py
--model_name_or_path distilgpt2
--train_file ./tests/fixtures/sample_text.txt
--validation_file ./tests/fixtures/sample_text.txt
--do_train
--do_eval
--block_size 128
--per_device_train_batch_size 4
--per_device_eval_batch_size 4
--num_train_epochs 2
--logging_steps 2 --eval_steps 2
--output_dir {tmp_dir}
--overwrite_output_dir
""".split()
with patch.object(snake_case__ , '''argv''' , snake_case__ ):
run_clm_flax.main()
lowercase :Optional[Any] = get_results(snake_case__ )
self.assertLess(result['''eval_perplexity'''] , 1_0_0 )
@slow
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :str = self.get_auto_remove_tmp_dir()
lowercase :Optional[int] = f"""
run_summarization.py
--model_name_or_path t5-small
--train_file tests/fixtures/tests_samples/xsum/sample.json
--validation_file tests/fixtures/tests_samples/xsum/sample.json
--test_file tests/fixtures/tests_samples/xsum/sample.json
--output_dir {tmp_dir}
--overwrite_output_dir
--num_train_epochs=3
--warmup_steps=8
--do_train
--do_eval
--do_predict
--learning_rate=2e-4
--per_device_train_batch_size=2
--per_device_eval_batch_size=1
--predict_with_generate
""".split()
with patch.object(snake_case__ , '''argv''' , snake_case__ ):
run_summarization_flax.main()
lowercase :Tuple = get_results(snake_case__ , split='''test''' )
self.assertGreaterEqual(result['''test_rouge1'''] , 1_0 )
self.assertGreaterEqual(result['''test_rouge2'''] , 2 )
self.assertGreaterEqual(result['''test_rougeL'''] , 7 )
self.assertGreaterEqual(result['''test_rougeLsum'''] , 7 )
@slow
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :Optional[int] = self.get_auto_remove_tmp_dir()
lowercase :Any = f"""
run_mlm.py
--model_name_or_path distilroberta-base
--train_file ./tests/fixtures/sample_text.txt
--validation_file ./tests/fixtures/sample_text.txt
--output_dir {tmp_dir}
--overwrite_output_dir
--max_seq_length 128
--per_device_train_batch_size 4
--per_device_eval_batch_size 4
--logging_steps 2 --eval_steps 2
--do_train
--do_eval
--num_train_epochs=1
""".split()
with patch.object(snake_case__ , '''argv''' , snake_case__ ):
run_mlm_flax.main()
lowercase :List[Any] = get_results(snake_case__ )
self.assertLess(result['''eval_perplexity'''] , 4_2 )
@slow
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[str] = self.get_auto_remove_tmp_dir()
lowercase :Dict = f"""
run_t5_mlm_flax.py
--model_name_or_path t5-small
--train_file ./tests/fixtures/sample_text.txt
--validation_file ./tests/fixtures/sample_text.txt
--do_train
--do_eval
--max_seq_length 128
--per_device_train_batch_size 4
--per_device_eval_batch_size 4
--num_train_epochs 2
--logging_steps 2 --eval_steps 2
--output_dir {tmp_dir}
--overwrite_output_dir
""".split()
with patch.object(snake_case__ , '''argv''' , snake_case__ ):
run_ta_mlm_flax.main()
lowercase :Tuple = get_results(snake_case__ )
self.assertGreaterEqual(result['''eval_accuracy'''] , 0.42 )
@slow
def __snake_case ( self : int ):
'''simple docstring'''
lowercase :Any = 7 if get_gpu_count() > 1 else 2
lowercase :Dict = self.get_auto_remove_tmp_dir()
lowercase :int = f"""
run_flax_ner.py
--model_name_or_path bert-base-uncased
--train_file tests/fixtures/tests_samples/conll/sample.json
--validation_file tests/fixtures/tests_samples/conll/sample.json
--output_dir {tmp_dir}
--overwrite_output_dir
--do_train
--do_eval
--warmup_steps=2
--learning_rate=2e-4
--logging_steps 2 --eval_steps 2
--per_device_train_batch_size=2
--per_device_eval_batch_size=2
--num_train_epochs={epochs}
--seed 7
""".split()
with patch.object(snake_case__ , '''argv''' , snake_case__ ):
run_flax_ner.main()
lowercase :Tuple = get_results(snake_case__ )
self.assertGreaterEqual(result['''eval_accuracy'''] , 0.75 )
self.assertGreaterEqual(result['''eval_f1'''] , 0.3 )
@slow
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :int = self.get_auto_remove_tmp_dir()
lowercase :Optional[Any] = f"""
run_qa.py
--model_name_or_path bert-base-uncased
--version_2_with_negative
--train_file tests/fixtures/tests_samples/SQUAD/sample.json
--validation_file tests/fixtures/tests_samples/SQUAD/sample.json
--output_dir {tmp_dir}
--overwrite_output_dir
--num_train_epochs=3
--warmup_steps=2
--do_train
--do_eval
--logging_steps 2 --eval_steps 2
--learning_rate=2e-4
--per_device_train_batch_size=2
--per_device_eval_batch_size=1
""".split()
with patch.object(snake_case__ , '''argv''' , snake_case__ ):
run_qa.main()
lowercase :List[str] = get_results(snake_case__ )
self.assertGreaterEqual(result['''eval_f1'''] , 3_0 )
self.assertGreaterEqual(result['''eval_exact'''] , 3_0 )
| 677 |
"""simple docstring"""
import logging
import os
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from tempfile import TemporaryDirectory
from typing import List, Optional
import faiss
import torch
from datasets import Features, Sequence, Value, load_dataset
from transformers import DPRContextEncoder, DPRContextEncoderTokenizerFast, HfArgumentParser
UpperCAmelCase = logging.getLogger(__name__)
torch.set_grad_enabled(False)
UpperCAmelCase = '''cuda''' if torch.cuda.is_available() else '''cpu'''
def lowerCamelCase (a_ :str , a_ :List[str]=100 , a_ :Optional[Any]=" ") -> List[str]:
lowercase :str = text.split(a_)
return [character.join(text[i : i + n]).strip() for i in range(0 , len(a_) , a_)]
def lowerCamelCase (a_ :dict) -> dict:
lowercase , lowercase :str = [], []
for title, text in zip(documents['''title'''] , documents['''text''']):
if text is not None:
for passage in split_text(a_):
titles.append(title if title is not None else '''''')
texts.append(a_)
return {"title": titles, "text": texts}
def lowerCamelCase (a_ :dict , a_ :DPRContextEncoder , a_ :DPRContextEncoderTokenizerFast) -> dict:
lowercase :Tuple = ctx_tokenizer(
documents['''title'''] , documents['''text'''] , truncation=a_ , padding='''longest''' , return_tensors='''pt''')['''input_ids''']
lowercase :Optional[Any] = ctx_encoder(input_ids.to(device=a_) , return_dict=a_).pooler_output
return {"embeddings": embeddings.detach().cpu().numpy()}
def lowerCamelCase (a_ :"RagExampleArguments" , a_ :"ProcessingArguments" , a_ :"IndexHnswArguments" , ) -> Any:
######################################
logger.info('''Step 1 - Create the dataset''')
######################################
# The dataset needed for RAG must have three columns:
# - title (string): title of the document
# - text (string): text of a passage of the document
# - embeddings (array of dimension d): DPR representation of the passage
# Let's say you have documents in tab-separated csv files with columns "title" and "text"
assert os.path.isfile(rag_example_args.csv_path), "Please provide a valid path to a csv file"
# You can load a Dataset object this way
lowercase :List[Any] = load_dataset(
'''csv''' , data_files=[rag_example_args.csv_path] , split='''train''' , delimiter='''\t''' , column_names=['''title''', '''text'''])
# More info about loading csv files in the documentation: https://huggingface.co/docs/datasets/loading_datasets.html?highlight=csv#csv-files
# Then split the documents into passages of 100 words
lowercase :Optional[Any] = dataset.map(a_ , batched=a_ , num_proc=processing_args.num_proc)
# And compute the embeddings
lowercase :str = DPRContextEncoder.from_pretrained(rag_example_args.dpr_ctx_encoder_model_name).to(device=a_)
lowercase :Dict = DPRContextEncoderTokenizerFast.from_pretrained(rag_example_args.dpr_ctx_encoder_model_name)
lowercase :str = Features(
{'''text''': Value('''string'''), '''title''': Value('''string'''), '''embeddings''': Sequence(Value('''float32'''))}) # optional, save as float32 instead of float64 to save space
lowercase :Optional[Any] = dataset.map(
partial(a_ , ctx_encoder=a_ , ctx_tokenizer=a_) , batched=a_ , batch_size=processing_args.batch_size , features=a_ , )
# And finally save your dataset
lowercase :str = os.path.join(rag_example_args.output_dir , '''my_knowledge_dataset''')
dataset.save_to_disk(a_)
# from datasets import load_from_disk
# dataset = load_from_disk(passages_path) # to reload the dataset
######################################
logger.info('''Step 2 - Index the dataset''')
######################################
# Let's use the Faiss implementation of HNSW for fast approximate nearest neighbor search
lowercase :str = faiss.IndexHNSWFlat(index_hnsw_args.d , index_hnsw_args.m , faiss.METRIC_INNER_PRODUCT)
dataset.add_faiss_index('''embeddings''' , custom_index=a_)
# And save the index
lowercase :Optional[Any] = os.path.join(rag_example_args.output_dir , '''my_knowledge_dataset_hnsw_index.faiss''')
dataset.get_index('''embeddings''').save(a_)
# dataset.load_faiss_index("embeddings", index_path) # to reload the index
@dataclass
class __magic_name__ :
__A : str = field(
default=str(Path(__UpperCAmelCase ).parent / "test_run" / "dummy-kb" / "my_knowledge_dataset.csv" ) , metadata={"help": "Path to a tab-separated csv file with columns 'title' and 'text'"} , )
__A : Optional[str] = field(
default=__UpperCAmelCase , metadata={"help": "Question that is passed as input to RAG. Default is 'What does Moses' rod turn into ?'."} , )
__A : str = field(
default="facebook/rag-sequence-nq" , metadata={"help": "The RAG model to use. Either 'facebook/rag-sequence-nq' or 'facebook/rag-token-nq'"} , )
__A : str = field(
default="facebook/dpr-ctx_encoder-multiset-base" , metadata={
"help": (
"The DPR context encoder model to use. Either 'facebook/dpr-ctx_encoder-single-nq-base' or"
" 'facebook/dpr-ctx_encoder-multiset-base'"
)
} , )
__A : Optional[str] = field(
default=str(Path(__UpperCAmelCase ).parent / "test_run" / "dummy-kb" ) , metadata={"help": "Path to a directory where the dataset passages and the index will be saved"} , )
@dataclass
class __magic_name__ :
__A : Optional[int] = field(
default=__UpperCAmelCase , metadata={
"help": "The number of processes to use to split the documents into passages. Default is single process."
} , )
__A : int = field(
default=16 , metadata={
"help": "The batch size to use when computing the passages embeddings using the DPR context encoder."
} , )
@dataclass
class __magic_name__ :
__A : int = field(
default=7_68 , metadata={"help": "The dimension of the embeddings to pass to the HNSW Faiss index."} , )
__A : int = field(
default=1_28 , metadata={
"help": (
"The number of bi-directional links created for every new element during the HNSW index construction."
)
} , )
if __name__ == "__main__":
logging.basicConfig(level=logging.WARNING)
logger.setLevel(logging.INFO)
UpperCAmelCase = HfArgumentParser((RagExampleArguments, ProcessingArguments, IndexHnswArguments))
UpperCAmelCase , UpperCAmelCase , UpperCAmelCase = parser.parse_args_into_dataclasses()
with TemporaryDirectory() as tmp_dir:
UpperCAmelCase = rag_example_args.output_dir or tmp_dir
main(rag_example_args, processing_args, index_hnsw_args)
| 677 | 1 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tf_available,
is_tokenizers_available,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_electra''': ['''ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ElectraConfig''', '''ElectraOnnxConfig'''],
'''tokenization_electra''': ['''ElectraTokenizer'''],
}
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''ElectraTokenizerFast''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''ElectraForCausalLM''',
'''ElectraForMaskedLM''',
'''ElectraForMultipleChoice''',
'''ElectraForPreTraining''',
'''ElectraForQuestionAnswering''',
'''ElectraForSequenceClassification''',
'''ElectraForTokenClassification''',
'''ElectraModel''',
'''ElectraPreTrainedModel''',
'''load_tf_weights_in_electra''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''TFElectraForMaskedLM''',
'''TFElectraForMultipleChoice''',
'''TFElectraForPreTraining''',
'''TFElectraForQuestionAnswering''',
'''TFElectraForSequenceClassification''',
'''TFElectraForTokenClassification''',
'''TFElectraModel''',
'''TFElectraPreTrainedModel''',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxElectraForCausalLM''',
'''FlaxElectraForMaskedLM''',
'''FlaxElectraForMultipleChoice''',
'''FlaxElectraForPreTraining''',
'''FlaxElectraForQuestionAnswering''',
'''FlaxElectraForSequenceClassification''',
'''FlaxElectraForTokenClassification''',
'''FlaxElectraModel''',
'''FlaxElectraPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
from .tokenization_electra import ElectraTokenizer
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_electra_fast import ElectraTokenizerFast
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_electra import (
ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
ElectraForCausalLM,
ElectraForMaskedLM,
ElectraForMultipleChoice,
ElectraForPreTraining,
ElectraForQuestionAnswering,
ElectraForSequenceClassification,
ElectraForTokenClassification,
ElectraModel,
ElectraPreTrainedModel,
load_tf_weights_in_electra,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_electra import (
TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
TFElectraForMaskedLM,
TFElectraForMultipleChoice,
TFElectraForPreTraining,
TFElectraForQuestionAnswering,
TFElectraForSequenceClassification,
TFElectraForTokenClassification,
TFElectraModel,
TFElectraPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_electra import (
FlaxElectraForCausalLM,
FlaxElectraForMaskedLM,
FlaxElectraForMultipleChoice,
FlaxElectraForPreTraining,
FlaxElectraForQuestionAnswering,
FlaxElectraForSequenceClassification,
FlaxElectraForTokenClassification,
FlaxElectraModel,
FlaxElectraPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available
UpperCAmelCase = {
'''configuration_longt5''': ['''LONGT5_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''LongT5Config''', '''LongT5OnnxConfig'''],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''LONGT5_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''LongT5EncoderModel''',
'''LongT5ForConditionalGeneration''',
'''LongT5Model''',
'''LongT5PreTrainedModel''',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxLongT5ForConditionalGeneration''',
'''FlaxLongT5Model''',
'''FlaxLongT5PreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_longta import LONGT5_PRETRAINED_CONFIG_ARCHIVE_MAP, LongTaConfig, LongTaOnnxConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_longta import (
LONGT5_PRETRAINED_MODEL_ARCHIVE_LIST,
LongTaEncoderModel,
LongTaForConditionalGeneration,
LongTaModel,
LongTaPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_longta import (
FlaxLongTaForConditionalGeneration,
FlaxLongTaModel,
FlaxLongTaPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
import math
def lowerCamelCase (a_ :list , a_ :int) -> int:
lowercase :int = len(a_)
lowercase :Union[str, Any] = int(math.floor(math.sqrt(a_)))
lowercase :List[Any] = 0
while arr[min(a_ , a_) - 1] < x:
lowercase :List[Any] = step
step += int(math.floor(math.sqrt(a_)))
if prev >= n:
return -1
while arr[prev] < x:
lowercase :Optional[Any] = prev + 1
if prev == min(a_ , a_):
return -1
if arr[prev] == x:
return prev
return -1
if __name__ == "__main__":
UpperCAmelCase = input('''Enter numbers separated by a comma:\n''').strip()
UpperCAmelCase = [int(item) for item in user_input.split(''',''')]
UpperCAmelCase = int(input('''Enter the number to be searched:\n'''))
UpperCAmelCase = jump_search(arr, x)
if res == -1:
print('''Number not found!''')
else:
print(F"""Number {x} is at index {res}""")
| 677 |
"""simple docstring"""
import uuid
from typing import Any, Dict, List, Optional, Union
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline
if is_tf_available():
import tensorflow as tf
if is_torch_available():
import torch
UpperCAmelCase = logging.get_logger(__name__)
class __magic_name__ :
def __init__( self : Tuple , snake_case__ : str = None , snake_case__ : uuid.UUID = None , snake_case__ : Optional[int]=None , snake_case__ : Tuple=None ):
'''simple docstring'''
if not conversation_id:
lowercase :List[Any] = uuid.uuida()
if past_user_inputs is None:
lowercase :Union[str, Any] = []
if generated_responses is None:
lowercase :List[str] = []
lowercase :uuid.UUID = conversation_id
lowercase :List[str] = past_user_inputs
lowercase :List[str] = generated_responses
lowercase :Optional[str] = text
def __eq__( self : Optional[Any] , snake_case__ : str ):
'''simple docstring'''
if not isinstance(snake_case__ , snake_case__ ):
return False
if self.uuid == other.uuid:
return True
return (
self.new_user_input == other.new_user_input
and self.past_user_inputs == other.past_user_inputs
and self.generated_responses == other.generated_responses
)
def __snake_case ( self : Optional[int] , snake_case__ : str , snake_case__ : bool = False ):
'''simple docstring'''
if self.new_user_input:
if overwrite:
logger.warning(
f"""User input added while unprocessed input was existing: \"{self.new_user_input}\" was overwritten """
f"""with: \"{text}\".""" )
lowercase :List[str] = text
else:
logger.warning(
f"""User input added while unprocessed input was existing: \"{self.new_user_input}\" new input """
f"""ignored: \"{text}\". Set `overwrite` to True to overwrite unprocessed user input""" )
else:
lowercase :Optional[int] = text
def __snake_case ( self : Any ):
'''simple docstring'''
if self.new_user_input:
self.past_user_inputs.append(self.new_user_input )
lowercase :Tuple = None
def __snake_case ( self : Tuple , snake_case__ : str ):
'''simple docstring'''
self.generated_responses.append(snake_case__ )
def __snake_case ( self : Tuple ):
'''simple docstring'''
for user_input, generated_response in zip(self.past_user_inputs , self.generated_responses ):
yield True, user_input
yield False, generated_response
if self.new_user_input:
yield True, self.new_user_input
def __repr__( self : Dict ):
'''simple docstring'''
lowercase :int = f"""Conversation id: {self.uuid} \n"""
for is_user, text in self.iter_texts():
lowercase :Dict = '''user''' if is_user else '''bot'''
output += f"""{name} >> {text} \n"""
return output
@add_end_docstrings(
__UpperCAmelCase , R"\n min_length_for_response (`int`, *optional*, defaults to 32):\n The minimum length (in number of tokens) for a response.\n minimum_tokens (`int`, *optional*, defaults to 10):\n The minimum length of tokens to leave for a response.\n " , )
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Optional[Any] , *snake_case__ : Optional[Any] , **snake_case__ : List[Any] ):
'''simple docstring'''
super().__init__(*snake_case__ , **snake_case__ )
if self.tokenizer.pad_token_id is None:
lowercase :Any = self.tokenizer.eos_token
def __snake_case ( self : List[Any] , snake_case__ : Optional[int]=None , snake_case__ : Union[str, Any]=None , snake_case__ : List[str]=None , **snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase :str = {}
lowercase :List[str] = {}
lowercase :Tuple = {}
if min_length_for_response is not None:
lowercase :Dict = min_length_for_response
if minimum_tokens is not None:
lowercase :Union[str, Any] = minimum_tokens
if "max_length" in generate_kwargs:
lowercase :List[Any] = generate_kwargs['''max_length''']
# self.max_length = generate_kwargs.get("max_length", self.model.config.max_length)
if clean_up_tokenization_spaces is not None:
lowercase :Dict = clean_up_tokenization_spaces
if generate_kwargs:
forward_params.update(snake_case__ )
return preprocess_params, forward_params, postprocess_params
def __call__( self : List[Any] , snake_case__ : Union[Conversation, List[Conversation]] , snake_case__ : int=0 , **snake_case__ : int ):
'''simple docstring'''
lowercase :int = super().__call__(snake_case__ , num_workers=snake_case__ , **snake_case__ )
if isinstance(snake_case__ , snake_case__ ) and len(snake_case__ ) == 1:
return outputs[0]
return outputs
def __snake_case ( self : List[Any] , snake_case__ : Conversation , snake_case__ : Any=3_2 ):
'''simple docstring'''
if not isinstance(snake_case__ , snake_case__ ):
raise ValueError('''ConversationalPipeline, expects Conversation as inputs''' )
if conversation.new_user_input is None:
raise ValueError(
f"""Conversation with UUID {type(conversation.uuid )} does not contain new user input to process. """
'''Add user inputs with the conversation\'s `add_user_input` method''' )
if hasattr(self.tokenizer , '''_build_conversation_input_ids''' ):
lowercase :List[str] = self.tokenizer._build_conversation_input_ids(snake_case__ )
else:
# If the tokenizer cannot handle conversations, we default to only the old version
lowercase :List[str] = self._legacy_parse_and_tokenize(snake_case__ )
if self.framework == "pt":
lowercase :int = torch.LongTensor([input_ids] )
elif self.framework == "tf":
lowercase :Any = tf.constant([input_ids] )
return {"input_ids": input_ids, "conversation": conversation}
def __snake_case ( self : int , snake_case__ : Union[str, Any] , snake_case__ : Any=1_0 , **snake_case__ : int ):
'''simple docstring'''
lowercase :Dict = generate_kwargs.get('''max_length''' , self.model.config.max_length )
lowercase :Optional[Any] = model_inputs['''input_ids'''].shape[1]
if max_length - minimum_tokens < n:
logger.warning(f"""Conversation input is to long ({n}), trimming it to ({max_length} - {minimum_tokens})""" )
lowercase :int = max_length - minimum_tokens
lowercase :int = model_inputs['''input_ids'''][:, -trim:]
if "attention_mask" in model_inputs:
lowercase :int = model_inputs['''attention_mask'''][:, -trim:]
lowercase :int = model_inputs.pop('''conversation''' )
lowercase :Union[str, Any] = max_length
lowercase :Dict = self.model.generate(**snake_case__ , **snake_case__ )
if self.model.config.is_encoder_decoder:
lowercase :List[Any] = 1
else:
lowercase :Optional[Any] = n
return {"output_ids": output_ids[:, start_position:], "conversation": conversation}
def __snake_case ( self : Optional[int] , snake_case__ : List[Any] , snake_case__ : Optional[Any]=True ):
'''simple docstring'''
lowercase :Dict = model_outputs['''output_ids''']
lowercase :Dict = self.tokenizer.decode(
output_ids[0] , skip_special_tokens=snake_case__ , clean_up_tokenization_spaces=snake_case__ , )
lowercase :Optional[int] = model_outputs['''conversation''']
conversation.mark_processed()
conversation.append_response(snake_case__ )
return conversation
def __snake_case ( self : List[Any] , snake_case__ : Conversation ):
'''simple docstring'''
lowercase :str = self.tokenizer.eos_token_id
lowercase :List[Any] = []
for is_user, text in conversation.iter_texts():
if eos_token_id is not None:
input_ids.extend(self.tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ ) + [eos_token_id] )
else:
input_ids.extend(self.tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ ) )
if len(snake_case__ ) > self.tokenizer.model_max_length:
lowercase :List[Any] = input_ids[-self.tokenizer.model_max_length :]
return input_ids
| 677 | 1 |
"""simple docstring"""
from dataclasses import dataclass, field
from typing import Optional
from transformers import AutoConfig, AutoImageProcessor, AutoTokenizer, FlaxVisionEncoderDecoderModel, HfArgumentParser
@dataclass
class __magic_name__ :
__A : str = field(
metadata={"help": "The output directory where the model will be written."} , )
__A : str = field(
metadata={
"help": (
"The encoder model checkpoint for weights initialization."
"Don't set if you want to train an encoder model from scratch."
)
} , )
__A : str = field(
metadata={
"help": (
"The decoder model checkpoint for weights initialization."
"Don't set if you want to train a decoder model from scratch."
)
} , )
__A : Optional[str] = field(
default=__UpperCAmelCase , metadata={"help": "Pretrained encoder config name or path if not the same as encoder_model_name"} )
__A : Optional[str] = field(
default=__UpperCAmelCase , metadata={"help": "Pretrained decoder config name or path if not the same as decoder_model_name"} )
def lowerCamelCase () -> Tuple:
lowercase :Tuple = HfArgumentParser((ModelArguments,))
((lowercase) , ) :Any = parser.parse_args_into_dataclasses()
# Load pretrained model and tokenizer
# Use explicit specified encoder config
if model_args.encoder_config_name:
lowercase :Tuple = AutoConfig.from_pretrained(model_args.encoder_config_name)
# Use pretrained encoder model's config
else:
lowercase :List[Any] = AutoConfig.from_pretrained(model_args.encoder_model_name_or_path)
# Use explicit specified decoder config
if model_args.decoder_config_name:
lowercase :List[Any] = AutoConfig.from_pretrained(model_args.decoder_config_name)
# Use pretrained decoder model's config
else:
lowercase :Optional[int] = AutoConfig.from_pretrained(model_args.decoder_model_name_or_path)
# necessary for `from_encoder_decoder_pretrained` when `decoder_config` is passed
lowercase :Optional[Any] = True
lowercase :Dict = True
lowercase :Union[str, Any] = FlaxVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
encoder_pretrained_model_name_or_path=model_args.encoder_model_name_or_path , decoder_pretrained_model_name_or_path=model_args.decoder_model_name_or_path , encoder_config=a_ , decoder_config=a_ , )
# GPT2 only has bos/eos tokens but not decoder_start/pad tokens
lowercase :Dict = decoder_config.decoder_start_token_id
lowercase :Union[str, Any] = decoder_config.pad_token_id
if decoder_start_token_id is None:
lowercase :List[Any] = decoder_config.bos_token_id
if pad_token_id is None:
lowercase :Union[str, Any] = decoder_config.eos_token_id
# This is necessary to make Flax's generate() work
lowercase :Dict = decoder_config.eos_token_id
lowercase :Optional[Any] = decoder_start_token_id
lowercase :str = pad_token_id
lowercase :Optional[Any] = AutoImageProcessor.from_pretrained(model_args.encoder_model_name_or_path)
lowercase :str = AutoTokenizer.from_pretrained(model_args.decoder_model_name_or_path)
lowercase :int = tokenizer.convert_ids_to_tokens(model.config.pad_token_id)
model.save_pretrained(model_args.output_dir)
image_processor.save_pretrained(model_args.output_dir)
tokenizer.save_pretrained(model_args.output_dir)
if __name__ == "__main__":
main()
| 677 |
"""simple docstring"""
def lowerCamelCase (a_ :int = 100) -> int:
lowercase :Union[str, Any] = set()
lowercase :List[Any] = 0
lowercase :Dict = n + 1 # maximum limit
for a in range(2 , a_):
for b in range(2 , a_):
lowercase :Tuple = a**b # calculates the current power
collect_powers.add(a_) # adds the result to the set
return len(a_)
if __name__ == "__main__":
print('''Number of terms ''', solution(int(str(input()).strip())))
| 677 | 1 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tf_available,
is_tokenizers_available,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_blenderbot''': [
'''BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''BlenderbotConfig''',
'''BlenderbotOnnxConfig''',
],
'''tokenization_blenderbot''': ['''BlenderbotTokenizer'''],
}
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''BlenderbotTokenizerFast''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''BlenderbotForCausalLM''',
'''BlenderbotForConditionalGeneration''',
'''BlenderbotModel''',
'''BlenderbotPreTrainedModel''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TFBlenderbotForConditionalGeneration''',
'''TFBlenderbotModel''',
'''TFBlenderbotPreTrainedModel''',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxBlenderbotForConditionalGeneration''',
'''FlaxBlenderbotModel''',
'''FlaxBlenderbotPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_blenderbot import (
BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP,
BlenderbotConfig,
BlenderbotOnnxConfig,
)
from .tokenization_blenderbot import BlenderbotTokenizer
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_blenderbot_fast import BlenderbotTokenizerFast
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_blenderbot import (
BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST,
BlenderbotForCausalLM,
BlenderbotForConditionalGeneration,
BlenderbotModel,
BlenderbotPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_blenderbot import (
TFBlenderbotForConditionalGeneration,
TFBlenderbotModel,
TFBlenderbotPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_blenderbot import (
FlaxBlenderbotForConditionalGeneration,
FlaxBlenderbotModel,
FlaxBlenderbotPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 |
"""simple docstring"""
from typing import Callable, Optional, Union
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''microsoft/xprophetnet-large-wiki100-cased''': (
'''https://huggingface.co/microsoft/xprophetnet-large-wiki100-cased/resolve/main/config.json'''
),
}
class __magic_name__ ( __UpperCAmelCase ):
__A : Optional[Any] = "xlm-prophetnet"
__A : List[str] = ["past_key_values"]
__A : int = {
"num_attention_heads": "num_encoder_attention_heads",
}
def __init__( self : Any , snake_case__ : Optional[float] = 0.1 , snake_case__ : Optional[Union[str, Callable]] = "gelu" , snake_case__ : Optional[int] = 3_0_5_2_2 , snake_case__ : Optional[int] = 1_0_2_4 , snake_case__ : Optional[int] = 4_0_9_6 , snake_case__ : Optional[int] = 1_2 , snake_case__ : Optional[int] = 1_6 , snake_case__ : Optional[int] = 4_0_9_6 , snake_case__ : Optional[int] = 1_2 , snake_case__ : Optional[int] = 1_6 , snake_case__ : Optional[float] = 0.1 , snake_case__ : Optional[float] = 0.1 , snake_case__ : Optional[int] = 5_1_2 , snake_case__ : Optional[float] = 0.02 , snake_case__ : Optional[bool] = True , snake_case__ : Optional[bool] = True , snake_case__ : Optional[int] = 0 , snake_case__ : Optional[int] = 2 , snake_case__ : Optional[int] = 3_2 , snake_case__ : Optional[int] = 1_2_8 , snake_case__ : Optional[bool] = False , snake_case__ : Optional[float] = 0.0 , snake_case__ : Optional[bool] = True , snake_case__ : Optional[int] = 0 , snake_case__ : Optional[int] = 1 , snake_case__ : Optional[int] = 2 , **snake_case__ : List[str] , ):
'''simple docstring'''
lowercase :Tuple = vocab_size
lowercase :Optional[int] = hidden_size
lowercase :Optional[int] = encoder_ffn_dim
lowercase :Optional[int] = num_encoder_layers
lowercase :Dict = num_encoder_attention_heads
lowercase :List[str] = decoder_ffn_dim
lowercase :Dict = num_decoder_layers
lowercase :List[Any] = num_decoder_attention_heads
lowercase :Optional[int] = max_position_embeddings
lowercase :Tuple = init_std # Normal(0, this parameter)
lowercase :int = activation_function
# parameters for xlmprophetnet
lowercase :Dict = ngram
lowercase :Optional[Any] = num_buckets
lowercase :Dict = relative_max_distance
lowercase :List[Any] = disable_ngram_loss
lowercase :Optional[Any] = eps
# 3 Types of Dropout
lowercase :Any = attention_dropout
lowercase :List[str] = activation_dropout
lowercase :List[str] = dropout
lowercase :List[str] = use_cache
super().__init__(
pad_token_id=snake_case__ , bos_token_id=snake_case__ , eos_token_id=snake_case__ , is_encoder_decoder=snake_case__ , add_cross_attention=snake_case__ , decoder_start_token_id=snake_case__ , **snake_case__ , )
@property
def __snake_case ( self : Any ):
'''simple docstring'''
return self.num_encoder_layers + self.num_decoder_layers
@num_hidden_layers.setter
def __snake_case ( self : Optional[Any] , snake_case__ : Optional[Any] ):
'''simple docstring'''
raise NotImplementedError(
'''This model does not support the setting of `num_hidden_layers`. Please set `num_encoder_layers` and'''
''' `num_decoder_layers`.''' )
| 677 | 1 |
"""simple docstring"""
import inspect
import unittest
from transformers import ConvNextVaConfig
from transformers.models.auto import get_values
from transformers.models.auto.modeling_auto import MODEL_FOR_BACKBONE_MAPPING_NAMES, MODEL_MAPPING_NAMES
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin
if is_torch_available():
import torch
from transformers import ConvNextVaBackbone, ConvNextVaForImageClassification, ConvNextVaModel
from transformers.models.convnextva.modeling_convnextva import CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST
if is_vision_available():
from PIL import Image
from transformers import AutoImageProcessor
class __magic_name__ :
def __init__( self : int , snake_case__ : List[Any] , snake_case__ : List[Any]=1_3 , snake_case__ : Union[str, Any]=3_2 , snake_case__ : List[Any]=3 , snake_case__ : Union[str, Any]=4 , snake_case__ : List[Any]=[1_0, 2_0, 3_0, 4_0] , snake_case__ : Dict=[2, 2, 3, 2] , snake_case__ : Tuple=True , snake_case__ : Union[str, Any]=True , snake_case__ : Union[str, Any]=3_7 , snake_case__ : Optional[Any]="gelu" , snake_case__ : Tuple=1_0 , snake_case__ : str=0.02 , snake_case__ : Optional[Any]=["stage2", "stage3", "stage4"] , snake_case__ : Any=[2, 3, 4] , snake_case__ : Union[str, Any]=None , ):
'''simple docstring'''
lowercase :List[str] = parent
lowercase :int = batch_size
lowercase :int = image_size
lowercase :List[Any] = num_channels
lowercase :str = num_stages
lowercase :int = hidden_sizes
lowercase :Tuple = depths
lowercase :List[str] = is_training
lowercase :Union[str, Any] = use_labels
lowercase :List[str] = intermediate_size
lowercase :List[Any] = hidden_act
lowercase :Tuple = num_labels
lowercase :List[str] = initializer_range
lowercase :List[Any] = out_features
lowercase :List[str] = out_indices
lowercase :List[str] = scope
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase :Any = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
lowercase :Optional[int] = None
if self.use_labels:
lowercase :List[str] = ids_tensor([self.batch_size] , self.num_labels )
lowercase :Union[str, Any] = self.get_config()
return config, pixel_values, labels
def __snake_case ( self : Tuple ):
'''simple docstring'''
return ConvNextVaConfig(
num_channels=self.num_channels , hidden_sizes=self.hidden_sizes , depths=self.depths , num_stages=self.num_stages , hidden_act=self.hidden_act , is_decoder=snake_case__ , initializer_range=self.initializer_range , out_features=self.out_features , out_indices=self.out_indices , num_labels=self.num_labels , )
def __snake_case ( self : Optional[Any] , snake_case__ : str , snake_case__ : int , snake_case__ : List[str] ):
'''simple docstring'''
lowercase :int = ConvNextVaModel(config=snake_case__ )
model.to(snake_case__ )
model.eval()
lowercase :Any = model(snake_case__ )
# expected last hidden states: B, C, H // 32, W // 32
self.parent.assertEqual(
result.last_hidden_state.shape , (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2) , )
def __snake_case ( self : Optional[Any] , snake_case__ : str , snake_case__ : str , snake_case__ : List[Any] ):
'''simple docstring'''
lowercase :Any = ConvNextVaForImageClassification(snake_case__ )
model.to(snake_case__ )
model.eval()
lowercase :Dict = model(snake_case__ , labels=snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def __snake_case ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : Union[str, Any] , snake_case__ : int ):
'''simple docstring'''
lowercase :List[Any] = ConvNextVaBackbone(config=snake_case__ )
model.to(snake_case__ )
model.eval()
lowercase :Any = model(snake_case__ )
# verify hidden states
self.parent.assertEqual(len(result.feature_maps ) , len(config.out_features ) )
self.parent.assertListEqual(list(result.feature_maps[0].shape ) , [self.batch_size, self.hidden_sizes[1], 4, 4] )
# verify channels
self.parent.assertEqual(len(model.channels ) , len(config.out_features ) )
self.parent.assertListEqual(model.channels , config.hidden_sizes[1:] )
# verify backbone works with out_features=None
lowercase :Union[str, Any] = None
lowercase :Union[str, Any] = ConvNextVaBackbone(config=snake_case__ )
model.to(snake_case__ )
model.eval()
lowercase :Optional[int] = model(snake_case__ )
# verify feature maps
self.parent.assertEqual(len(result.feature_maps ) , 1 )
self.parent.assertListEqual(list(result.feature_maps[0].shape ) , [self.batch_size, self.hidden_sizes[-1], 1, 1] )
# verify channels
self.parent.assertEqual(len(model.channels ) , 1 )
self.parent.assertListEqual(model.channels , [config.hidden_sizes[-1]] )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :Dict = self.prepare_config_and_inputs()
lowercase , lowercase , lowercase :List[str] = config_and_inputs
lowercase :str = {'''pixel_values''': pixel_values}
return config, inputs_dict
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :Optional[int] = self.prepare_config_and_inputs()
lowercase , lowercase , lowercase :Dict = config_and_inputs
lowercase :Dict = {'''pixel_values''': pixel_values, '''labels''': labels}
return config, inputs_dict
@require_torch
class __magic_name__ ( __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
__A : int = (
(
ConvNextVaModel,
ConvNextVaForImageClassification,
ConvNextVaBackbone,
)
if is_torch_available()
else ()
)
__A : Union[str, Any] = (
{"feature-extraction": ConvNextVaModel, "image-classification": ConvNextVaForImageClassification}
if is_torch_available()
else {}
)
__A : str = False
__A : Union[str, Any] = False
__A : Any = False
__A : List[Any] = False
__A : List[Any] = False
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Optional[int] = ConvNextVaModelTester(self )
lowercase :List[str] = ConfigTester(self , config_class=snake_case__ , has_text_modality=snake_case__ , hidden_size=3_7 )
def __snake_case ( self : int ):
'''simple docstring'''
self.create_and_test_config_common_properties()
self.config_tester.create_and_test_config_to_json_string()
self.config_tester.create_and_test_config_to_json_file()
self.config_tester.create_and_test_config_from_and_save_pretrained()
self.config_tester.create_and_test_config_with_num_labels()
self.config_tester.check_config_can_be_init_without_params()
self.config_tester.check_config_arguments_init()
def __snake_case ( self : List[str] ):
'''simple docstring'''
return
@unittest.skip(reason='''ConvNextV2 does not use inputs_embeds''' )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
pass
@unittest.skip(reason='''ConvNextV2 does not support input and output embeddings''' )
def __snake_case ( self : Dict ):
'''simple docstring'''
pass
@unittest.skip(reason='''ConvNextV2 does not use feedforward chunking''' )
def __snake_case ( self : int ):
'''simple docstring'''
pass
def __snake_case ( self : str ):
'''simple docstring'''
if not self.model_tester.is_training:
return
for model_class in self.all_model_classes:
lowercase , lowercase :Any = self.model_tester.prepare_config_and_inputs_with_labels()
lowercase :List[Any] = True
if model_class.__name__ in [
*get_values(snake_case__ ),
*get_values(snake_case__ ),
]:
continue
lowercase :Any = model_class(snake_case__ )
model.to(snake_case__ )
model.train()
lowercase :Optional[int] = self._prepare_for_class(snake_case__ , snake_case__ , return_labels=snake_case__ )
lowercase :Union[str, Any] = model(**snake_case__ ).loss
loss.backward()
def __snake_case ( self : str ):
'''simple docstring'''
if not self.model_tester.is_training:
return
for model_class in self.all_model_classes:
lowercase , lowercase :Tuple = self.model_tester.prepare_config_and_inputs_with_labels()
lowercase :Any = False
lowercase :List[str] = True
if (
model_class.__name__
in [*get_values(snake_case__ ), *get_values(snake_case__ )]
or not model_class.supports_gradient_checkpointing
):
continue
lowercase :List[Any] = model_class(snake_case__ )
model.to(snake_case__ )
model.gradient_checkpointing_enable()
model.train()
lowercase :Tuple = self._prepare_for_class(snake_case__ , snake_case__ , return_labels=snake_case__ )
lowercase :int = model(**snake_case__ ).loss
loss.backward()
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase , lowercase :int = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :List[Any] = model_class(snake_case__ )
lowercase :Dict = inspect.signature(model.forward )
# signature.parameters is an OrderedDict => so arg_names order is deterministic
lowercase :Tuple = [*signature.parameters.keys()]
lowercase :Optional[int] = ['''pixel_values''']
self.assertListEqual(arg_names[:1] , snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Tuple = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*snake_case__ )
def __snake_case ( self : Tuple ):
'''simple docstring'''
def check_hidden_states_output(snake_case__ : List[Any] , snake_case__ : Any , snake_case__ : List[str] ):
lowercase :Optional[int] = model_class(snake_case__ )
model.to(snake_case__ )
model.eval()
with torch.no_grad():
lowercase :List[Any] = model(**self._prepare_for_class(snake_case__ , snake_case__ ) )
lowercase :Any = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
lowercase :List[Any] = self.model_tester.num_stages
self.assertEqual(len(snake_case__ ) , expected_num_stages + 1 )
# ConvNextV2's feature maps are of shape (batch_size, num_channels, height, width)
self.assertListEqual(
list(hidden_states[0].shape[-2:] ) , [self.model_tester.image_size // 4, self.model_tester.image_size // 4] , )
lowercase , lowercase :Dict = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :List[str] = True
check_hidden_states_output(snake_case__ , snake_case__ , snake_case__ )
# check that output_hidden_states also work using config
del inputs_dict["output_hidden_states"]
lowercase :List[Any] = True
check_hidden_states_output(snake_case__ , snake_case__ , snake_case__ )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :List[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_image_classification(*snake_case__ )
@slow
def __snake_case ( self : Any ):
'''simple docstring'''
for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
lowercase :str = ConvNextVaModel.from_pretrained(snake_case__ )
self.assertIsNotNone(snake_case__ )
def lowerCamelCase () -> Optional[int]:
lowercase :Tuple = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
return image
@require_torch
@require_vision
class __magic_name__ ( unittest.TestCase ):
@cached_property
def __snake_case ( self : Any ):
'''simple docstring'''
return AutoImageProcessor.from_pretrained('''facebook/convnextv2-tiny-1k-224''' ) if is_vision_available() else None
@slow
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Any = ConvNextVaForImageClassification.from_pretrained('''facebook/convnextv2-tiny-1k-224''' ).to(snake_case__ )
lowercase :Tuple = self.default_image_processor
lowercase :Optional[int] = prepare_img()
lowercase :List[Any] = preprocessor(images=snake_case__ , return_tensors='''pt''' ).to(snake_case__ )
# forward pass
with torch.no_grad():
lowercase :Optional[int] = model(**snake_case__ )
# verify the logits
lowercase :Dict = torch.Size((1, 1_0_0_0) )
self.assertEqual(outputs.logits.shape , snake_case__ )
lowercase :Union[str, Any] = torch.tensor([0.99_96, 0.19_66, -0.43_86] ).to(snake_case__ )
self.assertTrue(torch.allclose(outputs.logits[0, :3] , snake_case__ , atol=1e-4 ) )
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tensorflow_text_available,
is_tf_available,
is_tokenizers_available,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_bert''': ['''BERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BertConfig''', '''BertOnnxConfig'''],
'''tokenization_bert''': ['''BasicTokenizer''', '''BertTokenizer''', '''WordpieceTokenizer'''],
}
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''BertTokenizerFast''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''BertForMaskedLM''',
'''BertForMultipleChoice''',
'''BertForNextSentencePrediction''',
'''BertForPreTraining''',
'''BertForQuestionAnswering''',
'''BertForSequenceClassification''',
'''BertForTokenClassification''',
'''BertLayer''',
'''BertLMHeadModel''',
'''BertModel''',
'''BertPreTrainedModel''',
'''load_tf_weights_in_bert''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''TFBertEmbeddings''',
'''TFBertForMaskedLM''',
'''TFBertForMultipleChoice''',
'''TFBertForNextSentencePrediction''',
'''TFBertForPreTraining''',
'''TFBertForQuestionAnswering''',
'''TFBertForSequenceClassification''',
'''TFBertForTokenClassification''',
'''TFBertLMHeadModel''',
'''TFBertMainLayer''',
'''TFBertModel''',
'''TFBertPreTrainedModel''',
]
try:
if not is_tensorflow_text_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''TFBertTokenizer''']
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxBertForCausalLM''',
'''FlaxBertForMaskedLM''',
'''FlaxBertForMultipleChoice''',
'''FlaxBertForNextSentencePrediction''',
'''FlaxBertForPreTraining''',
'''FlaxBertForQuestionAnswering''',
'''FlaxBertForSequenceClassification''',
'''FlaxBertForTokenClassification''',
'''FlaxBertModel''',
'''FlaxBertPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_bert import BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BertConfig, BertOnnxConfig
from .tokenization_bert import BasicTokenizer, BertTokenizer, WordpieceTokenizer
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_bert_fast import BertTokenizerFast
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_bert import (
BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
BertForMaskedLM,
BertForMultipleChoice,
BertForNextSentencePrediction,
BertForPreTraining,
BertForQuestionAnswering,
BertForSequenceClassification,
BertForTokenClassification,
BertLayer,
BertLMHeadModel,
BertModel,
BertPreTrainedModel,
load_tf_weights_in_bert,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_bert import (
TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
TFBertEmbeddings,
TFBertForMaskedLM,
TFBertForMultipleChoice,
TFBertForNextSentencePrediction,
TFBertForPreTraining,
TFBertForQuestionAnswering,
TFBertForSequenceClassification,
TFBertForTokenClassification,
TFBertLMHeadModel,
TFBertMainLayer,
TFBertModel,
TFBertPreTrainedModel,
)
try:
if not is_tensorflow_text_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_bert_tf import TFBertTokenizer
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_bert import (
FlaxBertForCausalLM,
FlaxBertForMaskedLM,
FlaxBertForMultipleChoice,
FlaxBertForNextSentencePrediction,
FlaxBertForPreTraining,
FlaxBertForQuestionAnswering,
FlaxBertForSequenceClassification,
FlaxBertForTokenClassification,
FlaxBertModel,
FlaxBertPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
import math
import unittest
def lowerCamelCase (a_ :int) -> bool:
assert isinstance(a_ , a_) and (
number >= 0
), "'number' must been an int and positive"
if 1 < number < 4:
# 2 and 3 are primes
return True
elif number < 2 or number % 2 == 0 or number % 3 == 0:
# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
return False
# All primes number are in format of 6k +/- 1
for i in range(5 , int(math.sqrt(a_) + 1) , 6):
if number % i == 0 or number % (i + 2) == 0:
return False
return True
class __magic_name__ ( unittest.TestCase ):
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
self.assertTrue(is_prime(2 ) )
self.assertTrue(is_prime(3 ) )
self.assertTrue(is_prime(5 ) )
self.assertTrue(is_prime(7 ) )
self.assertTrue(is_prime(1_1 ) )
self.assertTrue(is_prime(1_3 ) )
self.assertTrue(is_prime(1_7 ) )
self.assertTrue(is_prime(1_9 ) )
self.assertTrue(is_prime(2_3 ) )
self.assertTrue(is_prime(2_9 ) )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
with self.assertRaises(snake_case__ ):
is_prime(-1_9 )
self.assertFalse(
is_prime(0 ) , '''Zero doesn\'t have any positive factors, primes must have exactly two.''' , )
self.assertFalse(
is_prime(1 ) , '''One only has 1 positive factor, primes must have exactly two.''' , )
self.assertFalse(is_prime(2 * 2 ) )
self.assertFalse(is_prime(2 * 3 ) )
self.assertFalse(is_prime(3 * 3 ) )
self.assertFalse(is_prime(3 * 5 ) )
self.assertFalse(is_prime(3 * 5 * 7 ) )
if __name__ == "__main__":
unittest.main()
| 677 |
"""simple docstring"""
from typing import List, Optional, Union
from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
class __magic_name__ ( __UpperCAmelCase ):
__A : Tuple = ["image_processor", "tokenizer"]
__A : Dict = "BlipImageProcessor"
__A : Dict = "AutoTokenizer"
def __init__( self : Any , snake_case__ : Union[str, Any] , snake_case__ : str ):
'''simple docstring'''
lowercase :Dict = False
super().__init__(snake_case__ , snake_case__ )
lowercase :Union[str, Any] = self.image_processor
def __call__( self : Optional[int] , snake_case__ : ImageInput = None , snake_case__ : Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None , snake_case__ : bool = True , snake_case__ : Union[bool, str, PaddingStrategy] = False , snake_case__ : Union[bool, str, TruncationStrategy] = None , snake_case__ : Optional[int] = None , snake_case__ : int = 0 , snake_case__ : Optional[int] = None , snake_case__ : Optional[bool] = None , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = True , snake_case__ : Optional[Union[str, TensorType]] = None , **snake_case__ : Optional[Any] , ):
'''simple docstring'''
if images is None and text is None:
raise ValueError('''You have to specify either images or text.''' )
# Get only text
if images is None:
lowercase :List[Any] = self.tokenizer
lowercase :str = self.tokenizer(
text=snake_case__ , add_special_tokens=snake_case__ , padding=snake_case__ , truncation=snake_case__ , max_length=snake_case__ , stride=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , return_overflowing_tokens=snake_case__ , return_special_tokens_mask=snake_case__ , return_offsets_mapping=snake_case__ , return_token_type_ids=snake_case__ , return_length=snake_case__ , verbose=snake_case__ , return_tensors=snake_case__ , **snake_case__ , )
return text_encoding
# add pixel_values
lowercase :Union[str, Any] = self.image_processor(snake_case__ , return_tensors=snake_case__ )
if text is not None:
lowercase :int = self.tokenizer(
text=snake_case__ , add_special_tokens=snake_case__ , padding=snake_case__ , truncation=snake_case__ , max_length=snake_case__ , stride=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , return_overflowing_tokens=snake_case__ , return_special_tokens_mask=snake_case__ , return_offsets_mapping=snake_case__ , return_token_type_ids=snake_case__ , return_length=snake_case__ , verbose=snake_case__ , return_tensors=snake_case__ , **snake_case__ , )
else:
lowercase :Optional[int] = None
if text_encoding is not None:
encoding_image_processor.update(snake_case__ )
return encoding_image_processor
def __snake_case ( self : Tuple , *snake_case__ : List[Any] , **snake_case__ : Tuple ):
'''simple docstring'''
return self.tokenizer.batch_decode(*snake_case__ , **snake_case__ )
def __snake_case ( self : List[str] , *snake_case__ : Dict , **snake_case__ : List[Any] ):
'''simple docstring'''
return self.tokenizer.decode(*snake_case__ , **snake_case__ )
@property
# Copied from transformers.models.blip.processing_blip.BlipProcessor.model_input_names
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase :List[Any] = self.tokenizer.model_input_names
lowercase :List[Any] = self.image_processor.model_input_names
return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) )
| 677 | 1 |
"""simple docstring"""
import warnings
from .generation import TFGenerationMixin
class __magic_name__ ( __UpperCAmelCase ):
# warning at import time
warnings.warn(
"Importing `TFGenerationMixin` from `src/transformers/generation_tf_utils.py` is deprecated and will "
"be removed in Transformers v5. Import as `from transformers import TFGenerationMixin` instead." , __UpperCAmelCase , )
| 677 |
"""simple docstring"""
import subprocess
import sys
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch
class __magic_name__ ( __UpperCAmelCase ):
@require_torch
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Optional[Any] = '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
'''
lowercase :Any = '''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
'''
lowercase :Tuple = '''
import socket
def offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")
socket.socket = offline_socket
'''
# Force fetching the files so that we can use the cache
lowercase :str = '''hf-internal-testing/tiny-random-bert'''
BertConfig.from_pretrained(snake_case__ )
BertModel.from_pretrained(snake_case__ )
BertTokenizer.from_pretrained(snake_case__ )
pipeline(task='''fill-mask''' , model=snake_case__ )
# baseline - just load from_pretrained with normal network
lowercase :Union[str, Any] = [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]
# should succeed
lowercase :Any = self.get_env()
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :List[Any] = '''1'''
lowercase :List[str] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :List[str] = '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
'''
lowercase :Dict = '''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
'''
lowercase :List[Any] = '''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")
socket.socket = offline_socket
'''
# Force fetching the files so that we can use the cache
lowercase :str = '''hf-internal-testing/tiny-random-bert'''
BertConfig.from_pretrained(snake_case__ )
BertModel.from_pretrained(snake_case__ )
BertTokenizer.from_pretrained(snake_case__ )
pipeline(task='''fill-mask''' , model=snake_case__ )
# baseline - just load from_pretrained with normal network
lowercase :List[str] = [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]
# should succeed
lowercase :str = self.get_env()
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : int ):
'''simple docstring'''
lowercase :str = '''
from transformers import BertConfig, BertModel, BertTokenizer
'''
lowercase :Union[str, Any] = '''
mname = "hf-internal-testing/tiny-random-bert-sharded"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
print("success")
'''
lowercase :Optional[int] = '''
import socket
def offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")
socket.socket = offline_socket
'''
# baseline - just load from_pretrained with normal network
lowercase :Optional[Any] = [sys.executable, '''-c''', '''\n'''.join([load, run] )]
# should succeed
lowercase :Union[str, Any] = self.get_env()
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
# next emulate no network
lowercase :Tuple = [sys.executable, '''-c''', '''\n'''.join([load, mock, run] )]
# Doesn't fail anymore since the model is in the cache due to other tests, so commenting this.
# env["TRANSFORMERS_OFFLINE"] = "0"
# result = subprocess.run(cmd, env=env, check=False, capture_output=True)
# self.assertEqual(result.returncode, 1, result.stderr)
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :Any = '''1'''
lowercase :Optional[Any] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :Dict = '''
from transformers import pipeline
'''
lowercase :Optional[Any] = '''
mname = "hf-internal-testing/tiny-random-bert"
pipe = pipeline(model=mname)
'''
lowercase :Dict = '''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")
socket.socket = offline_socket
'''
lowercase :Tuple = self.get_env()
lowercase :Optional[Any] = '''1'''
lowercase :Optional[int] = [sys.executable, '''-c''', '''\n'''.join([load, mock, run] )]
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 1 , result.stderr )
self.assertIn(
'''You cannot infer task automatically within `pipeline` when using offline mode''' , result.stderr.decode().replace('''\n''' , '''''' ) , )
@require_torch
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = '''
from transformers import AutoModel
'''
lowercase :Union[str, Any] = '''
mname = "hf-internal-testing/test_dynamic_model"
AutoModel.from_pretrained(mname, trust_remote_code=True)
print("success")
'''
# baseline - just load from_pretrained with normal network
lowercase :Union[str, Any] = [sys.executable, '''-c''', '''\n'''.join([load, run] )]
# should succeed
lowercase :List[str] = self.get_env()
lowercase :Optional[int] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :List[Any] = '''1'''
lowercase :Tuple = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
| 677 | 1 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available
UpperCAmelCase = {
'''configuration_transfo_xl''': ['''TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''TransfoXLConfig'''],
'''tokenization_transfo_xl''': ['''TransfoXLCorpus''', '''TransfoXLTokenizer'''],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''AdaptiveEmbedding''',
'''TransfoXLForSequenceClassification''',
'''TransfoXLLMHeadModel''',
'''TransfoXLModel''',
'''TransfoXLPreTrainedModel''',
'''load_tf_weights_in_transfo_xl''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''TFAdaptiveEmbedding''',
'''TFTransfoXLForSequenceClassification''',
'''TFTransfoXLLMHeadModel''',
'''TFTransfoXLMainLayer''',
'''TFTransfoXLModel''',
'''TFTransfoXLPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_transfo_xl import (
TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
AdaptiveEmbedding,
TransfoXLForSequenceClassification,
TransfoXLLMHeadModel,
TransfoXLModel,
TransfoXLPreTrainedModel,
load_tf_weights_in_transfo_xl,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_transfo_xl import (
TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
TFAdaptiveEmbedding,
TFTransfoXLForSequenceClassification,
TFTransfoXLLMHeadModel,
TFTransfoXLMainLayer,
TFTransfoXLModel,
TFTransfoXLPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 |
"""simple docstring"""
import argparse
import json
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from typing import List
import timm
import torch
import torch.nn as nn
from huggingface_hub import hf_hub_download
from torch import Tensor
from transformers import AutoImageProcessor, ResNetConfig, ResNetForImageClassification
from transformers.utils import logging
logging.set_verbosity_info()
UpperCAmelCase = logging.get_logger()
@dataclass
class __magic_name__ :
__A : nn.Module
__A : List[nn.Module] = field(default_factory=__UpperCAmelCase )
__A : list = field(default_factory=__UpperCAmelCase )
def __snake_case ( self : List[str] , snake_case__ : List[str] , snake_case__ : Tensor , snake_case__ : Tensor ):
'''simple docstring'''
lowercase :List[str] = len(list(m.modules() ) ) == 1 or isinstance(snake_case__ , nn.Convad ) or isinstance(snake_case__ , nn.BatchNormad )
if has_not_submodules:
self.traced.append(snake_case__ )
def __call__( self : int , snake_case__ : Tensor ):
'''simple docstring'''
for m in self.module.modules():
self.handles.append(m.register_forward_hook(self._forward_hook ) )
self.module(snake_case__ )
[x.remove() for x in self.handles]
return self
@property
def __snake_case ( self : int ):
'''simple docstring'''
return list(filter(lambda snake_case__ : len(list(x.state_dict().keys() ) ) > 0 , self.traced ) )
@dataclass
class __magic_name__ :
__A : nn.Module
__A : nn.Module
__A : int = 0
__A : List = field(default_factory=__UpperCAmelCase )
__A : List = field(default_factory=__UpperCAmelCase )
def __call__( self : Dict , snake_case__ : Tensor ):
'''simple docstring'''
lowercase :Dict = Tracker(self.dest )(snake_case__ ).parametrized
lowercase :Optional[Any] = Tracker(self.src )(snake_case__ ).parametrized
lowercase :List[str] = list(filter(lambda snake_case__ : type(snake_case__ ) not in self.src_skip , snake_case__ ) )
lowercase :Tuple = list(filter(lambda snake_case__ : type(snake_case__ ) not in self.dest_skip , snake_case__ ) )
if len(snake_case__ ) != len(snake_case__ ):
raise Exception(
f"""Numbers of operations are different. Source module has {len(snake_case__ )} operations while"""
f""" destination module has {len(snake_case__ )}.""" )
for dest_m, src_m in zip(snake_case__ , snake_case__ ):
dest_m.load_state_dict(src_m.state_dict() )
if self.verbose == 1:
print(f"""Transfered from={src_m} to={dest_m}""" )
def lowerCamelCase (a_ :str , a_ :ResNetConfig , a_ :Path , a_ :bool = True) -> Optional[Any]:
print(F"""Converting {name}...""")
with torch.no_grad():
lowercase :Union[str, Any] = timm.create_model(a_ , pretrained=a_).eval()
lowercase :Tuple = ResNetForImageClassification(a_).eval()
lowercase :int = ModuleTransfer(src=a_ , dest=a_)
lowercase :List[Any] = torch.randn((1, 3, 224, 224))
module_transfer(a_)
assert torch.allclose(from_model(a_) , our_model(a_).logits), "The model logits don't match the original one."
lowercase :List[Any] = F"""resnet{'-'.join(name.split('resnet'))}"""
print(a_)
if push_to_hub:
our_model.push_to_hub(
repo_path_or_name=save_directory / checkpoint_name , commit_message='''Add model''' , use_temp_dir=a_ , )
# we can use the convnext one
lowercase :Any = AutoImageProcessor.from_pretrained('''facebook/convnext-base-224-22k-1k''')
image_processor.push_to_hub(
repo_path_or_name=save_directory / checkpoint_name , commit_message='''Add image processor''' , use_temp_dir=a_ , )
print(F"""Pushed {checkpoint_name}""")
def lowerCamelCase (a_ :Path , a_ :str = None , a_ :bool = True) -> int:
lowercase :Optional[Any] = '''imagenet-1k-id2label.json'''
lowercase :Union[str, Any] = 1000
lowercase :Any = (1, num_labels)
lowercase :Tuple = '''huggingface/label-files'''
lowercase :List[str] = num_labels
lowercase :Union[str, Any] = json.load(open(hf_hub_download(a_ , a_ , repo_type='''dataset''') , '''r'''))
lowercase :Any = {int(a_): v for k, v in idalabel.items()}
lowercase :str = idalabel
lowercase :Any = {v: k for k, v in idalabel.items()}
lowercase :Union[str, Any] = partial(a_ , num_labels=a_ , idalabel=a_ , labelaid=a_)
lowercase :Optional[int] = {
'''resnet18''': ImageNetPreTrainedConfig(
depths=[2, 2, 2, 2] , hidden_sizes=[64, 128, 256, 512] , layer_type='''basic'''),
'''resnet26''': ImageNetPreTrainedConfig(
depths=[2, 2, 2, 2] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet34''': ImageNetPreTrainedConfig(
depths=[3, 4, 6, 3] , hidden_sizes=[64, 128, 256, 512] , layer_type='''basic'''),
'''resnet50''': ImageNetPreTrainedConfig(
depths=[3, 4, 6, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet101''': ImageNetPreTrainedConfig(
depths=[3, 4, 23, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet152''': ImageNetPreTrainedConfig(
depths=[3, 8, 36, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
}
if model_name:
convert_weight_and_push(a_ , names_to_config[model_name] , a_ , a_)
else:
for model_name, config in names_to_config.items():
convert_weight_and_push(a_ , a_ , a_ , a_)
return config, expected_shape
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'''--model_name''',
default=None,
type=str,
help=(
'''The name of the model you wish to convert, it must be one of the supported resnet* architecture,'''
''' currently: resnet18,26,34,50,101,152. If `None`, all of them will the converted.'''
),
)
parser.add_argument(
'''--pytorch_dump_folder_path''',
default=None,
type=Path,
required=True,
help='''Path to the output PyTorch model directory.''',
)
parser.add_argument(
'''--push_to_hub''',
default=True,
type=bool,
required=False,
help='''If True, push model and image processor to the hub.''',
)
UpperCAmelCase = parser.parse_args()
UpperCAmelCase = args.pytorch_dump_folder_path
pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
| 677 | 1 |
"""simple docstring"""
from __future__ import annotations
from collections.abc import Generator
def lowerCamelCase () -> Generator[int, None, None]:
lowercase :dict[int, int] = {}
lowercase :List[Any] = 2
while True:
lowercase :Any = factor_map.pop(a_ , a_)
if factor:
lowercase :int = factor + prime
while x in factor_map:
x += factor
lowercase :Union[str, Any] = factor
else:
lowercase :int = prime
yield prime
prime += 1
def lowerCamelCase (a_ :float = 1E10) -> int:
lowercase :Optional[Any] = sieve()
lowercase :str = 1
while True:
lowercase :Optional[Any] = next(a_)
if (2 * prime * n) > limit:
return n
# Ignore the next prime as the reminder will be 2.
next(a_)
n += 2
if __name__ == "__main__":
print(solution())
| 677 |
"""simple docstring"""
from __future__ import annotations
import unittest
from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin
if is_tf_available():
import tensorflow as tf
from transformers import (
TF_MODEL_FOR_PRETRAINING_MAPPING,
TFMobileBertForMaskedLM,
TFMobileBertForMultipleChoice,
TFMobileBertForNextSentencePrediction,
TFMobileBertForPreTraining,
TFMobileBertForQuestionAnswering,
TFMobileBertForSequenceClassification,
TFMobileBertForTokenClassification,
TFMobileBertModel,
)
@require_tf
class __magic_name__ ( __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
__A : Any = (
(
TFMobileBertModel,
TFMobileBertForMaskedLM,
TFMobileBertForNextSentencePrediction,
TFMobileBertForPreTraining,
TFMobileBertForQuestionAnswering,
TFMobileBertForSequenceClassification,
TFMobileBertForTokenClassification,
TFMobileBertForMultipleChoice,
)
if is_tf_available()
else ()
)
__A : List[Any] = (
{
"feature-extraction": TFMobileBertModel,
"fill-mask": TFMobileBertForMaskedLM,
"question-answering": TFMobileBertForQuestionAnswering,
"text-classification": TFMobileBertForSequenceClassification,
"token-classification": TFMobileBertForTokenClassification,
"zero-shot": TFMobileBertForSequenceClassification,
}
if is_tf_available()
else {}
)
__A : List[str] = False
__A : int = False
def __snake_case ( self : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Any , snake_case__ : int=False ):
'''simple docstring'''
lowercase :Union[str, Any] = super()._prepare_for_class(snake_case__ , snake_case__ , return_labels=snake_case__ )
if return_labels:
if model_class in get_values(snake_case__ ):
lowercase :Tuple = tf.zeros(self.model_tester.batch_size , dtype=tf.intaa )
return inputs_dict
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Any , snake_case__ : Dict , snake_case__ : Dict=1_3 , snake_case__ : Tuple=7 , snake_case__ : Optional[Any]=True , snake_case__ : Union[str, Any]=True , snake_case__ : str=True , snake_case__ : Optional[Any]=True , snake_case__ : Any=9_9 , snake_case__ : Optional[Any]=3_2 , snake_case__ : Optional[Any]=3_2 , snake_case__ : Any=2 , snake_case__ : Optional[int]=4 , snake_case__ : List[Any]=3_7 , snake_case__ : Optional[int]="gelu" , snake_case__ : List[Any]=0.1 , snake_case__ : str=0.1 , snake_case__ : List[Any]=5_1_2 , snake_case__ : List[str]=1_6 , snake_case__ : Union[str, Any]=2 , snake_case__ : Optional[Any]=0.02 , snake_case__ : Optional[Any]=3 , snake_case__ : Dict=4 , snake_case__ : int=None , ):
'''simple docstring'''
lowercase :Tuple = parent
lowercase :Tuple = batch_size
lowercase :Optional[Any] = seq_length
lowercase :Optional[Any] = is_training
lowercase :Optional[Any] = use_input_mask
lowercase :List[Any] = use_token_type_ids
lowercase :str = use_labels
lowercase :List[str] = vocab_size
lowercase :str = hidden_size
lowercase :Optional[int] = num_hidden_layers
lowercase :Dict = num_attention_heads
lowercase :Any = intermediate_size
lowercase :List[str] = hidden_act
lowercase :Optional[Any] = hidden_dropout_prob
lowercase :List[Any] = attention_probs_dropout_prob
lowercase :List[Any] = max_position_embeddings
lowercase :List[Any] = type_vocab_size
lowercase :Union[str, Any] = type_sequence_label_size
lowercase :Union[str, Any] = initializer_range
lowercase :Any = num_labels
lowercase :int = num_choices
lowercase :Dict = scope
lowercase :Dict = embedding_size
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :Optional[int] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size )
lowercase :int = None
if self.use_input_mask:
lowercase :int = random_attention_mask([self.batch_size, self.seq_length] )
lowercase :Tuple = None
if self.use_token_type_ids:
lowercase :int = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size )
lowercase :Union[str, Any] = None
lowercase :int = None
lowercase :str = None
if self.use_labels:
lowercase :int = ids_tensor([self.batch_size] , self.type_sequence_label_size )
lowercase :str = ids_tensor([self.batch_size, self.seq_length] , self.num_labels )
lowercase :Dict = ids_tensor([self.batch_size] , self.num_choices )
lowercase :Optional[int] = MobileBertConfig(
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 , embedding_size=self.embedding_size , )
return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
def __snake_case ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Any , snake_case__ : Tuple , snake_case__ : Tuple ):
'''simple docstring'''
lowercase :Dict = TFMobileBertModel(config=snake_case__ )
lowercase :Union[str, Any] = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
lowercase :Optional[int] = [input_ids, input_mask]
lowercase :Optional[int] = model(snake_case__ )
lowercase :Union[str, Any] = model(snake_case__ )
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 : List[Any] , snake_case__ : Dict , snake_case__ : Optional[int] , snake_case__ : int , snake_case__ : str , snake_case__ : Dict , snake_case__ : Tuple , snake_case__ : Optional[int] ):
'''simple docstring'''
lowercase :Any = TFMobileBertForMaskedLM(config=snake_case__ )
lowercase :Any = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :int = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) )
def __snake_case ( self : Tuple , snake_case__ : Any , snake_case__ : Optional[Any] , snake_case__ : List[Any] , snake_case__ : Dict , snake_case__ : str , snake_case__ : List[Any] , snake_case__ : Tuple ):
'''simple docstring'''
lowercase :Optional[Any] = TFMobileBertForNextSentencePrediction(config=snake_case__ )
lowercase :Tuple = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :Optional[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, 2) )
def __snake_case ( self : Dict , snake_case__ : Optional[Any] , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : Optional[int] , snake_case__ : int , snake_case__ : Union[str, Any] , snake_case__ : Dict ):
'''simple docstring'''
lowercase :int = TFMobileBertForPreTraining(config=snake_case__ )
lowercase :Any = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
self.parent.assertEqual(
result.prediction_logits.shape , (self.batch_size, self.seq_length, self.vocab_size) )
self.parent.assertEqual(result.seq_relationship_logits.shape , (self.batch_size, 2) )
def __snake_case ( self : Optional[Any] , snake_case__ : Tuple , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Optional[Any] , snake_case__ : List[str] , snake_case__ : Dict , snake_case__ : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = self.num_labels
lowercase :List[Any] = TFMobileBertForSequenceClassification(config=snake_case__ )
lowercase :Dict = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def __snake_case ( self : Any , snake_case__ : Optional[int] , snake_case__ : Tuple , snake_case__ : Union[str, Any] , snake_case__ : List[Any] , snake_case__ : List[Any] , snake_case__ : List[Any] , snake_case__ : Optional[Any] ):
'''simple docstring'''
lowercase :Tuple = self.num_choices
lowercase :Any = TFMobileBertForMultipleChoice(config=snake_case__ )
lowercase :Any = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :Union[str, Any] = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :List[Any] = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :Dict = {
'''input_ids''': multiple_choice_inputs_ids,
'''attention_mask''': multiple_choice_input_mask,
'''token_type_ids''': multiple_choice_token_type_ids,
}
lowercase :Optional[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) )
def __snake_case ( self : Any , snake_case__ : str , snake_case__ : Tuple , snake_case__ : int , snake_case__ : Tuple , snake_case__ : Dict , snake_case__ : Optional[Any] , snake_case__ : Dict ):
'''simple docstring'''
lowercase :List[Any] = self.num_labels
lowercase :List[str] = TFMobileBertForTokenClassification(config=snake_case__ )
lowercase :int = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :int = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) )
def __snake_case ( self : List[str] , snake_case__ : List[Any] , snake_case__ : Optional[int] , snake_case__ : Optional[int] , snake_case__ : List[Any] , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : str ):
'''simple docstring'''
lowercase :Union[str, Any] = TFMobileBertForQuestionAnswering(config=snake_case__ )
lowercase :List[Any] = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :str = model(snake_case__ )
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 : List[Any] ):
'''simple docstring'''
lowercase :Dict = self.prepare_config_and_inputs()
(
(
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) ,
) :Dict = config_and_inputs
lowercase :Optional[Any] = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
return config, inputs_dict
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = TFMobileBertModelTest.TFMobileBertModelTester(self )
lowercase :List[str] = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
self.config_tester.run_common_tests()
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :List[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_model(*snake_case__ )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :List[str] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_masked_lm(*snake_case__ )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :str = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_multiple_choice(*snake_case__ )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :Tuple = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*snake_case__ )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :int = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_pretraining(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Tuple = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_question_answering(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Optional[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_sequence_classification(*snake_case__ )
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_token_classification(*snake_case__ )
@slow
def __snake_case ( self : int ):
'''simple docstring'''
for model_name in ["google/mobilebert-uncased"]:
lowercase :List[str] = TFMobileBertModel.from_pretrained(snake_case__ )
self.assertIsNotNone(snake_case__ )
@require_tf
class __magic_name__ ( unittest.TestCase ):
@slow
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :int = TFMobileBertForPreTraining.from_pretrained('''google/mobilebert-uncased''' )
lowercase :Optional[Any] = tf.constant([[0, 1, 2, 3, 4, 5]] )
lowercase :List[Any] = model(snake_case__ )[0]
lowercase :Union[str, Any] = [1, 6, 3_0_5_2_2]
self.assertEqual(output.shape , snake_case__ )
lowercase :Optional[int] = tf.constant(
[
[
[-4.5_91_95_47, -9.24_82_95, -9.64_52_56],
[-6.7_30_61_75, -6.44_02_84, -6.6_05_28_37],
[-7.2_74_35_06, -6.7_84_79_15, -6.02_46_73],
]
] )
tf.debugging.assert_near(output[:, :3, :3] , snake_case__ , atol=1e-4 )
| 677 | 1 |
"""simple docstring"""
import logging
import math
from functools import partial
from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple, Union
import torch
from .tensor_utils import tensor_tree_map, tree_map
def lowerCamelCase (a_ :Union[dict, list, tuple, torch.Tensor]) -> List[Tuple[int, ...]]:
lowercase :Optional[int] = []
if isinstance(a_ , a_):
for v in tree.values():
shapes.extend(_fetch_dims(a_))
elif isinstance(a_ , (list, tuple)):
for t in tree:
shapes.extend(_fetch_dims(a_))
elif isinstance(a_ , torch.Tensor):
shapes.append(tree.shape)
else:
raise ValueError('''Not supported''')
return shapes
@torch.jit.ignore
def lowerCamelCase (a_ :int , a_ :Tuple[int, ...]) -> Tuple[int, ...]:
lowercase :Optional[int] = []
for d in reversed(a_):
idx.append(flat_idx % d)
lowercase :str = flat_idx // d
return tuple(reversed(a_))
@torch.jit.ignore
def lowerCamelCase (a_ :Sequence[int] , a_ :Sequence[int] , a_ :Sequence[int] , a_ :Optional[Sequence[bool]] = None , a_ :Optional[Sequence[bool]] = None , ) -> List[Tuple[slice, ...]]:
# start_edges and end_edges both indicate whether, starting from any given
# dimension, the start/end index is at the top/bottom edge of the
# corresponding tensor, modeled as a tree
def reduce_edge_list(a_ :List[bool]) -> None:
lowercase :int = True
for i in range(len(a_)):
lowercase :Union[str, Any] = -1 * (i + 1)
l[reversed_idx] &= tally
lowercase :Union[str, Any] = l[reversed_idx]
if start_edges is None:
lowercase :List[Any] = [s == 0 for s in start]
reduce_edge_list(a_)
if end_edges is None:
lowercase :List[Any] = [e == (d - 1) for e, d in zip(a_ , a_)]
reduce_edge_list(a_)
# Base cases. Either start/end are empty and we're done, or the final,
# one-dimensional tensor can be simply sliced
if len(a_) == 0:
return [()]
elif len(a_) == 1:
return [(slice(start[0] , end[0] + 1),)]
lowercase :List[Tuple[slice, ...]] = []
lowercase :List[slice] = []
# Dimensions common to start and end can be selected directly
for s, e in zip(a_ , a_):
if s == e:
path_list.append(slice(a_ , s + 1))
else:
break
lowercase :Tuple[slice, ...] = tuple(a_)
lowercase :Any = len(a_)
# start == end, and we're done
if divergence_idx == len(a_):
return [path]
def upper() -> Tuple[Tuple[slice, ...], ...]:
assert start_edges is not None
assert end_edges is not None
lowercase :Optional[Any] = start[divergence_idx]
return tuple(
path + (slice(a_ , sdi + 1),) + s
for s in _get_minimal_slice_set(
start[divergence_idx + 1 :] , [d - 1 for d in dims[divergence_idx + 1 :]] , dims[divergence_idx + 1 :] , start_edges=start_edges[divergence_idx + 1 :] , end_edges=[True for _ in end_edges[divergence_idx + 1 :]] , ))
def lower() -> Tuple[Tuple[slice, ...], ...]:
assert start_edges is not None
assert end_edges is not None
lowercase :Optional[Any] = end[divergence_idx]
return tuple(
path + (slice(a_ , edi + 1),) + s
for s in _get_minimal_slice_set(
[0 for _ in start[divergence_idx + 1 :]] , end[divergence_idx + 1 :] , dims[divergence_idx + 1 :] , start_edges=[True for _ in start_edges[divergence_idx + 1 :]] , end_edges=end_edges[divergence_idx + 1 :] , ))
# If both start and end are at the edges of the subtree rooted at
# divergence_idx, we can just select the whole subtree at once
if start_edges[divergence_idx] and end_edges[divergence_idx]:
slices.append(path + (slice(start[divergence_idx] , end[divergence_idx] + 1),))
# If just start is at the edge, we can grab almost all of the subtree,
# treating only the ragged bottom edge as an edge case
elif start_edges[divergence_idx]:
slices.append(path + (slice(start[divergence_idx] , end[divergence_idx]),))
slices.extend(lower())
# Analogous to the previous case, but the top is ragged this time
elif end_edges[divergence_idx]:
slices.extend(upper())
slices.append(path + (slice(start[divergence_idx] + 1 , end[divergence_idx] + 1),))
# If both sides of the range are ragged, we need to handle both sides
# separately. If there's contiguous meat in between them, we can index it
# in one big chunk
else:
slices.extend(upper())
lowercase :List[str] = end[divergence_idx] - start[divergence_idx]
if middle_ground > 1:
slices.append(path + (slice(start[divergence_idx] + 1 , end[divergence_idx]),))
slices.extend(lower())
return slices
@torch.jit.ignore
def lowerCamelCase (a_ :torch.Tensor , a_ :int , a_ :int , a_ :int) -> torch.Tensor:
lowercase :Any = t.shape[:no_batch_dims]
lowercase :int = list(_flat_idx_to_idx(a_ , a_))
# _get_minimal_slice_set is inclusive
lowercase :Optional[int] = list(_flat_idx_to_idx(flat_end - 1 , a_))
# Get an ordered list of slices to perform
lowercase :str = _get_minimal_slice_set(
a_ , a_ , a_ , )
lowercase :Tuple = [t[s] for s in slices]
return torch.cat([s.view((-1,) + t.shape[no_batch_dims:]) for s in sliced_tensors])
def lowerCamelCase (a_ :Callable , a_ :Dict[str, Any] , a_ :int , a_ :int , a_ :bool = False , a_ :Any = None , a_ :bool = False , ) -> Any:
if not (len(a_) > 0):
raise ValueError('''Must provide at least one input''')
lowercase :Union[str, Any] = [shape[:no_batch_dims] for shape in _fetch_dims(a_)]
lowercase :Any = tuple([max(a_) for s in zip(*a_)])
def _prep_inputs(a_ :torch.Tensor) -> torch.Tensor:
if not low_mem:
if not sum(t.shape[:no_batch_dims]) == no_batch_dims:
lowercase :Dict = t.expand(orig_batch_dims + t.shape[no_batch_dims:])
lowercase :Tuple = t.reshape(-1 , *t.shape[no_batch_dims:])
else:
lowercase :List[str] = t.expand(orig_batch_dims + t.shape[no_batch_dims:])
return t
lowercase :Dict[str, Any] = tensor_tree_map(_prep_inputs , a_)
lowercase :Optional[int] = None
if _out is not None:
lowercase :Any = tensor_tree_map(lambda a_: t.view([-1] + list(t.shape[no_batch_dims:])) , _out)
lowercase :Optional[int] = 1
for d in orig_batch_dims:
flat_batch_dim *= d
lowercase :Tuple = flat_batch_dim // chunk_size + (flat_batch_dim % chunk_size != 0)
def _select_chunk(a_ :torch.Tensor) -> torch.Tensor:
return t[i : i + chunk_size] if t.shape[0] != 1 else t
lowercase :List[Any] = 0
lowercase :List[str] = prepped_outputs
for _ in range(a_):
# Chunk the input
if not low_mem:
lowercase :Tuple = _select_chunk
else:
lowercase :Optional[Any] = partial(
_chunk_slice , flat_start=a_ , flat_end=min(a_ , i + chunk_size) , no_batch_dims=len(a_) , )
lowercase :Dict[str, Any] = tensor_tree_map(a_ , a_)
# Run the layer on the chunk
lowercase :str = layer(**a_)
# Allocate space for the output
if out is None:
lowercase :Tuple = tensor_tree_map(lambda a_: t.new_zeros((flat_batch_dim,) + t.shape[1:]) , a_)
# Put the chunk in its pre-allocated space
if isinstance(a_ , a_):
def assign(a_ :dict , a_ :dict) -> None:
for k, v in da.items():
if isinstance(a_ , a_):
assign(a_ , da[k])
else:
if _add_into_out:
v[i : i + chunk_size] += da[k]
else:
lowercase :Dict = da[k]
assign(a_ , a_)
elif isinstance(a_ , a_):
for xa, xa in zip(a_ , a_):
if _add_into_out:
xa[i : i + chunk_size] += xa
else:
lowercase :Any = xa
elif isinstance(a_ , torch.Tensor):
if _add_into_out:
out[i : i + chunk_size] += output_chunk
else:
lowercase :Optional[Any] = output_chunk
else:
raise ValueError('''Not supported''')
i += chunk_size
lowercase :Optional[int] = tensor_tree_map(lambda a_: t.view(orig_batch_dims + t.shape[1:]) , a_)
return out
class __magic_name__ :
def __init__( self : Tuple , snake_case__ : int = 5_1_2 , ):
'''simple docstring'''
lowercase :Tuple = max_chunk_size
lowercase :Optional[int] = None
lowercase :Optional[tuple] = None
def __snake_case ( self : str , snake_case__ : Callable , snake_case__ : tuple , snake_case__ : int ):
'''simple docstring'''
logging.info('''Tuning chunk size...''' )
if min_chunk_size >= self.max_chunk_size:
return min_chunk_size
lowercase :List[int] = [2**l for l in range(int(math.log(self.max_chunk_size , 2 ) ) + 1 )]
lowercase :int = [c for c in candidates if c > min_chunk_size]
lowercase :Optional[Any] = [min_chunk_size] + candidates
candidates[-1] += 4
def test_chunk_size(snake_case__ : int ) -> bool:
try:
with torch.no_grad():
fn(*snake_case__ , chunk_size=snake_case__ )
return True
except RuntimeError:
return False
lowercase :List[str] = 0
lowercase :int = len(snake_case__ ) - 1
while i > min_viable_chunk_size_index:
lowercase :int = test_chunk_size(candidates[i] )
if not viable:
lowercase :Optional[Any] = (min_viable_chunk_size_index + i) // 2
else:
lowercase :Union[str, Any] = i
lowercase :Tuple = (i + len(snake_case__ ) - 1) // 2
return candidates[min_viable_chunk_size_index]
def __snake_case ( self : Dict , snake_case__ : Iterable , snake_case__ : Iterable ):
'''simple docstring'''
lowercase :int = True
for aa, aa in zip(snake_case__ , snake_case__ ):
assert type(snake_case__ ) == type(snake_case__ )
if isinstance(snake_case__ , (list, tuple) ):
consistent &= self._compare_arg_caches(snake_case__ , snake_case__ )
elif isinstance(snake_case__ , snake_case__ ):
lowercase :Dict = [v for _, v in sorted(aa.items() , key=lambda snake_case__ : x[0] )]
lowercase :List[str] = [v for _, v in sorted(aa.items() , key=lambda snake_case__ : x[0] )]
consistent &= self._compare_arg_caches(snake_case__ , snake_case__ )
else:
consistent &= aa == aa
return consistent
def __snake_case ( self : Optional[int] , snake_case__ : Callable , snake_case__ : tuple , snake_case__ : int , ):
'''simple docstring'''
lowercase :List[str] = True
lowercase :tuple = tree_map(lambda snake_case__ : a.shape if isinstance(snake_case__ , torch.Tensor ) else a , snake_case__ , snake_case__ )
if self.cached_arg_data is not None:
# If args have changed shape/value, we need to re-tune
assert len(self.cached_arg_data ) == len(snake_case__ )
lowercase :str = self._compare_arg_caches(self.cached_arg_data , snake_case__ )
else:
# Otherwise, we can reuse the precomputed value
lowercase :Optional[Any] = False
if not consistent:
lowercase :Union[str, Any] = self._determine_favorable_chunk_size(
snake_case__ , snake_case__ , snake_case__ , )
lowercase :Optional[int] = arg_data
assert self.cached_chunk_size is not None
return self.cached_chunk_size
| 677 |
"""simple docstring"""
import contextlib
import copy
import random
from typing import Any, Dict, Iterable, Optional, Union
import numpy as np
import torch
from .utils import deprecate, is_transformers_available
if is_transformers_available():
import transformers
def lowerCamelCase (a_ :int) -> List[str]:
random.seed(a_)
np.random.seed(a_)
torch.manual_seed(a_)
torch.cuda.manual_seed_all(a_)
# ^^ safe to call this function even if cuda is not available
class __magic_name__ :
def __init__( self : Optional[Any] , snake_case__ : Iterable[torch.nn.Parameter] , snake_case__ : float = 0.99_99 , snake_case__ : float = 0.0 , snake_case__ : int = 0 , snake_case__ : bool = False , snake_case__ : Union[float, int] = 1.0 , snake_case__ : Union[float, int] = 2 / 3 , snake_case__ : Optional[Any] = None , snake_case__ : Dict[str, Any] = None , **snake_case__ : Tuple , ):
'''simple docstring'''
if isinstance(snake_case__ , torch.nn.Module ):
lowercase :int = (
'''Passing a `torch.nn.Module` to `ExponentialMovingAverage` is deprecated. '''
'''Please pass the parameters of the module instead.'''
)
deprecate(
'''passing a `torch.nn.Module` to `ExponentialMovingAverage`''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ , )
lowercase :Dict = parameters.parameters()
# set use_ema_warmup to True if a torch.nn.Module is passed for backwards compatibility
lowercase :Optional[Any] = True
if kwargs.get('''max_value''' , snake_case__ ) is not None:
lowercase :Optional[Any] = '''The `max_value` argument is deprecated. Please use `decay` instead.'''
deprecate('''max_value''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
lowercase :Optional[int] = kwargs['''max_value''']
if kwargs.get('''min_value''' , snake_case__ ) is not None:
lowercase :List[Any] = '''The `min_value` argument is deprecated. Please use `min_decay` instead.'''
deprecate('''min_value''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
lowercase :str = kwargs['''min_value''']
lowercase :Any = list(snake_case__ )
lowercase :Optional[Any] = [p.clone().detach() for p in parameters]
if kwargs.get('''device''' , snake_case__ ) is not None:
lowercase :str = '''The `device` argument is deprecated. Please use `to` instead.'''
deprecate('''device''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
self.to(device=kwargs['''device'''] )
lowercase :int = None
lowercase :int = decay
lowercase :Union[str, Any] = min_decay
lowercase :List[Any] = update_after_step
lowercase :Union[str, Any] = use_ema_warmup
lowercase :Any = inv_gamma
lowercase :Any = power
lowercase :str = 0
lowercase :int = None # set in `step()`
lowercase :List[str] = model_cls
lowercase :Any = model_config
@classmethod
def __snake_case ( cls : int , snake_case__ : Tuple , snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase , lowercase :int = model_cls.load_config(snake_case__ , return_unused_kwargs=snake_case__ )
lowercase :List[Any] = model_cls.from_pretrained(snake_case__ )
lowercase :Optional[int] = cls(model.parameters() , model_cls=snake_case__ , model_config=model.config )
ema_model.load_state_dict(snake_case__ )
return ema_model
def __snake_case ( self : int , snake_case__ : Union[str, Any] ):
'''simple docstring'''
if self.model_cls is None:
raise ValueError('''`save_pretrained` can only be used if `model_cls` was defined at __init__.''' )
if self.model_config is None:
raise ValueError('''`save_pretrained` can only be used if `model_config` was defined at __init__.''' )
lowercase :Dict = self.model_cls.from_config(self.model_config )
lowercase :Tuple = self.state_dict()
state_dict.pop('''shadow_params''' , snake_case__ )
model.register_to_config(**snake_case__ )
self.copy_to(model.parameters() )
model.save_pretrained(snake_case__ )
def __snake_case ( self : int , snake_case__ : int ):
'''simple docstring'''
lowercase :Union[str, Any] = max(0 , optimization_step - self.update_after_step - 1 )
if step <= 0:
return 0.0
if self.use_ema_warmup:
lowercase :int = 1 - (1 + step / self.inv_gamma) ** -self.power
else:
lowercase :Dict = (1 + step) / (1_0 + step)
lowercase :Optional[int] = min(snake_case__ , self.decay )
# make sure decay is not smaller than min_decay
lowercase :Optional[int] = max(snake_case__ , self.min_decay )
return cur_decay_value
@torch.no_grad()
def __snake_case ( self : Any , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
if isinstance(snake_case__ , torch.nn.Module ):
lowercase :Tuple = (
'''Passing a `torch.nn.Module` to `ExponentialMovingAverage.step` is deprecated. '''
'''Please pass the parameters of the module instead.'''
)
deprecate(
'''passing a `torch.nn.Module` to `ExponentialMovingAverage.step`''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ , )
lowercase :Union[str, Any] = parameters.parameters()
lowercase :Optional[Any] = list(snake_case__ )
self.optimization_step += 1
# Compute the decay factor for the exponential moving average.
lowercase :List[Any] = self.get_decay(self.optimization_step )
lowercase :Optional[Any] = decay
lowercase :List[Any] = 1 - decay
lowercase :List[str] = contextlib.nullcontext
if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
import deepspeed
for s_param, param in zip(self.shadow_params , snake_case__ ):
if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
lowercase :Union[str, Any] = deepspeed.zero.GatheredParameters(snake_case__ , modifier_rank=snake_case__ )
with context_manager():
if param.requires_grad:
s_param.sub_(one_minus_decay * (s_param - param) )
else:
s_param.copy_(snake_case__ )
def __snake_case ( self : str , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
lowercase :Optional[Any] = list(snake_case__ )
for s_param, param in zip(self.shadow_params , snake_case__ ):
param.data.copy_(s_param.to(param.device ).data )
def __snake_case ( self : Optional[int] , snake_case__ : Dict=None , snake_case__ : Dict=None ):
'''simple docstring'''
lowercase :str = [
p.to(device=snake_case__ , dtype=snake_case__ ) if p.is_floating_point() else p.to(device=snake_case__ )
for p in self.shadow_params
]
def __snake_case ( self : Dict ):
'''simple docstring'''
return {
"decay": self.decay,
"min_decay": self.min_decay,
"optimization_step": self.optimization_step,
"update_after_step": self.update_after_step,
"use_ema_warmup": self.use_ema_warmup,
"inv_gamma": self.inv_gamma,
"power": self.power,
"shadow_params": self.shadow_params,
}
def __snake_case ( self : Optional[int] , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
lowercase :str = [param.detach().cpu().clone() for param in parameters]
def __snake_case ( self : List[Any] , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
if self.temp_stored_params is None:
raise RuntimeError('''This ExponentialMovingAverage has no `store()`ed weights ''' '''to `restore()`''' )
for c_param, param in zip(self.temp_stored_params , snake_case__ ):
param.data.copy_(c_param.data )
# Better memory-wise.
lowercase :Dict = None
def __snake_case ( self : Union[str, Any] , snake_case__ : dict ):
'''simple docstring'''
lowercase :List[str] = copy.deepcopy(snake_case__ )
lowercase :Any = state_dict.get('''decay''' , self.decay )
if self.decay < 0.0 or self.decay > 1.0:
raise ValueError('''Decay must be between 0 and 1''' )
lowercase :int = state_dict.get('''min_decay''' , self.min_decay )
if not isinstance(self.min_decay , snake_case__ ):
raise ValueError('''Invalid min_decay''' )
lowercase :List[Any] = state_dict.get('''optimization_step''' , self.optimization_step )
if not isinstance(self.optimization_step , snake_case__ ):
raise ValueError('''Invalid optimization_step''' )
lowercase :int = state_dict.get('''update_after_step''' , self.update_after_step )
if not isinstance(self.update_after_step , snake_case__ ):
raise ValueError('''Invalid update_after_step''' )
lowercase :Optional[int] = state_dict.get('''use_ema_warmup''' , self.use_ema_warmup )
if not isinstance(self.use_ema_warmup , snake_case__ ):
raise ValueError('''Invalid use_ema_warmup''' )
lowercase :Any = state_dict.get('''inv_gamma''' , self.inv_gamma )
if not isinstance(self.inv_gamma , (float, int) ):
raise ValueError('''Invalid inv_gamma''' )
lowercase :Dict = state_dict.get('''power''' , self.power )
if not isinstance(self.power , (float, int) ):
raise ValueError('''Invalid power''' )
lowercase :Optional[int] = state_dict.get('''shadow_params''' , snake_case__ )
if shadow_params is not None:
lowercase :List[Any] = shadow_params
if not isinstance(self.shadow_params , snake_case__ ):
raise ValueError('''shadow_params must be a list''' )
if not all(isinstance(snake_case__ , torch.Tensor ) for p in self.shadow_params ):
raise ValueError('''shadow_params must all be Tensors''' )
| 677 | 1 |
"""simple docstring"""
import unittest
from transformers import TrOCRConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device
from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin
if is_torch_available():
import torch
from transformers.models.trocr.modeling_trocr import TrOCRDecoder, TrOCRForCausalLM
@require_torch
class __magic_name__ :
def __init__( self : Union[str, Any] , snake_case__ : List[Any] , snake_case__ : Tuple=9_9 , snake_case__ : Optional[int]=1_3 , snake_case__ : List[Any]=1_6 , snake_case__ : List[str]=7 , snake_case__ : Dict=True , snake_case__ : List[str]=True , snake_case__ : Any=True , snake_case__ : int=False , snake_case__ : int=True , snake_case__ : Optional[Any]=2 , snake_case__ : Any=3_2 , snake_case__ : str=4 , snake_case__ : Any=4 , snake_case__ : int=3_0 , snake_case__ : Optional[Any]=0 , snake_case__ : Union[str, Any]=1 , snake_case__ : Optional[int]=2 , snake_case__ : int=None , ):
'''simple docstring'''
lowercase :List[str] = parent
lowercase :Any = batch_size
lowercase :Optional[Any] = decoder_seq_length
# For common tests
lowercase :List[Any] = self.decoder_seq_length
lowercase :Dict = is_training
lowercase :Tuple = use_attention_mask
lowercase :Optional[int] = use_labels
lowercase :Any = vocab_size
lowercase :Optional[int] = d_model
lowercase :Optional[Any] = d_model
lowercase :Dict = decoder_layers
lowercase :List[str] = decoder_layers
lowercase :Any = decoder_ffn_dim
lowercase :Union[str, Any] = decoder_attention_heads
lowercase :Optional[int] = decoder_attention_heads
lowercase :List[Any] = eos_token_id
lowercase :Optional[Any] = bos_token_id
lowercase :List[Any] = pad_token_id
lowercase :Any = decoder_start_token_id
lowercase :Tuple = use_cache
lowercase :Any = max_position_embeddings
lowercase :Any = None
lowercase :int = decoder_seq_length
lowercase :Optional[int] = 2
lowercase :Optional[int] = 1
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :str = ids_tensor([self.batch_size, self.decoder_seq_length] , self.vocab_size )
lowercase :Tuple = None
if self.use_attention_mask:
lowercase :Any = ids_tensor([self.batch_size, self.decoder_seq_length] , vocab_size=2 )
lowercase :List[str] = None
if self.use_labels:
lowercase :List[Any] = ids_tensor([self.batch_size, self.decoder_seq_length] , self.vocab_size )
lowercase :Any = TrOCRConfig(
vocab_size=self.vocab_size , d_model=self.d_model , decoder_layers=self.decoder_layers , decoder_ffn_dim=self.decoder_ffn_dim , decoder_attention_heads=self.decoder_attention_heads , eos_token_id=self.eos_token_id , bos_token_id=self.bos_token_id , use_cache=self.use_cache , pad_token_id=self.pad_token_id , decoder_start_token_id=self.decoder_start_token_id , max_position_embeddings=self.max_position_embeddings , )
return (config, input_ids, attention_mask, lm_labels)
def __snake_case ( self : int , snake_case__ : List[Any] , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Union[str, Any] , ):
'''simple docstring'''
lowercase :Union[str, Any] = True
lowercase :str = TrOCRDecoder(config=snake_case__ ).to(snake_case__ ).eval()
lowercase :Optional[Any] = input_ids[:2]
input_ids[input_ids == 0] += 1
# first forward pass
lowercase :Any = model(snake_case__ , use_cache=snake_case__ )
lowercase :Any = model(snake_case__ )
lowercase :Union[str, Any] = model(snake_case__ , use_cache=snake_case__ )
self.parent.assertTrue(len(snake_case__ ) == len(snake_case__ ) )
self.parent.assertTrue(len(snake_case__ ) == len(snake_case__ ) + 1 )
lowercase :Tuple = outputs['''past_key_values''']
# create hypothetical next token and extent to next_input_ids
lowercase :Optional[int] = ids_tensor((2, 1) , config.vocab_size - 1 ) + 1
# append to next input_ids and
lowercase :List[Any] = torch.cat([input_ids, next_tokens] , dim=-1 )
lowercase :Optional[int] = model(snake_case__ )['''last_hidden_state''']
lowercase :Any = model(snake_case__ , past_key_values=snake_case__ )['''last_hidden_state''']
# select random slice
lowercase :Optional[Any] = ids_tensor((1,) , output_from_past.shape[-1] ).item()
lowercase :Optional[Any] = output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
lowercase :Union[str, Any] = output_from_past[:, 0, random_slice_idx].detach()
# test that outputs are equal for slice
assert torch.allclose(snake_case__ , snake_case__ , atol=1e-3 )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :Optional[Any] = self.prepare_config_and_inputs()
lowercase , lowercase , lowercase , lowercase :Union[str, Any] = config_and_inputs
lowercase :Optional[int] = {'''input_ids''': input_ids, '''attention_mask''': attention_mask}
return config, inputs_dict
@require_torch
class __magic_name__ ( __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
__A : Any = (TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
__A : Optional[Any] = (TrOCRForCausalLM,) if is_torch_available() else ()
__A : List[Any] = {"text-generation": TrOCRForCausalLM} if is_torch_available() else {}
__A : Optional[Any] = True
__A : Dict = False
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :Tuple = TrOCRStandaloneDecoderModelTester(self , is_training=snake_case__ )
lowercase :List[Any] = ConfigTester(self , config_class=snake_case__ )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
pass
def __snake_case ( self : Any ):
'''simple docstring'''
pass
def __snake_case ( self : Dict ):
'''simple docstring'''
pass
def __snake_case ( self : str ):
'''simple docstring'''
self.config_tester.run_common_tests()
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase :List[str] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_decoder_model_past(*snake_case__ )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
return
@unittest.skip('''The model doesn\'t support left padding''' ) # and it's not used enough to be worth fixing :)
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
pass
| 677 |
"""simple docstring"""
import argparse
import collections
import numpy as np
import torch
from flax import traverse_util
from tax import checkpoints
from transformers import MTaConfig, UMTaEncoderModel, UMTaForConditionalGeneration
from transformers.utils import logging
logging.set_verbosity_info()
def lowerCamelCase (a_ :int , a_ :Union[str, Any] , a_ :List[Any]) -> List[str]:
return params[F"""{prefix}/{prefix}/relpos_bias/rel_embedding"""][:, i, :]
def lowerCamelCase (a_ :Optional[Any] , a_ :Optional[int] , a_ :str , a_ :Any="attention") -> Optional[int]:
lowercase :Tuple = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/key/kernel"""][:, i, :, :])
lowercase :int = k_tmp.reshape(k_tmp.shape[0] , k_tmp.shape[1] * k_tmp.shape[2])
lowercase :str = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/out/kernel"""][:, i, :, :])
lowercase :Any = o_tmp.reshape(o_tmp.shape[0] * o_tmp.shape[1] , o_tmp.shape[2])
lowercase :int = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/query/kernel"""][:, i, :, :])
lowercase :List[str] = q_tmp.reshape(q_tmp.shape[0] , q_tmp.shape[1] * q_tmp.shape[2])
lowercase :List[Any] = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/value/kernel"""][:, i, :, :])
lowercase :Optional[int] = v_tmp.reshape(v_tmp.shape[0] , v_tmp.shape[1] * v_tmp.shape[2])
return k, o, q, v
def lowerCamelCase (a_ :Any , a_ :Union[str, Any] , a_ :Union[str, Any] , a_ :Union[str, Any]=False) -> List[Any]:
if split_mlp_wi:
lowercase :List[Any] = params[F"""{prefix}/{prefix}/mlp/wi_0/kernel"""][:, i, :]
lowercase :Optional[int] = params[F"""{prefix}/{prefix}/mlp/wi_1/kernel"""][:, i, :]
lowercase :Dict = (wi_a, wi_a)
else:
lowercase :Optional[Any] = params[F"""{prefix}/{prefix}/mlp/wi/kernel"""][:, i, :]
lowercase :Union[str, Any] = params[F"""{prefix}/{prefix}/mlp/wo/kernel"""][:, i, :]
return wi, wo
def lowerCamelCase (a_ :Any , a_ :Optional[Any] , a_ :Optional[Any] , a_ :Union[str, Any]) -> Optional[Any]:
return params[F"""{prefix}/{prefix}/{layer_name}/scale"""][:, i]
def lowerCamelCase (a_ :dict , *, a_ :int , a_ :bool , a_ :bool = False) -> int:
lowercase :Dict = traverse_util.flatten_dict(variables['''target'''])
lowercase :Optional[Any] = {'''/'''.join(a_): v for k, v in old.items()}
# v1.1 models have a gated GeLU with wi_0 and wi_1 instead of wi
lowercase :str = '''encoder/encoder/mlp/wi_0/kernel''' in old
print('''Split MLP:''' , a_)
lowercase :str = collections.OrderedDict()
# Shared embeddings.
lowercase :int = old['''token_embedder/embedding''']
# Encoder.
for i in range(a_):
# Block i, layer 0 (Self Attention).
lowercase :Union[str, Any] = tax_layer_norm_lookup(a_ , a_ , '''encoder''' , '''pre_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :Tuple = tax_attention_lookup(a_ , a_ , '''encoder''' , '''attention''')
lowercase :Dict = layer_norm
lowercase :Dict = k.T
lowercase :Union[str, Any] = o.T
lowercase :List[Any] = q.T
lowercase :int = v.T
# Block i, layer 1 (MLP).
lowercase :Optional[int] = tax_layer_norm_lookup(a_ , a_ , '''encoder''' , '''pre_mlp_layer_norm''')
lowercase , lowercase :str = tax_mlp_lookup(a_ , a_ , '''encoder''' , a_)
lowercase :int = layer_norm
if split_mlp_wi:
lowercase :Tuple = wi[0].T
lowercase :Tuple = wi[1].T
else:
lowercase :int = wi.T
lowercase :Tuple = wo.T
if scalable_attention:
# convert the rel_embedding of each layer
lowercase :Dict = tax_relpos_bias_lookup(
a_ , a_ , '''encoder''').T
lowercase :str = old['''encoder/encoder_norm/scale''']
if not scalable_attention:
lowercase :str = tax_relpos_bias_lookup(
a_ , 0 , '''encoder''').T
lowercase :List[Any] = tax_relpos_bias_lookup(
a_ , 0 , '''decoder''').T
if not is_encoder_only:
# Decoder.
for i in range(a_):
# Block i, layer 0 (Self Attention).
lowercase :Any = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_self_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :str = tax_attention_lookup(a_ , a_ , '''decoder''' , '''self_attention''')
lowercase :List[str] = layer_norm
lowercase :Dict = k.T
lowercase :List[Any] = o.T
lowercase :List[Any] = q.T
lowercase :Any = v.T
# Block i, layer 1 (Cross Attention).
lowercase :Tuple = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_cross_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :int = tax_attention_lookup(a_ , a_ , '''decoder''' , '''encoder_decoder_attention''')
lowercase :int = layer_norm
lowercase :Dict = k.T
lowercase :int = o.T
lowercase :List[Any] = q.T
lowercase :Tuple = v.T
# Block i, layer 2 (MLP).
lowercase :Any = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_mlp_layer_norm''')
lowercase , lowercase :Tuple = tax_mlp_lookup(a_ , a_ , '''decoder''' , a_)
lowercase :Any = layer_norm
if split_mlp_wi:
lowercase :int = wi[0].T
lowercase :Union[str, Any] = wi[1].T
else:
lowercase :int = wi.T
lowercase :List[Any] = wo.T
if scalable_attention:
# convert the rel_embedding of each layer
lowercase :Union[str, Any] = tax_relpos_bias_lookup(a_ , a_ , '''decoder''').T
lowercase :Union[str, Any] = old['''decoder/decoder_norm/scale''']
# LM Head (only in v1.1 checkpoints, in v1.0 embeddings are used instead)
if "decoder/logits_dense/kernel" in old:
lowercase :int = old['''decoder/logits_dense/kernel'''].T
return new
def lowerCamelCase (a_ :Dict , a_ :bool) -> Tuple:
lowercase :str = collections.OrderedDict([(k, torch.from_numpy(v.copy())) for (k, v) in converted_params.items()])
# Add what is missing.
if "encoder.embed_tokens.weight" not in state_dict:
lowercase :Any = state_dict['''shared.weight''']
if not is_encoder_only:
if "decoder.embed_tokens.weight" not in state_dict:
lowercase :Optional[Any] = state_dict['''shared.weight''']
if "lm_head.weight" not in state_dict: # For old 1.0 models.
print('''Using shared word embeddings as lm_head.''')
lowercase :Optional[int] = state_dict['''shared.weight''']
return state_dict
def lowerCamelCase (a_ :List[str] , a_ :List[str] , a_ :Tuple , a_ :Optional[int] , a_ :List[str]) -> List[str]:
lowercase :Optional[Any] = checkpoints.load_tax_checkpoint(a_)
lowercase :Optional[int] = convert_tax_to_pytorch(
a_ , num_layers=config.num_layers , is_encoder_only=a_ , scalable_attention=a_)
lowercase :Union[str, Any] = make_state_dict(a_ , a_)
model.load_state_dict(a_ , strict=a_)
def lowerCamelCase (a_ :str , a_ :Optional[int] , a_ :Any , a_ :bool = False , a_ :bool = False , ) -> Tuple:
lowercase :Optional[int] = MTaConfig.from_json_file(a_)
print(F"""Building PyTorch model from configuration: {config}""")
# Non-v1.1 checkpoints could also use T5Model, but this works for all.
# The v1.0 checkpoints will simply have an LM head that is the word embeddings.
if is_encoder_only:
lowercase :Union[str, Any] = UMTaEncoderModel(a_)
else:
lowercase :int = UMTaForConditionalGeneration(a_)
# Load weights from tf checkpoint
load_tax_weights_in_ta(a_ , a_ , a_ , a_ , a_)
# Save pytorch-model
print(F"""Save PyTorch model to {pytorch_dump_path}""")
model.save_pretrained(a_)
# Verify that we can load the checkpoint.
model.from_pretrained(a_)
print('''Done''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser(description='''Converts a native T5X checkpoint into a PyTorch checkpoint.''')
# Required parameters
parser.add_argument(
'''--t5x_checkpoint_path''', default=None, type=str, required=True, help='''Path to the T5X checkpoint.'''
)
parser.add_argument(
'''--config_file''',
default=None,
type=str,
required=True,
help='''The config json file corresponding to the pre-trained T5 model.\nThis specifies the model architecture.''',
)
parser.add_argument(
'''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
)
parser.add_argument(
'''--is_encoder_only''', action='''store_true''', help='''Check if the model is encoder-decoder model''', default=False
)
parser.add_argument(
'''--scalable_attention''',
action='''store_true''',
help='''Whether the model uses scaled attention (umt5 model)''',
default=False,
)
UpperCAmelCase = parser.parse_args()
convert_tax_checkpoint_to_pytorch(
args.tax_checkpoint_path,
args.config_file,
args.pytorch_dump_path,
args.is_encoder_only,
args.scalable_attention,
)
| 677 | 1 |
"""simple docstring"""
from typing import List, Optional, TypeVar
from .arrow_dataset import Dataset, _concatenate_map_style_datasets, _interleave_map_style_datasets
from .dataset_dict import DatasetDict, IterableDatasetDict
from .info import DatasetInfo
from .iterable_dataset import IterableDataset, _concatenate_iterable_datasets, _interleave_iterable_datasets
from .splits import NamedSplit
from .utils import logging
from .utils.py_utils import Literal
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = TypeVar('''DatasetType''', Dataset, IterableDataset)
def lowerCamelCase (a_ :List[DatasetType] , a_ :Optional[List[float]] = None , a_ :Optional[int] = None , a_ :Optional[DatasetInfo] = None , a_ :Optional[NamedSplit] = None , a_ :Literal["first_exhausted", "all_exhausted"] = "first_exhausted" , ) -> DatasetType:
from .arrow_dataset import Dataset
from .iterable_dataset import IterableDataset
if not datasets:
raise ValueError('''Unable to interleave an empty list of datasets.''')
for i, dataset in enumerate(a_):
if not isinstance(a_ , (Dataset, IterableDataset)):
if isinstance(a_ , (DatasetDict, IterableDatasetDict)):
if not dataset:
raise ValueError(
F"""Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} """
'''is an empty dataset dictionary.''')
raise ValueError(
F"""Dataset at position {i} has at least one split: {list(a_)}\n"""
F"""Please pick one to interleave with the other datasets, for example: dataset['{next(iter(a_))}']""")
raise ValueError(
F"""Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} is a {type(a_).__name__}.""")
if i == 0:
lowercase , lowercase :str = (
(Dataset, IterableDataset) if isinstance(a_ , a_) else (IterableDataset, Dataset)
)
elif not isinstance(a_ , a_):
raise ValueError(
F"""Unable to interleave a {dataset_type.__name__} (at position 0) with a {other_type.__name__} (at position {i}). Expected a list of Dataset objects or a list of IterableDataset objects.""")
if stopping_strategy not in ["first_exhausted", "all_exhausted"]:
raise ValueError(F"""{stopping_strategy} is not supported. Please enter a valid stopping_strategy.""")
if dataset_type is Dataset:
return _interleave_map_style_datasets(
a_ , a_ , a_ , info=a_ , split=a_ , stopping_strategy=a_)
else:
return _interleave_iterable_datasets(
a_ , a_ , a_ , info=a_ , split=a_ , stopping_strategy=a_)
def lowerCamelCase (a_ :List[DatasetType] , a_ :Optional[DatasetInfo] = None , a_ :Optional[NamedSplit] = None , a_ :int = 0 , ) -> DatasetType:
if not dsets:
raise ValueError('''Unable to concatenate an empty list of datasets.''')
for i, dataset in enumerate(a_):
if not isinstance(a_ , (Dataset, IterableDataset)):
if isinstance(a_ , (DatasetDict, IterableDatasetDict)):
if not dataset:
raise ValueError(
F"""Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} """
'''is an empty dataset dictionary.''')
raise ValueError(
F"""Dataset at position {i} has at least one split: {list(a_)}\n"""
F"""Please pick one to interleave with the other datasets, for example: dataset['{next(iter(a_))}']""")
raise ValueError(
F"""Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} is a {type(a_).__name__}.""")
if i == 0:
lowercase , lowercase :Any = (
(Dataset, IterableDataset) if isinstance(a_ , a_) else (IterableDataset, Dataset)
)
elif not isinstance(a_ , a_):
raise ValueError(
F"""Unable to interleave a {dataset_type.__name__} (at position 0) with a {other_type.__name__} (at position {i}). Expected a list of Dataset objects or a list of IterableDataset objects.""")
if dataset_type is Dataset:
return _concatenate_map_style_datasets(a_ , info=a_ , split=a_ , axis=a_)
else:
return _concatenate_iterable_datasets(a_ , info=a_ , split=a_ , axis=a_)
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tf_available,
is_tokenizers_available,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_blenderbot''': [
'''BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''BlenderbotConfig''',
'''BlenderbotOnnxConfig''',
],
'''tokenization_blenderbot''': ['''BlenderbotTokenizer'''],
}
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''BlenderbotTokenizerFast''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''BlenderbotForCausalLM''',
'''BlenderbotForConditionalGeneration''',
'''BlenderbotModel''',
'''BlenderbotPreTrainedModel''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TFBlenderbotForConditionalGeneration''',
'''TFBlenderbotModel''',
'''TFBlenderbotPreTrainedModel''',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxBlenderbotForConditionalGeneration''',
'''FlaxBlenderbotModel''',
'''FlaxBlenderbotPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_blenderbot import (
BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP,
BlenderbotConfig,
BlenderbotOnnxConfig,
)
from .tokenization_blenderbot import BlenderbotTokenizer
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_blenderbot_fast import BlenderbotTokenizerFast
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_blenderbot import (
BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST,
BlenderbotForCausalLM,
BlenderbotForConditionalGeneration,
BlenderbotModel,
BlenderbotPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_blenderbot import (
TFBlenderbotForConditionalGeneration,
TFBlenderbotModel,
TFBlenderbotPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_blenderbot import (
FlaxBlenderbotForConditionalGeneration,
FlaxBlenderbotModel,
FlaxBlenderbotPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
import argparse
import json
import os
import time
import zipfile
from get_ci_error_statistics import download_artifact, get_artifacts_links
from transformers import logging
UpperCAmelCase = logging.get_logger(__name__)
def lowerCamelCase (a_ :Any , a_ :List[Any]) -> Union[str, Any]:
lowercase :Dict = set()
lowercase :Dict = []
def parse_line(a_ :List[str]):
for line in fp:
if isinstance(a_ , a_):
lowercase :Optional[Any] = line.decode('''UTF-8''')
if "warnings summary (final)" in line:
continue
# This means we are outside the body of a warning
elif not line.startswith(''' '''):
# process a single warning and move it to `selected_warnings`.
if len(a_) > 0:
lowercase :Union[str, Any] = '''\n'''.join(a_)
# Only keep the warnings specified in `targets`
if any(F""": {x}: """ in warning for x in targets):
selected_warnings.add(a_)
buffer.clear()
continue
else:
lowercase :str = line.strip()
buffer.append(a_)
if from_gh:
for filename in os.listdir(a_):
lowercase :Dict = os.path.join(a_ , a_)
if not os.path.isdir(a_):
# read the file
if filename != "warnings.txt":
continue
with open(a_) as fp:
parse_line(a_)
else:
try:
with zipfile.ZipFile(a_) as z:
for filename in z.namelist():
if not os.path.isdir(a_):
# read the file
if filename != "warnings.txt":
continue
with z.open(a_) as fp:
parse_line(a_)
except Exception:
logger.warning(
F"""{artifact_path} is either an invalid zip file or something else wrong. This file is skipped.""")
return selected_warnings
def lowerCamelCase (a_ :Dict , a_ :str) -> Union[str, Any]:
lowercase :List[Any] = set()
lowercase :int = [os.path.join(a_ , a_) for p in os.listdir(a_) if (p.endswith('''.zip''') or from_gh)]
for p in paths:
selected_warnings.update(extract_warnings_from_single_artifact(a_ , a_))
return selected_warnings
if __name__ == "__main__":
def lowerCamelCase (a_ :Dict) -> int:
return values.split(''',''')
UpperCAmelCase = argparse.ArgumentParser()
# Required parameters
parser.add_argument('''--workflow_run_id''', type=str, required=True, help='''A GitHub Actions workflow run id.''')
parser.add_argument(
'''--output_dir''',
type=str,
required=True,
help='''Where to store the downloaded artifacts and other result files.''',
)
parser.add_argument('''--token''', default=None, type=str, help='''A token that has actions:read permission.''')
# optional parameters
parser.add_argument(
'''--targets''',
default='''DeprecationWarning,UserWarning,FutureWarning''',
type=list_str,
help='''Comma-separated list of target warning(s) which we want to extract.''',
)
parser.add_argument(
'''--from_gh''',
action='''store_true''',
help='''If running from a GitHub action workflow and collecting warnings from its artifacts.''',
)
UpperCAmelCase = parser.parse_args()
UpperCAmelCase = args.from_gh
if from_gh:
# The artifacts have to be downloaded using `actions/download-artifact@v3`
pass
else:
os.makedirs(args.output_dir, exist_ok=True)
# get download links
UpperCAmelCase = get_artifacts_links(args.workflow_run_id, token=args.token)
with open(os.path.join(args.output_dir, '''artifacts.json'''), '''w''', encoding='''UTF-8''') as fp:
json.dump(artifacts, fp, ensure_ascii=False, indent=4)
# download artifacts
for idx, (name, url) in enumerate(artifacts.items()):
print(name)
print(url)
print('''=''' * 80)
download_artifact(name, url, args.output_dir, args.token)
# Be gentle to GitHub
time.sleep(1)
# extract warnings from artifacts
UpperCAmelCase = extract_warnings(args.output_dir, args.targets)
UpperCAmelCase = sorted(selected_warnings)
with open(os.path.join(args.output_dir, '''selected_warnings.json'''), '''w''', encoding='''UTF-8''') as fp:
json.dump(selected_warnings, fp, ensure_ascii=False, indent=4)
| 677 |
"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''naver-clova-ix/donut-base''': '''https://huggingface.co/naver-clova-ix/donut-base/resolve/main/config.json''',
# See all Donut models at https://huggingface.co/models?filter=donut-swin
}
class __magic_name__ ( __UpperCAmelCase ):
__A : Tuple = "donut-swin"
__A : Optional[Any] = {
"num_attention_heads": "num_heads",
"num_hidden_layers": "num_layers",
}
def __init__( self : List[str] , snake_case__ : Any=2_2_4 , snake_case__ : Tuple=4 , snake_case__ : str=3 , snake_case__ : Dict=9_6 , snake_case__ : Optional[Any]=[2, 2, 6, 2] , snake_case__ : Any=[3, 6, 1_2, 2_4] , snake_case__ : List[str]=7 , snake_case__ : Dict=4.0 , snake_case__ : str=True , snake_case__ : Optional[int]=0.0 , snake_case__ : Tuple=0.0 , snake_case__ : Any=0.1 , snake_case__ : List[str]="gelu" , snake_case__ : Tuple=False , snake_case__ : int=0.02 , snake_case__ : Optional[Any]=1e-5 , **snake_case__ : Any , ):
'''simple docstring'''
super().__init__(**snake_case__ )
lowercase :Union[str, Any] = image_size
lowercase :Optional[Any] = patch_size
lowercase :List[str] = num_channels
lowercase :Optional[int] = embed_dim
lowercase :Optional[Any] = depths
lowercase :List[Any] = len(snake_case__ )
lowercase :Optional[Any] = num_heads
lowercase :int = window_size
lowercase :str = mlp_ratio
lowercase :Optional[int] = qkv_bias
lowercase :Dict = hidden_dropout_prob
lowercase :Any = attention_probs_dropout_prob
lowercase :Any = drop_path_rate
lowercase :int = hidden_act
lowercase :int = use_absolute_embeddings
lowercase :List[str] = layer_norm_eps
lowercase :Union[str, Any] = initializer_range
# we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
# this indicates the channel dimension after the last stage of the model
lowercase :str = int(embed_dim * 2 ** (len(snake_case__ ) - 1) )
| 677 | 1 |
"""simple docstring"""
import argparse
import json
from pathlib import Path
import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from transformers import (
BertTokenizer,
ViltConfig,
ViltForImageAndTextRetrieval,
ViltForImagesAndTextClassification,
ViltForMaskedLM,
ViltForQuestionAnswering,
ViltImageProcessor,
ViltProcessor,
)
from transformers.utils import logging
logging.set_verbosity_info()
UpperCAmelCase = logging.get_logger(__name__)
def lowerCamelCase (a_ :Tuple , a_ :int=False , a_ :Optional[Any]=False , a_ :int=False) -> Union[str, Any]:
lowercase :Union[str, Any] = []
for i in range(config.num_hidden_layers):
# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
rename_keys.append((F"""transformer.blocks.{i}.norm1.weight""", F"""vilt.encoder.layer.{i}.layernorm_before.weight"""))
rename_keys.append((F"""transformer.blocks.{i}.norm1.bias""", F"""vilt.encoder.layer.{i}.layernorm_before.bias"""))
rename_keys.append(
(F"""transformer.blocks.{i}.attn.proj.weight""", F"""vilt.encoder.layer.{i}.attention.output.dense.weight"""))
rename_keys.append(
(F"""transformer.blocks.{i}.attn.proj.bias""", F"""vilt.encoder.layer.{i}.attention.output.dense.bias"""))
rename_keys.append((F"""transformer.blocks.{i}.norm2.weight""", F"""vilt.encoder.layer.{i}.layernorm_after.weight"""))
rename_keys.append((F"""transformer.blocks.{i}.norm2.bias""", F"""vilt.encoder.layer.{i}.layernorm_after.bias"""))
rename_keys.append(
(F"""transformer.blocks.{i}.mlp.fc1.weight""", F"""vilt.encoder.layer.{i}.intermediate.dense.weight"""))
rename_keys.append((F"""transformer.blocks.{i}.mlp.fc1.bias""", F"""vilt.encoder.layer.{i}.intermediate.dense.bias"""))
rename_keys.append((F"""transformer.blocks.{i}.mlp.fc2.weight""", F"""vilt.encoder.layer.{i}.output.dense.weight"""))
rename_keys.append((F"""transformer.blocks.{i}.mlp.fc2.bias""", F"""vilt.encoder.layer.{i}.output.dense.bias"""))
# embeddings
rename_keys.extend(
[
# text embeddings
('''text_embeddings.word_embeddings.weight''', '''vilt.embeddings.text_embeddings.word_embeddings.weight'''),
(
'''text_embeddings.position_embeddings.weight''',
'''vilt.embeddings.text_embeddings.position_embeddings.weight''',
),
('''text_embeddings.position_ids''', '''vilt.embeddings.text_embeddings.position_ids'''),
(
'''text_embeddings.token_type_embeddings.weight''',
'''vilt.embeddings.text_embeddings.token_type_embeddings.weight''',
),
('''text_embeddings.LayerNorm.weight''', '''vilt.embeddings.text_embeddings.LayerNorm.weight'''),
('''text_embeddings.LayerNorm.bias''', '''vilt.embeddings.text_embeddings.LayerNorm.bias'''),
# patch embeddings
('''transformer.cls_token''', '''vilt.embeddings.cls_token'''),
('''transformer.patch_embed.proj.weight''', '''vilt.embeddings.patch_embeddings.projection.weight'''),
('''transformer.patch_embed.proj.bias''', '''vilt.embeddings.patch_embeddings.projection.bias'''),
('''transformer.pos_embed''', '''vilt.embeddings.position_embeddings'''),
# token type embeddings
('''token_type_embeddings.weight''', '''vilt.embeddings.token_type_embeddings.weight'''),
])
# final layernorm + pooler
rename_keys.extend(
[
('''transformer.norm.weight''', '''vilt.layernorm.weight'''),
('''transformer.norm.bias''', '''vilt.layernorm.bias'''),
('''pooler.dense.weight''', '''vilt.pooler.dense.weight'''),
('''pooler.dense.bias''', '''vilt.pooler.dense.bias'''),
])
# classifier head(s)
if vqa_model:
# classification head
rename_keys.extend(
[
('''vqa_classifier.0.weight''', '''classifier.0.weight'''),
('''vqa_classifier.0.bias''', '''classifier.0.bias'''),
('''vqa_classifier.1.weight''', '''classifier.1.weight'''),
('''vqa_classifier.1.bias''', '''classifier.1.bias'''),
('''vqa_classifier.3.weight''', '''classifier.3.weight'''),
('''vqa_classifier.3.bias''', '''classifier.3.bias'''),
])
elif nlvr_model:
# classification head
rename_keys.extend(
[
('''nlvr2_classifier.0.weight''', '''classifier.0.weight'''),
('''nlvr2_classifier.0.bias''', '''classifier.0.bias'''),
('''nlvr2_classifier.1.weight''', '''classifier.1.weight'''),
('''nlvr2_classifier.1.bias''', '''classifier.1.bias'''),
('''nlvr2_classifier.3.weight''', '''classifier.3.weight'''),
('''nlvr2_classifier.3.bias''', '''classifier.3.bias'''),
])
else:
pass
return rename_keys
def lowerCamelCase (a_ :List[str] , a_ :Optional[Any]) -> Optional[int]:
for i in range(config.num_hidden_layers):
lowercase :str = '''vilt.'''
# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
lowercase :Union[str, Any] = state_dict.pop(F"""transformer.blocks.{i}.attn.qkv.weight""")
lowercase :Union[str, Any] = state_dict.pop(F"""transformer.blocks.{i}.attn.qkv.bias""")
# next, add query, keys and values (in that order) to the state dict
lowercase :Dict = in_proj_weight[
: config.hidden_size, :
]
lowercase :Optional[Any] = in_proj_bias[: config.hidden_size]
lowercase :Union[str, Any] = in_proj_weight[
config.hidden_size : config.hidden_size * 2, :
]
lowercase :Optional[Any] = in_proj_bias[
config.hidden_size : config.hidden_size * 2
]
lowercase :Optional[Any] = in_proj_weight[
-config.hidden_size :, :
]
lowercase :Optional[int] = in_proj_bias[-config.hidden_size :]
def lowerCamelCase (a_ :int) -> Any:
lowercase :Tuple = ['''head.weight''', '''head.bias''']
for k in ignore_keys:
state_dict.pop(a_ , a_)
def lowerCamelCase (a_ :Dict , a_ :Optional[Any] , a_ :Optional[int]) -> Any:
lowercase :Any = dct.pop(a_)
lowercase :str = val
@torch.no_grad()
def lowerCamelCase (a_ :Union[str, Any] , a_ :Any) -> List[str]:
lowercase :Any = ViltConfig(image_size=384 , patch_size=32 , tie_word_embeddings=a_)
lowercase :int = False
lowercase :Dict = False
lowercase :List[str] = False
lowercase :Union[str, Any] = False
if "vqa" in checkpoint_url:
lowercase :str = True
lowercase :int = 3129
lowercase :Any = '''huggingface/label-files'''
lowercase :Tuple = '''vqa2-id2label.json'''
lowercase :List[str] = json.load(open(hf_hub_download(a_ , a_ , repo_type='''dataset''') , '''r'''))
lowercase :Any = {int(a_): v for k, v in idalabel.items()}
lowercase :Any = idalabel
lowercase :List[str] = {v: k for k, v in idalabel.items()}
lowercase :Optional[Any] = ViltForQuestionAnswering(a_)
elif "nlvr" in checkpoint_url:
lowercase :List[Any] = True
lowercase :str = 2
lowercase :List[str] = {0: '''False''', 1: '''True'''}
lowercase :List[Any] = {v: k for k, v in config.idalabel.items()}
lowercase :Tuple = 3
lowercase :List[str] = ViltForImagesAndTextClassification(a_)
elif "irtr" in checkpoint_url:
lowercase :Union[str, Any] = True
lowercase :int = ViltForImageAndTextRetrieval(a_)
elif "mlm_itm" in checkpoint_url:
lowercase :Dict = True
lowercase :Optional[int] = ViltForMaskedLM(a_)
else:
raise ValueError('''Unknown model type''')
# load state_dict of original model, remove and rename some keys
lowercase :List[str] = torch.hub.load_state_dict_from_url(a_ , map_location='''cpu''')['''state_dict''']
lowercase :Tuple = create_rename_keys(a_ , a_ , a_ , a_)
for src, dest in rename_keys:
rename_key(a_ , a_ , a_)
read_in_q_k_v(a_ , a_)
if mlm_model or irtr_model:
lowercase :str = ['''itm_score.fc.weight''', '''itm_score.fc.bias''']
for k in ignore_keys:
state_dict.pop(a_ , a_)
# load state dict into HuggingFace model
model.eval()
if mlm_model:
lowercase , lowercase :Any = model.load_state_dict(a_ , strict=a_)
assert missing_keys == ["mlm_score.decoder.bias"]
else:
model.load_state_dict(a_)
# Define processor
lowercase :str = ViltImageProcessor(size=384)
lowercase :Optional[int] = BertTokenizer.from_pretrained('''bert-base-uncased''')
lowercase :Tuple = ViltProcessor(a_ , a_)
# Forward pass on example inputs (image + text)
if nlvr_model:
lowercase :Dict = Image.open(requests.get('''https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg''' , stream=a_).raw)
lowercase :str = Image.open(requests.get('''https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg''' , stream=a_).raw)
lowercase :Optional[int] = (
'''The left image contains twice the number of dogs as the right image, and at least two dogs in total are'''
''' standing.'''
)
lowercase :str = processor(a_ , a_ , return_tensors='''pt''')
lowercase :Optional[Any] = processor(a_ , a_ , return_tensors='''pt''')
lowercase :Optional[Any] = model(
input_ids=encoding_a.input_ids , pixel_values=encoding_a.pixel_values , pixel_values_a=encoding_a.pixel_values , )
else:
lowercase :str = Image.open(requests.get('''http://images.cocodataset.org/val2017/000000039769.jpg''' , stream=a_).raw)
if mlm_model:
lowercase :Tuple = '''a bunch of [MASK] laying on a [MASK].'''
else:
lowercase :Optional[Any] = '''How many cats are there?'''
lowercase :List[str] = processor(a_ , a_ , return_tensors='''pt''')
lowercase :List[str] = model(**a_)
# Verify outputs
if mlm_model:
lowercase :Any = torch.Size([1, 11, 3_0522])
lowercase :Dict = torch.tensor([-12.50_61, -12.51_23, -12.51_74])
assert outputs.logits.shape == expected_shape
assert torch.allclose(outputs.logits[0, 0, :3] , a_ , atol=1E-4)
# verify masked token prediction equals "cats"
lowercase :Any = outputs.logits[0, 4, :].argmax(-1).item()
assert tokenizer.decode([predicted_id]) == "cats"
elif vqa_model:
lowercase :str = torch.Size([1, 3129])
lowercase :Any = torch.tensor([-15.94_95, -18.14_72, -10.30_41])
assert torch.allclose(outputs.logits[0, :3] , a_ , atol=1E-4)
assert outputs.logits.shape == expected_shape
assert torch.allclose(outputs.logits[0, 0, :3] , a_ , atol=1E-4)
# verify vqa prediction equals "2"
lowercase :Any = outputs.logits.argmax(-1).item()
assert model.config.idalabel[predicted_idx] == "2"
elif nlvr_model:
lowercase :Optional[Any] = torch.Size([1, 2])
lowercase :Optional[int] = torch.tensor([-2.87_21, 2.12_91])
assert torch.allclose(outputs.logits[0, :3] , a_ , atol=1E-4)
assert outputs.logits.shape == expected_shape
Path(a_).mkdir(exist_ok=a_)
print(F"""Saving model and processor to {pytorch_dump_folder_path}""")
model.save_pretrained(a_)
processor.save_pretrained(a_)
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'''--checkpoint_url''',
default='''https://github.com/dandelin/ViLT/releases/download/200k/vilt_200k_mlm_itm.ckpt''',
type=str,
help='''URL of the checkpoint you\'d like to convert.''',
)
parser.add_argument(
'''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
)
UpperCAmelCase = parser.parse_args()
convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
| 677 |
"""simple docstring"""
import argparse
import os
import shutil
from pathlib import Path
import onnx
import torch
from packaging import version
from torch.onnx import export
from diffusers import OnnxRuntimeModel, OnnxStableDiffusionPipeline, StableDiffusionPipeline
UpperCAmelCase = version.parse(version.parse(torch.__version__).base_version) < version.parse('''1.11''')
def lowerCamelCase (a_ :Optional[int] , a_ :tuple , a_ :Path , a_ :str , a_ :int , a_ :List[Any] , a_ :Any , a_ :Union[str, Any]=False , ) -> Dict:
output_path.parent.mkdir(parents=a_ , exist_ok=a_)
# PyTorch deprecated the `enable_onnx_checker` and `use_external_data_format` arguments in v1.11,
# so we check the torch version for backwards compatibility
if is_torch_less_than_1_11:
export(
a_ , a_ , f=output_path.as_posix() , input_names=a_ , output_names=a_ , dynamic_axes=a_ , do_constant_folding=a_ , use_external_data_format=a_ , enable_onnx_checker=a_ , opset_version=a_ , )
else:
export(
a_ , a_ , f=output_path.as_posix() , input_names=a_ , output_names=a_ , dynamic_axes=a_ , do_constant_folding=a_ , opset_version=a_ , )
@torch.no_grad()
def lowerCamelCase (a_ :str , a_ :str , a_ :int , a_ :bool = False) -> Union[str, Any]:
lowercase :Any = torch.floataa if fpaa else torch.floataa
if fpaa and torch.cuda.is_available():
lowercase :Union[str, Any] = '''cuda'''
elif fpaa and not torch.cuda.is_available():
raise ValueError('''`float16` model export is only supported on GPUs with CUDA''')
else:
lowercase :List[str] = '''cpu'''
lowercase :List[str] = StableDiffusionPipeline.from_pretrained(a_ , torch_dtype=a_).to(a_)
lowercase :List[Any] = Path(a_)
# TEXT ENCODER
lowercase :List[Any] = pipeline.text_encoder.config.max_position_embeddings
lowercase :Dict = pipeline.text_encoder.config.hidden_size
lowercase :Union[str, Any] = pipeline.tokenizer(
'''A sample prompt''' , padding='''max_length''' , max_length=pipeline.tokenizer.model_max_length , truncation=a_ , return_tensors='''pt''' , )
onnx_export(
pipeline.text_encoder , model_args=(text_input.input_ids.to(device=a_ , dtype=torch.intaa)) , output_path=output_path / '''text_encoder''' / '''model.onnx''' , ordered_input_names=['''input_ids'''] , output_names=['''last_hidden_state''', '''pooler_output'''] , dynamic_axes={
'''input_ids''': {0: '''batch''', 1: '''sequence'''},
} , opset=a_ , )
del pipeline.text_encoder
# UNET
lowercase :Any = pipeline.unet.config.in_channels
lowercase :List[Any] = pipeline.unet.config.sample_size
lowercase :Optional[int] = output_path / '''unet''' / '''model.onnx'''
onnx_export(
pipeline.unet , model_args=(
torch.randn(2 , a_ , a_ , a_).to(device=a_ , dtype=a_),
torch.randn(2).to(device=a_ , dtype=a_),
torch.randn(2 , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=a_ , ordered_input_names=['''sample''', '''timestep''', '''encoder_hidden_states''', '''return_dict'''] , output_names=['''out_sample'''] , dynamic_axes={
'''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
'''timestep''': {0: '''batch'''},
'''encoder_hidden_states''': {0: '''batch''', 1: '''sequence'''},
} , opset=a_ , use_external_data_format=a_ , )
lowercase :List[Any] = str(unet_path.absolute().as_posix())
lowercase :str = os.path.dirname(a_)
lowercase :Optional[Any] = onnx.load(a_)
# clean up existing tensor files
shutil.rmtree(a_)
os.mkdir(a_)
# collate external tensor files into one
onnx.save_model(
a_ , a_ , save_as_external_data=a_ , all_tensors_to_one_file=a_ , location='''weights.pb''' , convert_attribute=a_ , )
del pipeline.unet
# VAE ENCODER
lowercase :Tuple = pipeline.vae
lowercase :Optional[Any] = vae_encoder.config.in_channels
lowercase :Any = vae_encoder.config.sample_size
# need to get the raw tensor output (sample) from the encoder
lowercase :Any = lambda a_ , a_: vae_encoder.encode(a_ , a_)[0].sample()
onnx_export(
a_ , model_args=(
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=output_path / '''vae_encoder''' / '''model.onnx''' , ordered_input_names=['''sample''', '''return_dict'''] , output_names=['''latent_sample'''] , dynamic_axes={
'''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
} , opset=a_ , )
# VAE DECODER
lowercase :Any = pipeline.vae
lowercase :Dict = vae_decoder.config.latent_channels
lowercase :Union[str, Any] = vae_decoder.config.out_channels
# forward only through the decoder part
lowercase :List[Any] = vae_encoder.decode
onnx_export(
a_ , model_args=(
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=output_path / '''vae_decoder''' / '''model.onnx''' , ordered_input_names=['''latent_sample''', '''return_dict'''] , output_names=['''sample'''] , dynamic_axes={
'''latent_sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
} , opset=a_ , )
del pipeline.vae
# SAFETY CHECKER
if pipeline.safety_checker is not None:
lowercase :Dict = pipeline.safety_checker
lowercase :str = safety_checker.config.vision_config.num_channels
lowercase :str = safety_checker.config.vision_config.image_size
lowercase :List[str] = safety_checker.forward_onnx
onnx_export(
pipeline.safety_checker , model_args=(
torch.randn(
1 , a_ , a_ , a_ , ).to(device=a_ , dtype=a_),
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
) , output_path=output_path / '''safety_checker''' / '''model.onnx''' , ordered_input_names=['''clip_input''', '''images'''] , output_names=['''out_images''', '''has_nsfw_concepts'''] , dynamic_axes={
'''clip_input''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
'''images''': {0: '''batch''', 1: '''height''', 2: '''width''', 3: '''channels'''},
} , opset=a_ , )
del pipeline.safety_checker
lowercase :Tuple = OnnxRuntimeModel.from_pretrained(output_path / '''safety_checker''')
lowercase :Optional[Any] = pipeline.feature_extractor
else:
lowercase :int = None
lowercase :Union[str, Any] = None
lowercase :Optional[int] = OnnxStableDiffusionPipeline(
vae_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_encoder''') , vae_decoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_decoder''') , text_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''text_encoder''') , tokenizer=pipeline.tokenizer , unet=OnnxRuntimeModel.from_pretrained(output_path / '''unet''') , scheduler=pipeline.scheduler , safety_checker=a_ , feature_extractor=a_ , requires_safety_checker=safety_checker is not None , )
onnx_pipeline.save_pretrained(a_)
print('''ONNX pipeline saved to''' , a_)
del pipeline
del onnx_pipeline
lowercase :Tuple = OnnxStableDiffusionPipeline.from_pretrained(a_ , provider='''CPUExecutionProvider''')
print('''ONNX pipeline is loadable''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
parser.add_argument(
'''--model_path''',
type=str,
required=True,
help='''Path to the `diffusers` checkpoint to convert (either a local directory or on the Hub).''',
)
parser.add_argument('''--output_path''', type=str, required=True, help='''Path to the output model.''')
parser.add_argument(
'''--opset''',
default=14,
type=int,
help='''The version of the ONNX operator set to use.''',
)
parser.add_argument('''--fp16''', action='''store_true''', default=False, help='''Export the models in `float16` mode''')
UpperCAmelCase = parser.parse_args()
convert_models(args.model_path, args.output_path, args.opset, args.fpaa)
| 677 | 1 |
"""simple docstring"""
import argparse
from collections import defaultdict
import yaml
UpperCAmelCase = '''docs/source/en/_toctree.yml'''
def lowerCamelCase (a_ :Optional[Any]) -> str:
lowercase :Dict = defaultdict(a_)
lowercase :List[str] = []
lowercase :List[str] = []
for doc in doc_list:
if "local" in doc:
counts[doc["local"]] += 1
if doc["title"].lower() == "overview":
overview_doc.append({'''local''': doc['''local'''], '''title''': doc['''title''']})
else:
new_doc_list.append(a_)
lowercase :Tuple = new_doc_list
lowercase :List[str] = [key for key, value in counts.items() if value > 1]
lowercase :Union[str, Any] = []
for duplicate_key in duplicates:
lowercase :List[Any] = list({doc['''title'''] for doc in doc_list if doc['''local'''] == duplicate_key})
if len(a_) > 1:
raise ValueError(
F"""{duplicate_key} is present several times in the documentation table of content at """
'''`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the '''
'''others.''')
# Only add this once
new_doc.append({'''local''': duplicate_key, '''title''': titles[0]})
# Add none duplicate-keys
new_doc.extend([doc for doc in doc_list if '''local''' not in counts or counts[doc['''local''']] == 1])
lowercase :Dict = sorted(a_ , key=lambda a_: s["title"].lower())
# "overview" gets special treatment and is always first
if len(a_) > 1:
raise ValueError('''{doc_list} has two \'overview\' docs which is not allowed.''')
overview_doc.extend(a_)
# Sort
return overview_doc
def lowerCamelCase (a_ :List[Any]=False) -> Optional[int]:
with open(a_ , encoding='''utf-8''') as f:
lowercase :Optional[Any] = yaml.safe_load(f.read())
# Get to the API doc
lowercase :Dict = 0
while content[api_idx]["title"] != "API":
api_idx += 1
lowercase :str = content[api_idx]['''sections''']
# Then to the model doc
lowercase :List[Any] = 0
while api_doc[scheduler_idx]["title"] != "Schedulers":
scheduler_idx += 1
lowercase :List[str] = api_doc[scheduler_idx]['''sections''']
lowercase :List[str] = clean_doc_toc(a_)
lowercase :Optional[Any] = False
if new_scheduler_doc != scheduler_doc:
lowercase :Dict = True
if overwrite:
lowercase :List[Any] = new_scheduler_doc
if diff:
if overwrite:
lowercase :List[Any] = api_doc
with open(a_ , '''w''' , encoding='''utf-8''') as f:
f.write(yaml.dump(a_ , allow_unicode=a_))
else:
raise ValueError(
'''The model doc part of the table of content is not properly sorted, run `make style` to fix this.''')
def lowerCamelCase (a_ :Optional[Any]=False) -> int:
with open(a_ , encoding='''utf-8''') as f:
lowercase :List[str] = yaml.safe_load(f.read())
# Get to the API doc
lowercase :Tuple = 0
while content[api_idx]["title"] != "API":
api_idx += 1
lowercase :Tuple = content[api_idx]['''sections''']
# Then to the model doc
lowercase :Tuple = 0
while api_doc[pipeline_idx]["title"] != "Pipelines":
pipeline_idx += 1
lowercase :Dict = False
lowercase :List[str] = api_doc[pipeline_idx]['''sections''']
lowercase :Tuple = []
# sort sub pipeline docs
for pipeline_doc in pipeline_docs:
if "section" in pipeline_doc:
lowercase :str = pipeline_doc['''section''']
lowercase :str = clean_doc_toc(a_)
if overwrite:
lowercase :str = new_sub_pipeline_doc
new_pipeline_docs.append(a_)
# sort overall pipeline doc
lowercase :Optional[Any] = clean_doc_toc(a_)
if new_pipeline_docs != pipeline_docs:
lowercase :List[str] = True
if overwrite:
lowercase :Any = new_pipeline_docs
if diff:
if overwrite:
lowercase :Optional[Any] = api_doc
with open(a_ , '''w''' , encoding='''utf-8''') as f:
f.write(yaml.dump(a_ , allow_unicode=a_))
else:
raise ValueError(
'''The model doc part of the table of content is not properly sorted, run `make style` to fix this.''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
parser.add_argument('''--fix_and_overwrite''', action='''store_true''', help='''Whether to fix inconsistencies.''')
UpperCAmelCase = parser.parse_args()
check_scheduler_doc(args.fix_and_overwrite)
check_pipeline_doc(args.fix_and_overwrite)
| 677 |
"""simple docstring"""
import itertools
import json
import linecache
import os
import pickle
import re
import socket
import string
from collections import Counter
from logging import getLogger
from pathlib import Path
from typing import Callable, Dict, Iterable, List
import git
import torch
from torch.utils.data import Dataset
from transformers import BartTokenizer, RagTokenizer, TaTokenizer
def lowerCamelCase (a_ :List[Any] , a_ :Union[str, Any] , a_ :Tuple , a_ :List[str] , a_ :str=True , a_ :str="pt") -> List[str]:
lowercase :Optional[int] = {'''add_prefix_space''': True} if isinstance(a_ , a_) and not line.startswith(''' ''') else {}
lowercase :Optional[int] = padding_side
return tokenizer(
[line] , max_length=a_ , padding='''max_length''' if pad_to_max_length else None , truncation=a_ , return_tensors=a_ , add_special_tokens=a_ , **a_ , )
def lowerCamelCase (a_ :str , a_ :Tuple , a_ :Optional[Any]=None , ) -> Tuple:
lowercase :Optional[Any] = input_ids.ne(a_).any(dim=0)
if attention_mask is None:
return input_ids[:, keep_column_mask]
else:
return (input_ids[:, keep_column_mask], attention_mask[:, keep_column_mask])
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Union[str, Any] , snake_case__ : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : str="train" , snake_case__ : Optional[Any]=None , snake_case__ : Tuple=None , snake_case__ : Any=None , snake_case__ : Dict="" , ):
'''simple docstring'''
super().__init__()
lowercase :Tuple = Path(snake_case__ ).joinpath(type_path + '''.source''' )
lowercase :Union[str, Any] = Path(snake_case__ ).joinpath(type_path + '''.target''' )
lowercase :List[Any] = self.get_char_lens(self.src_file )
lowercase :Tuple = max_source_length
lowercase :Optional[int] = max_target_length
assert min(self.src_lens ) > 0, f"""found empty line in {self.src_file}"""
lowercase :Any = tokenizer
lowercase :Tuple = prefix
if n_obs is not None:
lowercase :List[str] = self.src_lens[:n_obs]
lowercase :List[Any] = src_lang
lowercase :str = tgt_lang
def __len__( self : Any ):
'''simple docstring'''
return len(self.src_lens )
def __getitem__( self : str , snake_case__ : Any ):
'''simple docstring'''
lowercase :Optional[int] = index + 1 # linecache starts at 1
lowercase :Optional[Any] = self.prefix + linecache.getline(str(self.src_file ) , snake_case__ ).rstrip('''\n''' )
lowercase :Dict = linecache.getline(str(self.tgt_file ) , snake_case__ ).rstrip('''\n''' )
assert source_line, f"""empty source line for index {index}"""
assert tgt_line, f"""empty tgt line for index {index}"""
# Need to add eos token manually for T5
if isinstance(self.tokenizer , snake_case__ ):
source_line += self.tokenizer.eos_token
tgt_line += self.tokenizer.eos_token
# Pad source and target to the right
lowercase :Dict = (
self.tokenizer.question_encoder if isinstance(self.tokenizer , snake_case__ ) else self.tokenizer
)
lowercase :Optional[int] = self.tokenizer.generator if isinstance(self.tokenizer , snake_case__ ) else self.tokenizer
lowercase :Optional[int] = encode_line(snake_case__ , snake_case__ , self.max_source_length , '''right''' )
lowercase :Tuple = encode_line(snake_case__ , snake_case__ , self.max_target_length , '''right''' )
lowercase :List[str] = source_inputs['''input_ids'''].squeeze()
lowercase :Optional[Any] = target_inputs['''input_ids'''].squeeze()
lowercase :List[str] = source_inputs['''attention_mask'''].squeeze()
return {
"input_ids": source_ids,
"attention_mask": src_mask,
"decoder_input_ids": target_ids,
}
@staticmethod
def __snake_case ( snake_case__ : Optional[int] ):
'''simple docstring'''
return [len(snake_case__ ) for x in Path(snake_case__ ).open().readlines()]
def __snake_case ( self : Tuple , snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase :Optional[Any] = torch.stack([x['''input_ids'''] for x in batch] )
lowercase :Tuple = torch.stack([x['''attention_mask'''] for x in batch] )
lowercase :Tuple = torch.stack([x['''decoder_input_ids'''] for x in batch] )
lowercase :str = (
self.tokenizer.generator.pad_token_id
if isinstance(self.tokenizer , snake_case__ )
else self.tokenizer.pad_token_id
)
lowercase :Optional[int] = (
self.tokenizer.question_encoder.pad_token_id
if isinstance(self.tokenizer , snake_case__ )
else self.tokenizer.pad_token_id
)
lowercase :List[Any] = trim_batch(snake_case__ , snake_case__ )
lowercase , lowercase :List[str] = trim_batch(snake_case__ , snake_case__ , attention_mask=snake_case__ )
lowercase :Optional[int] = {
'''input_ids''': source_ids,
'''attention_mask''': source_mask,
'''decoder_input_ids''': y,
}
return batch
UpperCAmelCase = getLogger(__name__)
def lowerCamelCase (a_ :List[List]) -> Tuple:
return list(itertools.chain.from_iterable(a_))
def lowerCamelCase (a_ :str) -> None:
lowercase :List[str] = get_git_info()
save_json(a_ , os.path.join(a_ , '''git_log.json'''))
def lowerCamelCase (a_ :Optional[int] , a_ :Optional[int] , a_ :Optional[Any]=4 , **a_ :Optional[Any]) -> str:
with open(a_ , '''w''') as f:
json.dump(a_ , a_ , indent=a_ , **a_)
def lowerCamelCase (a_ :Dict) -> Union[str, Any]:
with open(a_) as f:
return json.load(a_)
def lowerCamelCase () -> List[str]:
lowercase :Dict = git.Repo(search_parent_directories=a_)
lowercase :int = {
'''repo_id''': str(a_),
'''repo_sha''': str(repo.head.object.hexsha),
'''repo_branch''': str(repo.active_branch),
'''hostname''': str(socket.gethostname()),
}
return repo_infos
def lowerCamelCase (a_ :Callable , a_ :Iterable) -> List:
return list(map(a_ , a_))
def lowerCamelCase (a_ :Optional[Any] , a_ :str) -> Any:
with open(a_ , '''wb''') as f:
return pickle.dump(a_ , a_)
def lowerCamelCase (a_ :List[str]) -> List[str]:
def remove_articles(a_ :Union[str, Any]):
return re.sub(R'''\b(a|an|the)\b''' , ''' ''' , a_)
def white_space_fix(a_ :Tuple):
return " ".join(text.split())
def remove_punc(a_ :int):
lowercase :List[Any] = set(string.punctuation)
return "".join(ch for ch in text if ch not in exclude)
def lower(a_ :int):
return text.lower()
return white_space_fix(remove_articles(remove_punc(lower(a_))))
def lowerCamelCase (a_ :List[str] , a_ :Any) -> List[str]:
lowercase :Dict = normalize_answer(a_).split()
lowercase :int = normalize_answer(a_).split()
lowercase :List[Any] = Counter(a_) & Counter(a_)
lowercase :Optional[int] = sum(common.values())
if num_same == 0:
return 0
lowercase :str = 1.0 * num_same / len(a_)
lowercase :Tuple = 1.0 * num_same / len(a_)
lowercase :Tuple = (2 * precision * recall) / (precision + recall)
return fa
def lowerCamelCase (a_ :Tuple , a_ :Optional[Any]) -> List[Any]:
return normalize_answer(a_) == normalize_answer(a_)
def lowerCamelCase (a_ :List[str] , a_ :List[str]) -> Dict:
assert len(a_) == len(a_)
lowercase :Any = 0
for hypo, pred in zip(a_ , a_):
em += exact_match_score(a_ , a_)
if len(a_) > 0:
em /= len(a_)
return {"em": em}
def lowerCamelCase (a_ :Union[str, Any]) -> Optional[Any]:
return model_prefix.startswith('''rag''')
def lowerCamelCase (a_ :List[str] , a_ :Tuple , a_ :List[str]) -> Any:
lowercase :List[str] = {p: p for p in extra_params}
# T5 models don't have `dropout` param, they have `dropout_rate` instead
lowercase :str = '''dropout_rate'''
for p in extra_params:
if getattr(a_ , a_ , a_):
if not hasattr(a_ , a_) and not hasattr(a_ , equivalent_param[p]):
logger.info('''config doesn\'t have a `{}` attribute'''.format(a_))
delattr(a_ , a_)
continue
lowercase :List[str] = p if hasattr(a_ , a_) else equivalent_param[p]
setattr(a_ , a_ , getattr(a_ , a_))
delattr(a_ , a_)
return hparams, config
| 677 | 1 |
"""simple docstring"""
from __future__ import annotations
class __magic_name__ :
def __init__( self : List[str] , snake_case__ : List[Any]=None ):
'''simple docstring'''
lowercase :List[Any] = data
lowercase :List[str] = None
def __repr__( self : Union[str, Any] ):
'''simple docstring'''
lowercase :int = []
lowercase :Any = self
while temp:
string_rep.append(f"""{temp.data}""" )
lowercase :Union[str, Any] = temp.next
return "->".join(snake_case__ )
def lowerCamelCase (a_ :list) -> Optional[int]:
if not elements_list:
raise Exception('''The Elements List is empty''')
lowercase :int = Node(elements_list[0])
for i in range(1 , len(a_)):
lowercase :Optional[int] = Node(elements_list[i])
lowercase :int = current.next
return head
def lowerCamelCase (a_ :Node) -> None:
if head_node is not None and isinstance(a_ , a_):
print_reverse(head_node.next)
print(head_node.data)
def lowerCamelCase () -> Union[str, Any]:
from doctest import testmod
testmod()
lowercase :Union[str, Any] = make_linked_list([14, 52, 14, 12, 43])
print('''Linked List:''')
print(a_)
print('''Elements in Reverse:''')
print_reverse(a_)
if __name__ == "__main__":
main()
| 677 |
"""simple docstring"""
def lowerCamelCase (a_ :Tuple , a_ :int , a_ :Tuple , a_ :List[Any]) -> str:
if height >= 1:
move_tower(height - 1 , a_ , a_ , a_)
move_disk(a_ , a_)
move_tower(height - 1 , a_ , a_ , a_)
def lowerCamelCase (a_ :int , a_ :Union[str, Any]) -> str:
print('''moving disk from''' , a_ , '''to''' , a_)
def lowerCamelCase () -> Tuple:
lowercase :int = int(input('''Height of hanoi: ''').strip())
move_tower(a_ , '''A''' , '''B''' , '''C''')
if __name__ == "__main__":
main()
| 677 | 1 |
"""simple docstring"""
UpperCAmelCase = {
'''meter''': '''m''',
'''kilometer''': '''km''',
'''megametre''': '''Mm''',
'''gigametre''': '''Gm''',
'''terametre''': '''Tm''',
'''petametre''': '''Pm''',
'''exametre''': '''Em''',
'''zettametre''': '''Zm''',
'''yottametre''': '''Ym''',
}
# Exponent of the factor(meter)
UpperCAmelCase = {
'''m''': 0,
'''km''': 3,
'''Mm''': 6,
'''Gm''': 9,
'''Tm''': 12,
'''Pm''': 15,
'''Em''': 18,
'''Zm''': 21,
'''Ym''': 24,
}
def lowerCamelCase (a_ :float , a_ :str , a_ :str) -> float:
lowercase :int = from_type.lower().strip('''s''')
lowercase :Optional[Any] = to_type.lower().strip('''s''')
lowercase :Any = UNIT_SYMBOL.get(a_ , a_)
lowercase :List[Any] = UNIT_SYMBOL.get(a_ , a_)
if from_sanitized not in METRIC_CONVERSION:
lowercase :int = (
F"""Invalid 'from_type' value: {from_type!r}.\n"""
F"""Conversion abbreviations are: {', '.join(a_)}"""
)
raise ValueError(a_)
if to_sanitized not in METRIC_CONVERSION:
lowercase :Optional[int] = (
F"""Invalid 'to_type' value: {to_type!r}.\n"""
F"""Conversion abbreviations are: {', '.join(a_)}"""
)
raise ValueError(a_)
lowercase :List[Any] = METRIC_CONVERSION[from_sanitized]
lowercase :str = METRIC_CONVERSION[to_sanitized]
lowercase :Dict = 1
if from_exponent > to_exponent:
lowercase :Union[str, Any] = from_exponent - to_exponent
else:
lowercase :Optional[int] = -(to_exponent - from_exponent)
return value * pow(10 , a_)
if __name__ == "__main__":
from doctest import testmod
testmod()
| 677 |
"""simple docstring"""
from sklearn.metrics import mean_squared_error
import datasets
UpperCAmelCase = '''\
@article{scikit-learn,
title={Scikit-learn: Machine Learning in {P}ython},
author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
journal={Journal of Machine Learning Research},
volume={12},
pages={2825--2830},
year={2011}
}
'''
UpperCAmelCase = '''\
Mean Squared Error(MSE) is the average of the square of difference between the predicted
and actual values.
'''
UpperCAmelCase = '''
Args:
predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)
Estimated target values.
references: array-like of shape (n_samples,) or (n_samples, n_outputs)
Ground truth (correct) target values.
sample_weight: array-like of shape (n_samples,), default=None
Sample weights.
multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"
Defines aggregating of multiple output values. Array-like value defines weights used to average errors.
"raw_values" : Returns a full set of errors in case of multioutput input.
"uniform_average" : Errors of all outputs are averaged with uniform weight.
squared : bool, default=True
If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.
Returns:
mse : mean squared error.
Examples:
>>> mse_metric = datasets.load_metric("mse")
>>> predictions = [2.5, 0.0, 2, 8]
>>> references = [3, -0.5, 2, 7]
>>> results = mse_metric.compute(predictions=predictions, references=references)
>>> print(results)
{\'mse\': 0.375}
>>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)
>>> print(rmse_result)
{\'mse\': 0.6123724356957945}
If you\'re using multi-dimensional lists, then set the config as follows :
>>> mse_metric = datasets.load_metric("mse", "multilist")
>>> predictions = [[0.5, 1], [-1, 1], [7, -6]]
>>> references = [[0, 2], [-1, 2], [8, -5]]
>>> results = mse_metric.compute(predictions=predictions, references=references)
>>> print(results)
{\'mse\': 0.7083333333333334}
>>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')
>>> print(results) # doctest: +NORMALIZE_WHITESPACE
{\'mse\': array([0.41666667, 1. ])}
'''
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class __magic_name__ ( datasets.Metric ):
def __snake_case ( self : int ):
'''simple docstring'''
return datasets.MetricInfo(
description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(self._get_feature_types() ) , reference_urls=[
'''https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html'''
] , )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
if self.config_name == "multilist":
return {
"predictions": datasets.Sequence(datasets.Value('''float''' ) ),
"references": datasets.Sequence(datasets.Value('''float''' ) ),
}
else:
return {
"predictions": datasets.Value('''float''' ),
"references": datasets.Value('''float''' ),
}
def __snake_case ( self : List[Any] , snake_case__ : str , snake_case__ : int , snake_case__ : str=None , snake_case__ : List[Any]="uniform_average" , snake_case__ : Dict=True ):
'''simple docstring'''
lowercase :Dict = mean_squared_error(
snake_case__ , snake_case__ , sample_weight=snake_case__ , multioutput=snake_case__ , squared=snake_case__ )
return {"mse": mse}
| 677 | 1 |
"""simple docstring"""
import inspect
import math
import tempfile
import unittest
import numpy as np
from transformers import ViTMAEConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin
if is_torch_available():
import torch
from torch import nn
from transformers import ViTMAEForPreTraining, ViTMAEModel
from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST
if is_vision_available():
from PIL import Image
from transformers import ViTImageProcessor
class __magic_name__ :
def __init__( self : Optional[Any] , snake_case__ : List[str] , snake_case__ : Tuple=1_3 , snake_case__ : Any=3_0 , snake_case__ : List[Any]=2 , snake_case__ : Optional[Any]=3 , snake_case__ : int=True , snake_case__ : Tuple=True , snake_case__ : Optional[int]=3_2 , snake_case__ : str=5 , snake_case__ : List[Any]=4 , snake_case__ : Tuple=3_7 , snake_case__ : Optional[Any]="gelu" , snake_case__ : Any=0.1 , snake_case__ : Optional[Any]=0.1 , snake_case__ : int=1_0 , snake_case__ : Optional[Any]=0.02 , snake_case__ : Dict=3 , snake_case__ : List[Any]=0.6 , snake_case__ : List[str]=None , ):
'''simple docstring'''
lowercase :Any = parent
lowercase :List[str] = batch_size
lowercase :str = image_size
lowercase :Union[str, Any] = patch_size
lowercase :Union[str, Any] = num_channels
lowercase :int = is_training
lowercase :int = use_labels
lowercase :int = hidden_size
lowercase :str = num_hidden_layers
lowercase :Any = num_attention_heads
lowercase :Union[str, Any] = intermediate_size
lowercase :str = hidden_act
lowercase :Dict = hidden_dropout_prob
lowercase :Optional[int] = attention_probs_dropout_prob
lowercase :List[str] = type_sequence_label_size
lowercase :int = initializer_range
lowercase :Optional[int] = mask_ratio
lowercase :Optional[int] = scope
# in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
# (we add 1 for the [CLS] token)
lowercase :Tuple = (image_size // patch_size) ** 2
lowercase :Optional[int] = int(math.ceil((1 - mask_ratio) * (num_patches + 1) ) )
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Any = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
lowercase :List[Any] = None
if self.use_labels:
lowercase :int = ids_tensor([self.batch_size] , self.type_sequence_label_size )
lowercase :Any = self.get_config()
return config, pixel_values, labels
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
return ViTMAEConfig(
image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , 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 , is_decoder=snake_case__ , initializer_range=self.initializer_range , mask_ratio=self.mask_ratio , )
def __snake_case ( self : List[str] , snake_case__ : Any , snake_case__ : List[Any] , snake_case__ : List[Any] ):
'''simple docstring'''
lowercase :List[str] = ViTMAEModel(config=snake_case__ )
model.to(snake_case__ )
model.eval()
lowercase :List[Any] = model(snake_case__ )
self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) )
def __snake_case ( self : Optional[int] , snake_case__ : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : int ):
'''simple docstring'''
lowercase :Optional[int] = ViTMAEForPreTraining(snake_case__ )
model.to(snake_case__ )
model.eval()
lowercase :Union[str, Any] = model(snake_case__ )
lowercase :Tuple = (self.image_size // self.patch_size) ** 2
lowercase :int = self.patch_size**2 * self.num_channels
self.parent.assertEqual(result.logits.shape , (self.batch_size, num_patches, expected_num_channels) )
# test greyscale images
lowercase :List[Any] = 1
lowercase :int = ViTMAEForPreTraining(snake_case__ )
model.to(snake_case__ )
model.eval()
lowercase :Tuple = floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
lowercase :List[Any] = model(snake_case__ )
lowercase :Dict = self.patch_size**2
self.parent.assertEqual(result.logits.shape , (self.batch_size, num_patches, expected_num_channels) )
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :List[str] = self.prepare_config_and_inputs()
lowercase , lowercase , lowercase :Tuple = config_and_inputs
lowercase :Tuple = {'''pixel_values''': pixel_values}
return config, inputs_dict
@require_torch
class __magic_name__ ( __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
__A : Optional[int] = (ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else ()
__A : Tuple = {"feature-extraction": ViTMAEModel} if is_torch_available() else {}
__A : Dict = False
__A : Optional[int] = False
__A : Union[str, Any] = False
__A : Any = False
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :Any = ViTMAEModelTester(self )
lowercase :Optional[Any] = ConfigTester(self , config_class=snake_case__ , has_text_modality=snake_case__ , hidden_size=3_7 )
def __snake_case ( self : int ):
'''simple docstring'''
self.config_tester.run_common_tests()
@unittest.skip(reason='''ViTMAE does not use inputs_embeds''' )
def __snake_case ( self : Tuple ):
'''simple docstring'''
pass
def __snake_case ( self : str ):
'''simple docstring'''
lowercase , lowercase :str = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :int = model_class(snake_case__ )
self.assertIsInstance(model.get_input_embeddings() , (nn.Module) )
lowercase :str = model.get_output_embeddings()
self.assertTrue(x is None or isinstance(snake_case__ , nn.Linear ) )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase , lowercase :str = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :Tuple = model_class(snake_case__ )
lowercase :int = inspect.signature(model.forward )
# signature.parameters is an OrderedDict => so arg_names order is deterministic
lowercase :str = [*signature.parameters.keys()]
lowercase :List[Any] = ['''pixel_values''']
self.assertListEqual(arg_names[:1] , snake_case__ )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :List[str] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*snake_case__ )
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_pretraining(*snake_case__ )
def __snake_case ( self : str , snake_case__ : Optional[Any] , snake_case__ : Union[str, Any] , snake_case__ : Any ):
'''simple docstring'''
np.random.seed(2 )
lowercase :Optional[int] = int((pt_model.config.image_size // pt_model.config.patch_size) ** 2 )
lowercase :Any = np.random.uniform(size=(self.model_tester.batch_size, num_patches) )
lowercase :int = torch.from_numpy(snake_case__ )
# Add `noise` argument.
# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
lowercase :List[Any] = pt_noise
super().check_pt_tf_models(snake_case__ , snake_case__ , snake_case__ )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase , lowercase :Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :int = model_class(snake_case__ )
model.to(snake_case__ )
model.eval()
# make random mask reproducible
torch.manual_seed(2 )
with torch.no_grad():
lowercase :Union[str, Any] = model(**self._prepare_for_class(snake_case__ , snake_case__ ) )
lowercase :Any = outputs[0].cpu().numpy()
lowercase :Any = 0
with tempfile.TemporaryDirectory() as tmpdirname:
model.save_pretrained(snake_case__ )
lowercase :str = model_class.from_pretrained(snake_case__ )
model.to(snake_case__ )
# make random mask reproducible
torch.manual_seed(2 )
with torch.no_grad():
lowercase :List[str] = model(**self._prepare_for_class(snake_case__ , snake_case__ ) )
# Make sure we don't have nans
lowercase :str = after_outputs[0].cpu().numpy()
lowercase :Tuple = 0
lowercase :Any = np.amax(np.abs(out_a - out_a ) )
self.assertLessEqual(snake_case__ , 1e-5 )
@unittest.skip(
reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
to get deterministic results.''' )
def __snake_case ( self : int ):
'''simple docstring'''
pass
@unittest.skip(
reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
to get deterministic results.''' )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
pass
@unittest.skip(
reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
to get deterministic results.''' )
def __snake_case ( self : Tuple ):
'''simple docstring'''
pass
@unittest.skip(reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load''' )
def __snake_case ( self : str ):
'''simple docstring'''
pass
@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''' )
def __snake_case ( self : str ):
'''simple docstring'''
pass
@slow
def __snake_case ( self : List[str] ):
'''simple docstring'''
for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
lowercase :Optional[int] = ViTMAEModel.from_pretrained(snake_case__ )
self.assertIsNotNone(snake_case__ )
def lowerCamelCase () -> Union[str, Any]:
lowercase :Optional[int] = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
return image
@require_torch
@require_vision
class __magic_name__ ( unittest.TestCase ):
@cached_property
def __snake_case ( self : List[Any] ):
'''simple docstring'''
return ViTImageProcessor.from_pretrained('''facebook/vit-mae-base''' ) if is_vision_available() else None
@slow
def __snake_case ( self : Dict ):
'''simple docstring'''
np.random.seed(2 )
lowercase :Union[str, Any] = ViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base''' ).to(snake_case__ )
lowercase :Tuple = self.default_image_processor
lowercase :Optional[int] = prepare_img()
lowercase :Any = image_processor(images=snake_case__ , return_tensors='''pt''' ).to(snake_case__ )
# prepare a noise vector that will be also used for testing the TF model
# (this way we can ensure that the PT and TF models operate on the same inputs)
lowercase :Union[str, Any] = ViTMAEConfig()
lowercase :Optional[int] = int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2 )
lowercase :Any = np.random.uniform(size=(1, num_patches) )
# forward pass
with torch.no_grad():
lowercase :int = model(**snake_case__ , noise=torch.from_numpy(snake_case__ ).to(device=snake_case__ ) )
# verify the logits
lowercase :Dict = torch.Size((1, 1_9_6, 7_6_8) )
self.assertEqual(outputs.logits.shape , snake_case__ )
lowercase :str = torch.tensor(
[[-0.05_48, -1.70_23, -0.93_25], [0.37_21, -0.56_70, -0.22_33], [0.82_35, -1.38_78, -0.35_24]] )
self.assertTrue(torch.allclose(outputs.logits[0, :3, :3] , expected_slice.to(snake_case__ ) , atol=1e-4 ) )
| 677 |
"""simple docstring"""
from abc import ABC, abstractmethod
from argparse import ArgumentParser
class __magic_name__ ( __UpperCAmelCase ):
@staticmethod
@abstractmethod
def __snake_case ( snake_case__ : ArgumentParser ):
'''simple docstring'''
raise NotImplementedError()
@abstractmethod
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
raise NotImplementedError()
| 677 | 1 |
"""simple docstring"""
import inspect
import unittest
from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available
from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor
if is_flax_available():
import jax
import jax.numpy as jnp
from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel
if is_vision_available():
from PIL import Image
from transformers import AutoImageProcessor
class __magic_name__ ( unittest.TestCase ):
def __init__( self : List[Any] , snake_case__ : Optional[int] , snake_case__ : List[str]=3 , snake_case__ : int=3_2 , snake_case__ : int=3 , snake_case__ : str=1_0 , snake_case__ : str=[1_0, 2_0, 3_0, 4_0] , snake_case__ : int=[1, 1, 2, 1] , snake_case__ : List[Any]=True , snake_case__ : Tuple=True , snake_case__ : Optional[Any]="relu" , snake_case__ : Optional[int]=3 , snake_case__ : Optional[Any]=None , ):
'''simple docstring'''
lowercase :Union[str, Any] = parent
lowercase :Optional[Any] = batch_size
lowercase :Dict = image_size
lowercase :Any = num_channels
lowercase :List[str] = embeddings_size
lowercase :Union[str, Any] = hidden_sizes
lowercase :Any = depths
lowercase :Dict = is_training
lowercase :Any = use_labels
lowercase :Any = hidden_act
lowercase :List[str] = num_labels
lowercase :List[Any] = scope
lowercase :int = len(snake_case__ )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :Optional[int] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
lowercase :Union[str, Any] = self.get_config()
return config, pixel_values
def __snake_case ( self : Dict ):
'''simple docstring'''
return RegNetConfig(
num_channels=self.num_channels , embeddings_size=self.embeddings_size , hidden_sizes=self.hidden_sizes , depths=self.depths , hidden_act=self.hidden_act , num_labels=self.num_labels , image_size=self.image_size , )
def __snake_case ( self : str , snake_case__ : Tuple , snake_case__ : List[Any] ):
'''simple docstring'''
lowercase :Any = FlaxRegNetModel(config=snake_case__ )
lowercase :str = model(snake_case__ )
# Output shape (b, c, h, w)
self.parent.assertEqual(
result.last_hidden_state.shape , (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2) , )
def __snake_case ( self : List[str] , snake_case__ : Optional[int] , snake_case__ : str ):
'''simple docstring'''
lowercase :Tuple = self.num_labels
lowercase :str = FlaxRegNetForImageClassification(config=snake_case__ )
lowercase :Union[str, Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :int = self.prepare_config_and_inputs()
lowercase , lowercase :Tuple = config_and_inputs
lowercase :Union[str, Any] = {'''pixel_values''': pixel_values}
return config, inputs_dict
@require_flax
class __magic_name__ ( __UpperCAmelCase , unittest.TestCase ):
__A : List[Any] = (FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()
__A : str = False
__A : Tuple = False
__A : Dict = False
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :Dict = FlaxRegNetModelTester(self )
lowercase :Tuple = ConfigTester(self , config_class=snake_case__ , has_text_modality=snake_case__ )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
self.create_and_test_config_common_properties()
self.config_tester.create_and_test_config_to_json_string()
self.config_tester.create_and_test_config_to_json_file()
self.config_tester.create_and_test_config_from_and_save_pretrained()
self.config_tester.create_and_test_config_with_num_labels()
self.config_tester.check_config_can_be_init_without_params()
self.config_tester.check_config_arguments_init()
def __snake_case ( self : List[Any] ):
'''simple docstring'''
return
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :Dict = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_image_classification(*snake_case__ )
@unittest.skip(reason='''RegNet does not use inputs_embeds''' )
def __snake_case ( self : Tuple ):
'''simple docstring'''
pass
@unittest.skip(reason='''RegNet does not support input and output embeddings''' )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
pass
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :Union[str, Any] = model_class(snake_case__ )
lowercase :int = inspect.signature(model.__call__ )
# signature.parameters is an OrderedDict => so arg_names order is deterministic
lowercase :Tuple = [*signature.parameters.keys()]
lowercase :Tuple = ['''pixel_values''']
self.assertListEqual(arg_names[:1] , snake_case__ )
def __snake_case ( self : Tuple ):
'''simple docstring'''
def check_hidden_states_output(snake_case__ : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[int] ):
lowercase :int = model_class(snake_case__ )
lowercase :Tuple = model(**self._prepare_for_class(snake_case__ , snake_case__ ) )
lowercase :Any = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
lowercase :Dict = self.model_tester.num_stages
self.assertEqual(len(snake_case__ ) , expected_num_stages + 1 )
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :Optional[int] = True
check_hidden_states_output(snake_case__ , snake_case__ , snake_case__ )
# check that output_hidden_states also work using config
del inputs_dict["output_hidden_states"]
lowercase :str = True
check_hidden_states_output(snake_case__ , snake_case__ , snake_case__ )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
with self.subTest(model_class.__name__ ):
lowercase :Optional[Any] = self._prepare_for_class(snake_case__ , snake_case__ )
lowercase :List[Any] = model_class(snake_case__ )
@jax.jit
def model_jitted(snake_case__ : str , **snake_case__ : Optional[int] ):
return model(pixel_values=snake_case__ , **snake_case__ )
with self.subTest('''JIT Enabled''' ):
lowercase :Optional[int] = model_jitted(**snake_case__ ).to_tuple()
with self.subTest('''JIT Disabled''' ):
with jax.disable_jit():
lowercase :Optional[int] = model_jitted(**snake_case__ ).to_tuple()
self.assertEqual(len(snake_case__ ) , len(snake_case__ ) )
for jitted_output, output in zip(snake_case__ , snake_case__ ):
self.assertEqual(jitted_output.shape , output.shape )
def lowerCamelCase () -> Tuple:
lowercase :Tuple = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
return image
@require_flax
class __magic_name__ ( unittest.TestCase ):
@cached_property
def __snake_case ( self : int ):
'''simple docstring'''
return AutoImageProcessor.from_pretrained('''facebook/regnet-y-040''' ) if is_vision_available() else None
@slow
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :int = FlaxRegNetForImageClassification.from_pretrained('''facebook/regnet-y-040''' )
lowercase :Optional[Any] = self.default_image_processor
lowercase :Dict = prepare_img()
lowercase :Any = image_processor(images=snake_case__ , return_tensors='''np''' )
lowercase :List[str] = model(**snake_case__ )
# verify the logits
lowercase :Any = (1, 1_0_0_0)
self.assertEqual(outputs.logits.shape , snake_case__ )
lowercase :List[Any] = jnp.array([-0.41_80, -1.50_51, -3.48_36] )
self.assertTrue(jnp.allclose(outputs.logits[0, :3] , snake_case__ , atol=1e-4 ) )
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_encodec''': [
'''ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''EncodecConfig''',
],
'''feature_extraction_encodec''': ['''EncodecFeatureExtractor'''],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''EncodecModel''',
'''EncodecPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_encodec import (
ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP,
EncodecConfig,
)
from .feature_extraction_encodec import EncodecFeatureExtractor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_encodec import (
ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST,
EncodecModel,
EncodecPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
import inspect
import os
import unittest
from dataclasses import dataclass
import torch
from accelerate import Accelerator, DistributedDataParallelKwargs, GradScalerKwargs
from accelerate.state import AcceleratorState
from accelerate.test_utils import execute_subprocess_async, require_cuda, require_multi_gpu
from accelerate.utils import KwargsHandler
@dataclass
class __magic_name__ ( __UpperCAmelCase ):
__A : int = 0
__A : bool = False
__A : float = 3.0
class __magic_name__ ( unittest.TestCase ):
def __snake_case ( self : List[str] ):
'''simple docstring'''
self.assertDictEqual(MockClass().to_kwargs() , {} )
self.assertDictEqual(MockClass(a=2 ).to_kwargs() , {'''a''': 2} )
self.assertDictEqual(MockClass(a=2 , b=snake_case__ ).to_kwargs() , {'''a''': 2, '''b''': True} )
self.assertDictEqual(MockClass(a=2 , c=2.25 ).to_kwargs() , {'''a''': 2, '''c''': 2.25} )
@require_cuda
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Dict = GradScalerKwargs(init_scale=1_0_2_4 , growth_factor=2 )
AcceleratorState._reset_state()
lowercase :int = Accelerator(mixed_precision='''fp16''' , kwargs_handlers=[scaler_handler] )
print(accelerator.use_fpaa )
lowercase :List[Any] = accelerator.scaler
# Check the kwargs have been applied
self.assertEqual(scaler._init_scale , 10_24.0 )
self.assertEqual(scaler._growth_factor , 2.0 )
# Check the other values are at the default
self.assertEqual(scaler._backoff_factor , 0.5 )
self.assertEqual(scaler._growth_interval , 2_0_0_0 )
self.assertEqual(scaler._enabled , snake_case__ )
@require_multi_gpu
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Dict = ['''torchrun''', f"""--nproc_per_node={torch.cuda.device_count()}""", inspect.getfile(self.__class__ )]
execute_subprocess_async(snake_case__ , env=os.environ.copy() )
if __name__ == "__main__":
UpperCAmelCase = DistributedDataParallelKwargs(bucket_cap_mb=15, find_unused_parameters=True)
UpperCAmelCase = Accelerator(kwargs_handlers=[ddp_scaler])
UpperCAmelCase = torch.nn.Linear(100, 200)
UpperCAmelCase = accelerator.prepare(model)
# Check the values changed in kwargs
UpperCAmelCase = ''''''
UpperCAmelCase = model.bucket_bytes_cap // (1_024 * 1_024)
if observed_bucket_cap_map != 15:
error_msg += F"Kwargs badly passed, should have `15` but found {observed_bucket_cap_map}.\n"
if model.find_unused_parameters is not True:
error_msg += F"Kwargs badly passed, should have `True` but found {model.find_unused_parameters}.\n"
# Check the values of the defaults
if model.dim != 0:
error_msg += F"Default value not respected, should have `0` but found {model.dim}.\n"
if model.broadcast_buffers is not True:
error_msg += F"Default value not respected, should have `True` but found {model.broadcast_buffers}.\n"
if model.gradient_as_bucket_view is not False:
error_msg += F"Default value not respected, should have `False` but found {model.gradient_as_bucket_view}.\n"
# Raise error at the end to make sure we don't stop at the first failure.
if len(error_msg) > 0:
raise ValueError(error_msg)
| 677 |
"""simple docstring"""
import inspect
import unittest
from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available
from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor
if is_flax_available():
import jax
import jax.numpy as jnp
from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel
if is_vision_available():
from PIL import Image
from transformers import AutoImageProcessor
class __magic_name__ ( unittest.TestCase ):
def __init__( self : List[Any] , snake_case__ : Optional[int] , snake_case__ : List[str]=3 , snake_case__ : int=3_2 , snake_case__ : int=3 , snake_case__ : str=1_0 , snake_case__ : str=[1_0, 2_0, 3_0, 4_0] , snake_case__ : int=[1, 1, 2, 1] , snake_case__ : List[Any]=True , snake_case__ : Tuple=True , snake_case__ : Optional[Any]="relu" , snake_case__ : Optional[int]=3 , snake_case__ : Optional[Any]=None , ):
'''simple docstring'''
lowercase :Union[str, Any] = parent
lowercase :Optional[Any] = batch_size
lowercase :Dict = image_size
lowercase :Any = num_channels
lowercase :List[str] = embeddings_size
lowercase :Union[str, Any] = hidden_sizes
lowercase :Any = depths
lowercase :Dict = is_training
lowercase :Any = use_labels
lowercase :Any = hidden_act
lowercase :List[str] = num_labels
lowercase :List[Any] = scope
lowercase :int = len(snake_case__ )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :Optional[int] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
lowercase :Union[str, Any] = self.get_config()
return config, pixel_values
def __snake_case ( self : Dict ):
'''simple docstring'''
return RegNetConfig(
num_channels=self.num_channels , embeddings_size=self.embeddings_size , hidden_sizes=self.hidden_sizes , depths=self.depths , hidden_act=self.hidden_act , num_labels=self.num_labels , image_size=self.image_size , )
def __snake_case ( self : str , snake_case__ : Tuple , snake_case__ : List[Any] ):
'''simple docstring'''
lowercase :Any = FlaxRegNetModel(config=snake_case__ )
lowercase :str = model(snake_case__ )
# Output shape (b, c, h, w)
self.parent.assertEqual(
result.last_hidden_state.shape , (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2) , )
def __snake_case ( self : List[str] , snake_case__ : Optional[int] , snake_case__ : str ):
'''simple docstring'''
lowercase :Tuple = self.num_labels
lowercase :str = FlaxRegNetForImageClassification(config=snake_case__ )
lowercase :Union[str, Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :int = self.prepare_config_and_inputs()
lowercase , lowercase :Tuple = config_and_inputs
lowercase :Union[str, Any] = {'''pixel_values''': pixel_values}
return config, inputs_dict
@require_flax
class __magic_name__ ( __UpperCAmelCase , unittest.TestCase ):
__A : List[Any] = (FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()
__A : str = False
__A : Tuple = False
__A : Dict = False
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :Dict = FlaxRegNetModelTester(self )
lowercase :Tuple = ConfigTester(self , config_class=snake_case__ , has_text_modality=snake_case__ )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
self.create_and_test_config_common_properties()
self.config_tester.create_and_test_config_to_json_string()
self.config_tester.create_and_test_config_to_json_file()
self.config_tester.create_and_test_config_from_and_save_pretrained()
self.config_tester.create_and_test_config_with_num_labels()
self.config_tester.check_config_can_be_init_without_params()
self.config_tester.check_config_arguments_init()
def __snake_case ( self : List[Any] ):
'''simple docstring'''
return
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :Dict = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_image_classification(*snake_case__ )
@unittest.skip(reason='''RegNet does not use inputs_embeds''' )
def __snake_case ( self : Tuple ):
'''simple docstring'''
pass
@unittest.skip(reason='''RegNet does not support input and output embeddings''' )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
pass
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :Union[str, Any] = model_class(snake_case__ )
lowercase :int = inspect.signature(model.__call__ )
# signature.parameters is an OrderedDict => so arg_names order is deterministic
lowercase :Tuple = [*signature.parameters.keys()]
lowercase :Tuple = ['''pixel_values''']
self.assertListEqual(arg_names[:1] , snake_case__ )
def __snake_case ( self : Tuple ):
'''simple docstring'''
def check_hidden_states_output(snake_case__ : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[int] ):
lowercase :int = model_class(snake_case__ )
lowercase :Tuple = model(**self._prepare_for_class(snake_case__ , snake_case__ ) )
lowercase :Any = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
lowercase :Dict = self.model_tester.num_stages
self.assertEqual(len(snake_case__ ) , expected_num_stages + 1 )
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :Optional[int] = True
check_hidden_states_output(snake_case__ , snake_case__ , snake_case__ )
# check that output_hidden_states also work using config
del inputs_dict["output_hidden_states"]
lowercase :str = True
check_hidden_states_output(snake_case__ , snake_case__ , snake_case__ )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
with self.subTest(model_class.__name__ ):
lowercase :Optional[Any] = self._prepare_for_class(snake_case__ , snake_case__ )
lowercase :List[Any] = model_class(snake_case__ )
@jax.jit
def model_jitted(snake_case__ : str , **snake_case__ : Optional[int] ):
return model(pixel_values=snake_case__ , **snake_case__ )
with self.subTest('''JIT Enabled''' ):
lowercase :Optional[int] = model_jitted(**snake_case__ ).to_tuple()
with self.subTest('''JIT Disabled''' ):
with jax.disable_jit():
lowercase :Optional[int] = model_jitted(**snake_case__ ).to_tuple()
self.assertEqual(len(snake_case__ ) , len(snake_case__ ) )
for jitted_output, output in zip(snake_case__ , snake_case__ ):
self.assertEqual(jitted_output.shape , output.shape )
def lowerCamelCase () -> Tuple:
lowercase :Tuple = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
return image
@require_flax
class __magic_name__ ( unittest.TestCase ):
@cached_property
def __snake_case ( self : int ):
'''simple docstring'''
return AutoImageProcessor.from_pretrained('''facebook/regnet-y-040''' ) if is_vision_available() else None
@slow
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :int = FlaxRegNetForImageClassification.from_pretrained('''facebook/regnet-y-040''' )
lowercase :Optional[Any] = self.default_image_processor
lowercase :Dict = prepare_img()
lowercase :Any = image_processor(images=snake_case__ , return_tensors='''np''' )
lowercase :List[str] = model(**snake_case__ )
# verify the logits
lowercase :Any = (1, 1_0_0_0)
self.assertEqual(outputs.logits.shape , snake_case__ )
lowercase :List[Any] = jnp.array([-0.41_80, -1.50_51, -3.48_36] )
self.assertTrue(jnp.allclose(outputs.logits[0, :3] , snake_case__ , atol=1e-4 ) )
| 677 | 1 |
"""simple docstring"""
import os
from typing import List, Optional, Union
from ...tokenization_utils import PreTrainedTokenizer
from ...tokenization_utils_base import AddedToken
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {'''vocab_file''': '''vocab.txt'''}
UpperCAmelCase = {
'''vocab_file''': {
'''facebook/esm2_t6_8M_UR50D''': '''https://huggingface.co/facebook/esm2_t6_8M_UR50D/resolve/main/vocab.txt''',
'''facebook/esm2_t12_35M_UR50D''': '''https://huggingface.co/facebook/esm2_t12_35M_UR50D/resolve/main/vocab.txt''',
},
}
UpperCAmelCase = {
'''facebook/esm2_t6_8M_UR50D''': 1_024,
'''facebook/esm2_t12_35M_UR50D''': 1_024,
}
def lowerCamelCase (a_ :Tuple) -> Dict:
with open(a_ , '''r''') as f:
lowercase :Any = f.read().splitlines()
return [l.strip() for l in lines]
class __magic_name__ ( __UpperCAmelCase ):
__A : Dict = VOCAB_FILES_NAMES
__A : Tuple = PRETRAINED_VOCAB_FILES_MAP
__A : Union[str, Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
__A : Tuple = ["input_ids", "attention_mask"]
def __init__( self : int , snake_case__ : Any , snake_case__ : str="<unk>" , snake_case__ : List[str]="<cls>" , snake_case__ : List[Any]="<pad>" , snake_case__ : Tuple="<mask>" , snake_case__ : Any="<eos>" , **snake_case__ : int , ):
'''simple docstring'''
super().__init__(**snake_case__ )
lowercase :List[str] = load_vocab_file(snake_case__ )
lowercase :Optional[int] = dict(enumerate(self.all_tokens ) )
lowercase :Optional[Any] = {tok: ind for ind, tok in enumerate(self.all_tokens )}
lowercase :List[str] = unk_token
lowercase :Union[str, Any] = cls_token
lowercase :List[Any] = pad_token
lowercase :Optional[int] = mask_token
lowercase :int = eos_token
lowercase :Optional[Any] = self.all_tokens
self._create_trie(self.unique_no_split_tokens )
def __snake_case ( self : str , snake_case__ : int ):
'''simple docstring'''
return self._id_to_token.get(snake_case__ , self.unk_token )
def __snake_case ( self : Optional[Any] , snake_case__ : str ):
'''simple docstring'''
return self._token_to_id.get(snake_case__ , self._token_to_id.get(self.unk_token ) )
def __snake_case ( self : Tuple , snake_case__ : Optional[int] , **snake_case__ : str ):
'''simple docstring'''
return text.split()
def __snake_case ( self : Tuple , snake_case__ : Optional[int]=False ):
'''simple docstring'''
return len(self._id_to_token )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
return {token: i for i, token in enumerate(self.all_tokens )}
def __snake_case ( self : Tuple , snake_case__ : str ):
'''simple docstring'''
return self._token_to_id.get(snake_case__ , self._token_to_id.get(self.unk_token ) )
def __snake_case ( self : Optional[Any] , snake_case__ : int ):
'''simple docstring'''
return self._id_to_token.get(snake_case__ , self.unk_token )
def __snake_case ( self : List[Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ):
'''simple docstring'''
lowercase :Any = [self.cls_token_id]
lowercase :str = [self.eos_token_id] # No sep token in ESM vocabulary
if token_ids_a is None:
if self.eos_token_id is None:
return cls + token_ids_a
else:
return cls + token_ids_a + sep
elif self.eos_token_id is None:
raise ValueError('''Cannot tokenize multiple sequences when EOS token is not set!''' )
return cls + token_ids_a + sep + token_ids_a + sep # Multiple inputs always have an EOS token
def __snake_case ( self : str , snake_case__ : List , snake_case__ : Optional[List] = None , snake_case__ : bool = False ):
'''simple docstring'''
if already_has_special_tokens:
if token_ids_a is not None:
raise ValueError(
'''You should not supply a second sequence if the provided sequence of '''
'''ids is already formatted with special tokens for the model.''' )
return [1 if token in self.all_special_ids else 0 for token in token_ids_a]
lowercase :Any = [1] + ([0] * len(snake_case__ )) + [1]
if token_ids_a is not None:
mask += [0] * len(snake_case__ ) + [1]
return mask
def __snake_case ( self : Optional[Any] , snake_case__ : int , snake_case__ : Any ):
'''simple docstring'''
lowercase :Optional[Any] = os.path.join(snake_case__ , (filename_prefix + '''-''' if filename_prefix else '''''') + '''vocab.txt''' )
with open(snake_case__ , '''w''' ) as f:
f.write('''\n'''.join(self.all_tokens ) )
return (vocab_file,)
@property
def __snake_case ( self : List[Any] ):
'''simple docstring'''
return self.get_vocab_size(with_added_tokens=snake_case__ )
def __snake_case ( self : Union[str, Any] , snake_case__ : Union[List[str], List[AddedToken]] , snake_case__ : bool = False ):
'''simple docstring'''
return super()._add_tokens(snake_case__ , special_tokens=snake_case__ )
| 677 |
"""simple docstring"""
UpperCAmelCase = {
'''A''': ['''B''', '''C''', '''E'''],
'''B''': ['''A''', '''D''', '''E'''],
'''C''': ['''A''', '''F''', '''G'''],
'''D''': ['''B'''],
'''E''': ['''A''', '''B''', '''D'''],
'''F''': ['''C'''],
'''G''': ['''C'''],
}
def lowerCamelCase (a_ :dict , a_ :List[str] , a_ :Tuple) -> list[str]:
lowercase :str = set()
# keep track of all the paths to be checked
lowercase :Dict = [[start]]
# return path if start is goal
if start == goal:
return [start]
# keeps looping until all possible paths have been checked
while queue:
# pop the first path from the queue
lowercase :Optional[int] = queue.pop(0)
# get the last node from the path
lowercase :Any = path[-1]
if node not in explored:
lowercase :int = graph[node]
# go through all neighbour nodes, construct a new path and
# push it into the queue
for neighbour in neighbours:
lowercase :List[Any] = list(a_)
new_path.append(a_)
queue.append(a_)
# return path if neighbour is goal
if neighbour == goal:
return new_path
# mark node as explored
explored.add(a_)
# in case there's no path between the 2 nodes
return []
def lowerCamelCase (a_ :dict , a_ :List[Any] , a_ :List[Any]) -> int:
if not graph or start not in graph or target not in graph:
return -1
if start == target:
return 0
lowercase :List[str] = [start]
lowercase :Optional[Any] = set(a_)
# Keep tab on distances from `start` node.
lowercase :Union[str, Any] = {start: 0, target: -1}
while queue:
lowercase :Union[str, Any] = queue.pop(0)
if node == target:
lowercase :Any = (
dist[node] if dist[target] == -1 else min(dist[target] , dist[node])
)
for adjacent in graph[node]:
if adjacent not in visited:
visited.add(a_)
queue.append(a_)
lowercase :Dict = dist[node] + 1
return dist[target]
if __name__ == "__main__":
print(bfs_shortest_path(demo_graph, '''G''', '''D''')) # returns ['G', 'C', 'A', 'B', 'D']
print(bfs_shortest_path_distance(demo_graph, '''G''', '''D''')) # returns 4
| 677 | 1 |
"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''facebook/convnextv2-tiny-1k-224''': '''https://huggingface.co/facebook/convnextv2-tiny-1k-224/resolve/main/config.json''',
}
class __magic_name__ ( __UpperCAmelCase , __UpperCAmelCase ):
__A : int = "convnextv2"
def __init__( self : int , snake_case__ : int=3 , snake_case__ : Union[str, Any]=4 , snake_case__ : Any=4 , snake_case__ : str=None , snake_case__ : Tuple=None , snake_case__ : Dict="gelu" , snake_case__ : int=0.02 , snake_case__ : Tuple=1e-1_2 , snake_case__ : Tuple=0.0 , snake_case__ : Optional[Any]=2_2_4 , snake_case__ : List[Any]=None , snake_case__ : Any=None , **snake_case__ : Optional[int] , ):
'''simple docstring'''
super().__init__(**snake_case__ )
lowercase :List[str] = num_channels
lowercase :Optional[int] = patch_size
lowercase :Optional[Any] = num_stages
lowercase :Union[str, Any] = [9_6, 1_9_2, 3_8_4, 7_6_8] if hidden_sizes is None else hidden_sizes
lowercase :int = [3, 3, 9, 3] if depths is None else depths
lowercase :str = hidden_act
lowercase :int = initializer_range
lowercase :List[str] = layer_norm_eps
lowercase :Tuple = drop_path_rate
lowercase :Tuple = image_size
lowercase :int = ['''stem'''] + [f"""stage{idx}""" for idx in range(1 , len(self.depths ) + 1 )]
lowercase , lowercase :List[str] = get_aligned_output_features_output_indices(
out_features=snake_case__ , out_indices=snake_case__ , stage_names=self.stage_names )
| 677 |
"""simple docstring"""
import logging
import os
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from tempfile import TemporaryDirectory
from typing import List, Optional
import faiss
import torch
from datasets import Features, Sequence, Value, load_dataset
from transformers import DPRContextEncoder, DPRContextEncoderTokenizerFast, HfArgumentParser
UpperCAmelCase = logging.getLogger(__name__)
torch.set_grad_enabled(False)
UpperCAmelCase = '''cuda''' if torch.cuda.is_available() else '''cpu'''
def lowerCamelCase (a_ :str , a_ :List[str]=100 , a_ :Optional[Any]=" ") -> List[str]:
lowercase :str = text.split(a_)
return [character.join(text[i : i + n]).strip() for i in range(0 , len(a_) , a_)]
def lowerCamelCase (a_ :dict) -> dict:
lowercase , lowercase :str = [], []
for title, text in zip(documents['''title'''] , documents['''text''']):
if text is not None:
for passage in split_text(a_):
titles.append(title if title is not None else '''''')
texts.append(a_)
return {"title": titles, "text": texts}
def lowerCamelCase (a_ :dict , a_ :DPRContextEncoder , a_ :DPRContextEncoderTokenizerFast) -> dict:
lowercase :Tuple = ctx_tokenizer(
documents['''title'''] , documents['''text'''] , truncation=a_ , padding='''longest''' , return_tensors='''pt''')['''input_ids''']
lowercase :Optional[Any] = ctx_encoder(input_ids.to(device=a_) , return_dict=a_).pooler_output
return {"embeddings": embeddings.detach().cpu().numpy()}
def lowerCamelCase (a_ :"RagExampleArguments" , a_ :"ProcessingArguments" , a_ :"IndexHnswArguments" , ) -> Any:
######################################
logger.info('''Step 1 - Create the dataset''')
######################################
# The dataset needed for RAG must have three columns:
# - title (string): title of the document
# - text (string): text of a passage of the document
# - embeddings (array of dimension d): DPR representation of the passage
# Let's say you have documents in tab-separated csv files with columns "title" and "text"
assert os.path.isfile(rag_example_args.csv_path), "Please provide a valid path to a csv file"
# You can load a Dataset object this way
lowercase :List[Any] = load_dataset(
'''csv''' , data_files=[rag_example_args.csv_path] , split='''train''' , delimiter='''\t''' , column_names=['''title''', '''text'''])
# More info about loading csv files in the documentation: https://huggingface.co/docs/datasets/loading_datasets.html?highlight=csv#csv-files
# Then split the documents into passages of 100 words
lowercase :Optional[Any] = dataset.map(a_ , batched=a_ , num_proc=processing_args.num_proc)
# And compute the embeddings
lowercase :str = DPRContextEncoder.from_pretrained(rag_example_args.dpr_ctx_encoder_model_name).to(device=a_)
lowercase :Dict = DPRContextEncoderTokenizerFast.from_pretrained(rag_example_args.dpr_ctx_encoder_model_name)
lowercase :str = Features(
{'''text''': Value('''string'''), '''title''': Value('''string'''), '''embeddings''': Sequence(Value('''float32'''))}) # optional, save as float32 instead of float64 to save space
lowercase :Optional[Any] = dataset.map(
partial(a_ , ctx_encoder=a_ , ctx_tokenizer=a_) , batched=a_ , batch_size=processing_args.batch_size , features=a_ , )
# And finally save your dataset
lowercase :str = os.path.join(rag_example_args.output_dir , '''my_knowledge_dataset''')
dataset.save_to_disk(a_)
# from datasets import load_from_disk
# dataset = load_from_disk(passages_path) # to reload the dataset
######################################
logger.info('''Step 2 - Index the dataset''')
######################################
# Let's use the Faiss implementation of HNSW for fast approximate nearest neighbor search
lowercase :str = faiss.IndexHNSWFlat(index_hnsw_args.d , index_hnsw_args.m , faiss.METRIC_INNER_PRODUCT)
dataset.add_faiss_index('''embeddings''' , custom_index=a_)
# And save the index
lowercase :Optional[Any] = os.path.join(rag_example_args.output_dir , '''my_knowledge_dataset_hnsw_index.faiss''')
dataset.get_index('''embeddings''').save(a_)
# dataset.load_faiss_index("embeddings", index_path) # to reload the index
@dataclass
class __magic_name__ :
__A : str = field(
default=str(Path(__UpperCAmelCase ).parent / "test_run" / "dummy-kb" / "my_knowledge_dataset.csv" ) , metadata={"help": "Path to a tab-separated csv file with columns 'title' and 'text'"} , )
__A : Optional[str] = field(
default=__UpperCAmelCase , metadata={"help": "Question that is passed as input to RAG. Default is 'What does Moses' rod turn into ?'."} , )
__A : str = field(
default="facebook/rag-sequence-nq" , metadata={"help": "The RAG model to use. Either 'facebook/rag-sequence-nq' or 'facebook/rag-token-nq'"} , )
__A : str = field(
default="facebook/dpr-ctx_encoder-multiset-base" , metadata={
"help": (
"The DPR context encoder model to use. Either 'facebook/dpr-ctx_encoder-single-nq-base' or"
" 'facebook/dpr-ctx_encoder-multiset-base'"
)
} , )
__A : Optional[str] = field(
default=str(Path(__UpperCAmelCase ).parent / "test_run" / "dummy-kb" ) , metadata={"help": "Path to a directory where the dataset passages and the index will be saved"} , )
@dataclass
class __magic_name__ :
__A : Optional[int] = field(
default=__UpperCAmelCase , metadata={
"help": "The number of processes to use to split the documents into passages. Default is single process."
} , )
__A : int = field(
default=16 , metadata={
"help": "The batch size to use when computing the passages embeddings using the DPR context encoder."
} , )
@dataclass
class __magic_name__ :
__A : int = field(
default=7_68 , metadata={"help": "The dimension of the embeddings to pass to the HNSW Faiss index."} , )
__A : int = field(
default=1_28 , metadata={
"help": (
"The number of bi-directional links created for every new element during the HNSW index construction."
)
} , )
if __name__ == "__main__":
logging.basicConfig(level=logging.WARNING)
logger.setLevel(logging.INFO)
UpperCAmelCase = HfArgumentParser((RagExampleArguments, ProcessingArguments, IndexHnswArguments))
UpperCAmelCase , UpperCAmelCase , UpperCAmelCase = parser.parse_args_into_dataclasses()
with TemporaryDirectory() as tmp_dir:
UpperCAmelCase = rag_example_args.output_dir or tmp_dir
main(rag_example_args, processing_args, index_hnsw_args)
| 677 | 1 |
"""simple docstring"""
import os
import shutil
from pathlib import Path
from typing import Optional, Union
import numpy as np
from huggingface_hub import hf_hub_download
from ..utils import ONNX_EXTERNAL_WEIGHTS_NAME, ONNX_WEIGHTS_NAME, is_onnx_available, logging
if is_onnx_available():
import onnxruntime as ort
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''tensor(bool)''': np.bool_,
'''tensor(int8)''': np.inta,
'''tensor(uint8)''': np.uinta,
'''tensor(int16)''': np.intaa,
'''tensor(uint16)''': np.uintaa,
'''tensor(int32)''': np.intaa,
'''tensor(uint32)''': np.uintaa,
'''tensor(int64)''': np.intaa,
'''tensor(uint64)''': np.uintaa,
'''tensor(float16)''': np.floataa,
'''tensor(float)''': np.floataa,
'''tensor(double)''': np.floataa,
}
class __magic_name__ :
def __init__( self : Union[str, Any] , snake_case__ : Optional[Any]=None , **snake_case__ : Dict ):
'''simple docstring'''
logger.info('''`diffusers.OnnxRuntimeModel` is experimental and might change in the future.''' )
lowercase :Optional[int] = model
lowercase :int = kwargs.get('''model_save_dir''' , snake_case__ )
lowercase :Dict = kwargs.get('''latest_model_name''' , snake_case__ )
def __call__( self : Optional[Any] , **snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase :Dict = {k: np.array(snake_case__ ) for k, v in kwargs.items()}
return self.model.run(snake_case__ , snake_case__ )
@staticmethod
def __snake_case ( snake_case__ : Union[str, Path] , snake_case__ : Union[str, Any]=None , snake_case__ : Dict=None ):
'''simple docstring'''
if provider is None:
logger.info('''No onnxruntime provider specified, using CPUExecutionProvider''' )
lowercase :int = '''CPUExecutionProvider'''
return ort.InferenceSession(snake_case__ , providers=[provider] , sess_options=snake_case__ )
def __snake_case ( self : Dict , snake_case__ : Union[str, Path] , snake_case__ : Optional[str] = None , **snake_case__ : int ):
'''simple docstring'''
lowercase :List[Any] = file_name if file_name is not None else ONNX_WEIGHTS_NAME
lowercase :int = self.model_save_dir.joinpath(self.latest_model_name )
lowercase :int = Path(snake_case__ ).joinpath(snake_case__ )
try:
shutil.copyfile(snake_case__ , snake_case__ )
except shutil.SameFileError:
pass
# copy external weights (for models >2GB)
lowercase :Tuple = self.model_save_dir.joinpath(snake_case__ )
if src_path.exists():
lowercase :Optional[int] = Path(snake_case__ ).joinpath(snake_case__ )
try:
shutil.copyfile(snake_case__ , snake_case__ )
except shutil.SameFileError:
pass
def __snake_case ( self : Union[str, Any] , snake_case__ : Union[str, os.PathLike] , **snake_case__ : str , ):
'''simple docstring'''
if os.path.isfile(snake_case__ ):
logger.error(f"""Provided path ({save_directory}) should be a directory, not a file""" )
return
os.makedirs(snake_case__ , exist_ok=snake_case__ )
# saving model weights/files
self._save_pretrained(snake_case__ , **snake_case__ )
@classmethod
def __snake_case ( cls : Optional[Any] , snake_case__ : Union[str, Path] , snake_case__ : Optional[Union[bool, str, None]] = None , snake_case__ : Optional[Union[str, None]] = None , snake_case__ : bool = False , snake_case__ : Optional[str] = None , snake_case__ : Optional[str] = None , snake_case__ : Optional[str] = None , snake_case__ : Optional["ort.SessionOptions"] = None , **snake_case__ : Optional[Any] , ):
'''simple docstring'''
lowercase :List[str] = file_name if file_name is not None else ONNX_WEIGHTS_NAME
# load model from local directory
if os.path.isdir(snake_case__ ):
lowercase :Dict = OnnxRuntimeModel.load_model(
os.path.join(snake_case__ , snake_case__ ) , provider=snake_case__ , sess_options=snake_case__ )
lowercase :str = Path(snake_case__ )
# load model from hub
else:
# download model
lowercase :Optional[Any] = hf_hub_download(
repo_id=snake_case__ , filename=snake_case__ , use_auth_token=snake_case__ , revision=snake_case__ , cache_dir=snake_case__ , force_download=snake_case__ , )
lowercase :str = Path(snake_case__ ).parent
lowercase :str = Path(snake_case__ ).name
lowercase :Tuple = OnnxRuntimeModel.load_model(snake_case__ , provider=snake_case__ , sess_options=snake_case__ )
return cls(model=snake_case__ , **snake_case__ )
@classmethod
def __snake_case ( cls : Tuple , snake_case__ : Union[str, Path] , snake_case__ : bool = True , snake_case__ : Optional[str] = None , snake_case__ : Optional[str] = None , **snake_case__ : Tuple , ):
'''simple docstring'''
lowercase :List[str] = None
if len(str(snake_case__ ).split('''@''' ) ) == 2:
lowercase , lowercase :List[Any] = model_id.split('''@''' )
return cls._from_pretrained(
model_id=snake_case__ , revision=snake_case__ , cache_dir=snake_case__ , force_download=snake_case__ , use_auth_token=snake_case__ , **snake_case__ , )
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available
UpperCAmelCase = {
'''configuration_longt5''': ['''LONGT5_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''LongT5Config''', '''LongT5OnnxConfig'''],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''LONGT5_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''LongT5EncoderModel''',
'''LongT5ForConditionalGeneration''',
'''LongT5Model''',
'''LongT5PreTrainedModel''',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxLongT5ForConditionalGeneration''',
'''FlaxLongT5Model''',
'''FlaxLongT5PreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_longta import LONGT5_PRETRAINED_CONFIG_ARCHIVE_MAP, LongTaConfig, LongTaOnnxConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_longta import (
LONGT5_PRETRAINED_MODEL_ARCHIVE_LIST,
LongTaEncoderModel,
LongTaForConditionalGeneration,
LongTaModel,
LongTaPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_longta import (
FlaxLongTaForConditionalGeneration,
FlaxLongTaModel,
FlaxLongTaPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
import argparse
import collections
import numpy as np
import torch
from flax import traverse_util
from tax import checkpoints
from transformers import MTaConfig, UMTaEncoderModel, UMTaForConditionalGeneration
from transformers.utils import logging
logging.set_verbosity_info()
def lowerCamelCase (a_ :int , a_ :Union[str, Any] , a_ :List[Any]) -> List[str]:
return params[F"""{prefix}/{prefix}/relpos_bias/rel_embedding"""][:, i, :]
def lowerCamelCase (a_ :Optional[Any] , a_ :Optional[int] , a_ :str , a_ :Any="attention") -> Optional[int]:
lowercase :Tuple = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/key/kernel"""][:, i, :, :])
lowercase :int = k_tmp.reshape(k_tmp.shape[0] , k_tmp.shape[1] * k_tmp.shape[2])
lowercase :str = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/out/kernel"""][:, i, :, :])
lowercase :Any = o_tmp.reshape(o_tmp.shape[0] * o_tmp.shape[1] , o_tmp.shape[2])
lowercase :int = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/query/kernel"""][:, i, :, :])
lowercase :List[str] = q_tmp.reshape(q_tmp.shape[0] , q_tmp.shape[1] * q_tmp.shape[2])
lowercase :List[Any] = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/value/kernel"""][:, i, :, :])
lowercase :Optional[int] = v_tmp.reshape(v_tmp.shape[0] , v_tmp.shape[1] * v_tmp.shape[2])
return k, o, q, v
def lowerCamelCase (a_ :Any , a_ :Union[str, Any] , a_ :Union[str, Any] , a_ :Union[str, Any]=False) -> List[Any]:
if split_mlp_wi:
lowercase :List[Any] = params[F"""{prefix}/{prefix}/mlp/wi_0/kernel"""][:, i, :]
lowercase :Optional[int] = params[F"""{prefix}/{prefix}/mlp/wi_1/kernel"""][:, i, :]
lowercase :Dict = (wi_a, wi_a)
else:
lowercase :Optional[Any] = params[F"""{prefix}/{prefix}/mlp/wi/kernel"""][:, i, :]
lowercase :Union[str, Any] = params[F"""{prefix}/{prefix}/mlp/wo/kernel"""][:, i, :]
return wi, wo
def lowerCamelCase (a_ :Any , a_ :Optional[Any] , a_ :Optional[Any] , a_ :Union[str, Any]) -> Optional[Any]:
return params[F"""{prefix}/{prefix}/{layer_name}/scale"""][:, i]
def lowerCamelCase (a_ :dict , *, a_ :int , a_ :bool , a_ :bool = False) -> int:
lowercase :Dict = traverse_util.flatten_dict(variables['''target'''])
lowercase :Optional[Any] = {'''/'''.join(a_): v for k, v in old.items()}
# v1.1 models have a gated GeLU with wi_0 and wi_1 instead of wi
lowercase :str = '''encoder/encoder/mlp/wi_0/kernel''' in old
print('''Split MLP:''' , a_)
lowercase :str = collections.OrderedDict()
# Shared embeddings.
lowercase :int = old['''token_embedder/embedding''']
# Encoder.
for i in range(a_):
# Block i, layer 0 (Self Attention).
lowercase :Union[str, Any] = tax_layer_norm_lookup(a_ , a_ , '''encoder''' , '''pre_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :Tuple = tax_attention_lookup(a_ , a_ , '''encoder''' , '''attention''')
lowercase :Dict = layer_norm
lowercase :Dict = k.T
lowercase :Union[str, Any] = o.T
lowercase :List[Any] = q.T
lowercase :int = v.T
# Block i, layer 1 (MLP).
lowercase :Optional[int] = tax_layer_norm_lookup(a_ , a_ , '''encoder''' , '''pre_mlp_layer_norm''')
lowercase , lowercase :str = tax_mlp_lookup(a_ , a_ , '''encoder''' , a_)
lowercase :int = layer_norm
if split_mlp_wi:
lowercase :Tuple = wi[0].T
lowercase :Tuple = wi[1].T
else:
lowercase :int = wi.T
lowercase :Tuple = wo.T
if scalable_attention:
# convert the rel_embedding of each layer
lowercase :Dict = tax_relpos_bias_lookup(
a_ , a_ , '''encoder''').T
lowercase :str = old['''encoder/encoder_norm/scale''']
if not scalable_attention:
lowercase :str = tax_relpos_bias_lookup(
a_ , 0 , '''encoder''').T
lowercase :List[Any] = tax_relpos_bias_lookup(
a_ , 0 , '''decoder''').T
if not is_encoder_only:
# Decoder.
for i in range(a_):
# Block i, layer 0 (Self Attention).
lowercase :Any = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_self_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :str = tax_attention_lookup(a_ , a_ , '''decoder''' , '''self_attention''')
lowercase :List[str] = layer_norm
lowercase :Dict = k.T
lowercase :List[Any] = o.T
lowercase :List[Any] = q.T
lowercase :Any = v.T
# Block i, layer 1 (Cross Attention).
lowercase :Tuple = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_cross_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :int = tax_attention_lookup(a_ , a_ , '''decoder''' , '''encoder_decoder_attention''')
lowercase :int = layer_norm
lowercase :Dict = k.T
lowercase :int = o.T
lowercase :List[Any] = q.T
lowercase :Tuple = v.T
# Block i, layer 2 (MLP).
lowercase :Any = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_mlp_layer_norm''')
lowercase , lowercase :Tuple = tax_mlp_lookup(a_ , a_ , '''decoder''' , a_)
lowercase :Any = layer_norm
if split_mlp_wi:
lowercase :int = wi[0].T
lowercase :Union[str, Any] = wi[1].T
else:
lowercase :int = wi.T
lowercase :List[Any] = wo.T
if scalable_attention:
# convert the rel_embedding of each layer
lowercase :Union[str, Any] = tax_relpos_bias_lookup(a_ , a_ , '''decoder''').T
lowercase :Union[str, Any] = old['''decoder/decoder_norm/scale''']
# LM Head (only in v1.1 checkpoints, in v1.0 embeddings are used instead)
if "decoder/logits_dense/kernel" in old:
lowercase :int = old['''decoder/logits_dense/kernel'''].T
return new
def lowerCamelCase (a_ :Dict , a_ :bool) -> Tuple:
lowercase :str = collections.OrderedDict([(k, torch.from_numpy(v.copy())) for (k, v) in converted_params.items()])
# Add what is missing.
if "encoder.embed_tokens.weight" not in state_dict:
lowercase :Any = state_dict['''shared.weight''']
if not is_encoder_only:
if "decoder.embed_tokens.weight" not in state_dict:
lowercase :Optional[Any] = state_dict['''shared.weight''']
if "lm_head.weight" not in state_dict: # For old 1.0 models.
print('''Using shared word embeddings as lm_head.''')
lowercase :Optional[int] = state_dict['''shared.weight''']
return state_dict
def lowerCamelCase (a_ :List[str] , a_ :List[str] , a_ :Tuple , a_ :Optional[int] , a_ :List[str]) -> List[str]:
lowercase :Optional[Any] = checkpoints.load_tax_checkpoint(a_)
lowercase :Optional[int] = convert_tax_to_pytorch(
a_ , num_layers=config.num_layers , is_encoder_only=a_ , scalable_attention=a_)
lowercase :Union[str, Any] = make_state_dict(a_ , a_)
model.load_state_dict(a_ , strict=a_)
def lowerCamelCase (a_ :str , a_ :Optional[int] , a_ :Any , a_ :bool = False , a_ :bool = False , ) -> Tuple:
lowercase :Optional[int] = MTaConfig.from_json_file(a_)
print(F"""Building PyTorch model from configuration: {config}""")
# Non-v1.1 checkpoints could also use T5Model, but this works for all.
# The v1.0 checkpoints will simply have an LM head that is the word embeddings.
if is_encoder_only:
lowercase :Union[str, Any] = UMTaEncoderModel(a_)
else:
lowercase :int = UMTaForConditionalGeneration(a_)
# Load weights from tf checkpoint
load_tax_weights_in_ta(a_ , a_ , a_ , a_ , a_)
# Save pytorch-model
print(F"""Save PyTorch model to {pytorch_dump_path}""")
model.save_pretrained(a_)
# Verify that we can load the checkpoint.
model.from_pretrained(a_)
print('''Done''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser(description='''Converts a native T5X checkpoint into a PyTorch checkpoint.''')
# Required parameters
parser.add_argument(
'''--t5x_checkpoint_path''', default=None, type=str, required=True, help='''Path to the T5X checkpoint.'''
)
parser.add_argument(
'''--config_file''',
default=None,
type=str,
required=True,
help='''The config json file corresponding to the pre-trained T5 model.\nThis specifies the model architecture.''',
)
parser.add_argument(
'''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
)
parser.add_argument(
'''--is_encoder_only''', action='''store_true''', help='''Check if the model is encoder-decoder model''', default=False
)
parser.add_argument(
'''--scalable_attention''',
action='''store_true''',
help='''Whether the model uses scaled attention (umt5 model)''',
default=False,
)
UpperCAmelCase = parser.parse_args()
convert_tax_checkpoint_to_pytorch(
args.tax_checkpoint_path,
args.config_file,
args.pytorch_dump_path,
args.is_encoder_only,
args.scalable_attention,
)
| 677 |
"""simple docstring"""
import uuid
from typing import Any, Dict, List, Optional, Union
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline
if is_tf_available():
import tensorflow as tf
if is_torch_available():
import torch
UpperCAmelCase = logging.get_logger(__name__)
class __magic_name__ :
def __init__( self : Tuple , snake_case__ : str = None , snake_case__ : uuid.UUID = None , snake_case__ : Optional[int]=None , snake_case__ : Tuple=None ):
'''simple docstring'''
if not conversation_id:
lowercase :List[Any] = uuid.uuida()
if past_user_inputs is None:
lowercase :Union[str, Any] = []
if generated_responses is None:
lowercase :List[str] = []
lowercase :uuid.UUID = conversation_id
lowercase :List[str] = past_user_inputs
lowercase :List[str] = generated_responses
lowercase :Optional[str] = text
def __eq__( self : Optional[Any] , snake_case__ : str ):
'''simple docstring'''
if not isinstance(snake_case__ , snake_case__ ):
return False
if self.uuid == other.uuid:
return True
return (
self.new_user_input == other.new_user_input
and self.past_user_inputs == other.past_user_inputs
and self.generated_responses == other.generated_responses
)
def __snake_case ( self : Optional[int] , snake_case__ : str , snake_case__ : bool = False ):
'''simple docstring'''
if self.new_user_input:
if overwrite:
logger.warning(
f"""User input added while unprocessed input was existing: \"{self.new_user_input}\" was overwritten """
f"""with: \"{text}\".""" )
lowercase :List[str] = text
else:
logger.warning(
f"""User input added while unprocessed input was existing: \"{self.new_user_input}\" new input """
f"""ignored: \"{text}\". Set `overwrite` to True to overwrite unprocessed user input""" )
else:
lowercase :Optional[int] = text
def __snake_case ( self : Any ):
'''simple docstring'''
if self.new_user_input:
self.past_user_inputs.append(self.new_user_input )
lowercase :Tuple = None
def __snake_case ( self : Tuple , snake_case__ : str ):
'''simple docstring'''
self.generated_responses.append(snake_case__ )
def __snake_case ( self : Tuple ):
'''simple docstring'''
for user_input, generated_response in zip(self.past_user_inputs , self.generated_responses ):
yield True, user_input
yield False, generated_response
if self.new_user_input:
yield True, self.new_user_input
def __repr__( self : Dict ):
'''simple docstring'''
lowercase :int = f"""Conversation id: {self.uuid} \n"""
for is_user, text in self.iter_texts():
lowercase :Dict = '''user''' if is_user else '''bot'''
output += f"""{name} >> {text} \n"""
return output
@add_end_docstrings(
__UpperCAmelCase , R"\n min_length_for_response (`int`, *optional*, defaults to 32):\n The minimum length (in number of tokens) for a response.\n minimum_tokens (`int`, *optional*, defaults to 10):\n The minimum length of tokens to leave for a response.\n " , )
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Optional[Any] , *snake_case__ : Optional[Any] , **snake_case__ : List[Any] ):
'''simple docstring'''
super().__init__(*snake_case__ , **snake_case__ )
if self.tokenizer.pad_token_id is None:
lowercase :Any = self.tokenizer.eos_token
def __snake_case ( self : List[Any] , snake_case__ : Optional[int]=None , snake_case__ : Union[str, Any]=None , snake_case__ : List[str]=None , **snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase :str = {}
lowercase :List[str] = {}
lowercase :Tuple = {}
if min_length_for_response is not None:
lowercase :Dict = min_length_for_response
if minimum_tokens is not None:
lowercase :Union[str, Any] = minimum_tokens
if "max_length" in generate_kwargs:
lowercase :List[Any] = generate_kwargs['''max_length''']
# self.max_length = generate_kwargs.get("max_length", self.model.config.max_length)
if clean_up_tokenization_spaces is not None:
lowercase :Dict = clean_up_tokenization_spaces
if generate_kwargs:
forward_params.update(snake_case__ )
return preprocess_params, forward_params, postprocess_params
def __call__( self : List[Any] , snake_case__ : Union[Conversation, List[Conversation]] , snake_case__ : int=0 , **snake_case__ : int ):
'''simple docstring'''
lowercase :int = super().__call__(snake_case__ , num_workers=snake_case__ , **snake_case__ )
if isinstance(snake_case__ , snake_case__ ) and len(snake_case__ ) == 1:
return outputs[0]
return outputs
def __snake_case ( self : List[Any] , snake_case__ : Conversation , snake_case__ : Any=3_2 ):
'''simple docstring'''
if not isinstance(snake_case__ , snake_case__ ):
raise ValueError('''ConversationalPipeline, expects Conversation as inputs''' )
if conversation.new_user_input is None:
raise ValueError(
f"""Conversation with UUID {type(conversation.uuid )} does not contain new user input to process. """
'''Add user inputs with the conversation\'s `add_user_input` method''' )
if hasattr(self.tokenizer , '''_build_conversation_input_ids''' ):
lowercase :List[str] = self.tokenizer._build_conversation_input_ids(snake_case__ )
else:
# If the tokenizer cannot handle conversations, we default to only the old version
lowercase :List[str] = self._legacy_parse_and_tokenize(snake_case__ )
if self.framework == "pt":
lowercase :int = torch.LongTensor([input_ids] )
elif self.framework == "tf":
lowercase :Any = tf.constant([input_ids] )
return {"input_ids": input_ids, "conversation": conversation}
def __snake_case ( self : int , snake_case__ : Union[str, Any] , snake_case__ : Any=1_0 , **snake_case__ : int ):
'''simple docstring'''
lowercase :Dict = generate_kwargs.get('''max_length''' , self.model.config.max_length )
lowercase :Optional[Any] = model_inputs['''input_ids'''].shape[1]
if max_length - minimum_tokens < n:
logger.warning(f"""Conversation input is to long ({n}), trimming it to ({max_length} - {minimum_tokens})""" )
lowercase :int = max_length - minimum_tokens
lowercase :int = model_inputs['''input_ids'''][:, -trim:]
if "attention_mask" in model_inputs:
lowercase :int = model_inputs['''attention_mask'''][:, -trim:]
lowercase :int = model_inputs.pop('''conversation''' )
lowercase :Union[str, Any] = max_length
lowercase :Dict = self.model.generate(**snake_case__ , **snake_case__ )
if self.model.config.is_encoder_decoder:
lowercase :List[Any] = 1
else:
lowercase :Optional[Any] = n
return {"output_ids": output_ids[:, start_position:], "conversation": conversation}
def __snake_case ( self : Optional[int] , snake_case__ : List[Any] , snake_case__ : Optional[Any]=True ):
'''simple docstring'''
lowercase :Dict = model_outputs['''output_ids''']
lowercase :Dict = self.tokenizer.decode(
output_ids[0] , skip_special_tokens=snake_case__ , clean_up_tokenization_spaces=snake_case__ , )
lowercase :Optional[int] = model_outputs['''conversation''']
conversation.mark_processed()
conversation.append_response(snake_case__ )
return conversation
def __snake_case ( self : List[Any] , snake_case__ : Conversation ):
'''simple docstring'''
lowercase :str = self.tokenizer.eos_token_id
lowercase :List[Any] = []
for is_user, text in conversation.iter_texts():
if eos_token_id is not None:
input_ids.extend(self.tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ ) + [eos_token_id] )
else:
input_ids.extend(self.tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ ) )
if len(snake_case__ ) > self.tokenizer.model_max_length:
lowercase :List[Any] = input_ids[-self.tokenizer.model_max_length :]
return input_ids
| 677 | 1 |
"""simple docstring"""
import inspect
from typing import Callable, List, Optional, Union
import torch
from transformers import (
CLIPImageProcessor,
CLIPTextModel,
CLIPTokenizer,
WhisperForConditionalGeneration,
WhisperProcessor,
)
from diffusers import (
AutoencoderKL,
DDIMScheduler,
DiffusionPipeline,
LMSDiscreteScheduler,
PNDMScheduler,
UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.utils import logging
UpperCAmelCase = logging.get_logger(__name__) # pylint: disable=invalid-name
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : List[Any] , snake_case__ : WhisperForConditionalGeneration , snake_case__ : WhisperProcessor , snake_case__ : AutoencoderKL , snake_case__ : CLIPTextModel , snake_case__ : CLIPTokenizer , snake_case__ : UNetaDConditionModel , snake_case__ : Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler] , snake_case__ : StableDiffusionSafetyChecker , snake_case__ : CLIPImageProcessor , ):
'''simple docstring'''
super().__init__()
if safety_checker is None:
logger.warning(
f"""You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"""
''' that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered'''
''' results in services or applications open to the public. Both the diffusers team and Hugging Face'''
''' strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling'''
''' it only for use-cases that involve analyzing network behavior or auditing its results. For more'''
''' information, please have a look at https://github.com/huggingface/diffusers/pull/254 .''' )
self.register_modules(
speech_model=snake_case__ , speech_processor=snake_case__ , vae=snake_case__ , text_encoder=snake_case__ , tokenizer=snake_case__ , unet=snake_case__ , scheduler=snake_case__ , feature_extractor=snake_case__ , )
def __snake_case ( self : Any , snake_case__ : Optional[Union[str, int]] = "auto" ):
'''simple docstring'''
if slice_size == "auto":
lowercase :List[str] = self.unet.config.attention_head_dim // 2
self.unet.set_attention_slice(snake_case__ )
def __snake_case ( self : int ):
'''simple docstring'''
self.enable_attention_slicing(snake_case__ )
@torch.no_grad()
def __call__( self : List[str] , snake_case__ : int , snake_case__ : str=1_6_0_0_0 , snake_case__ : int = 5_1_2 , snake_case__ : int = 5_1_2 , snake_case__ : int = 5_0 , snake_case__ : float = 7.5 , snake_case__ : Optional[Union[str, List[str]]] = None , snake_case__ : Optional[int] = 1 , snake_case__ : float = 0.0 , snake_case__ : Optional[torch.Generator] = None , snake_case__ : Optional[torch.FloatTensor] = None , snake_case__ : Optional[str] = "pil" , snake_case__ : bool = True , snake_case__ : Optional[Callable[[int, int, torch.FloatTensor], None]] = None , snake_case__ : int = 1 , **snake_case__ : int , ):
'''simple docstring'''
lowercase :Union[str, Any] = self.speech_processor.feature_extractor(
snake_case__ , return_tensors='''pt''' , sampling_rate=snake_case__ ).input_features.to(self.device )
lowercase :str = self.speech_model.generate(snake_case__ , max_length=4_8_0_0_0_0 )
lowercase :Any = self.speech_processor.tokenizer.batch_decode(snake_case__ , skip_special_tokens=snake_case__ , normalize=snake_case__ )[
0
]
if isinstance(snake_case__ , snake_case__ ):
lowercase :Tuple = 1
elif isinstance(snake_case__ , snake_case__ ):
lowercase :Optional[Any] = len(snake_case__ )
else:
raise ValueError(f"""`prompt` has to be of type `str` or `list` but is {type(snake_case__ )}""" )
if height % 8 != 0 or width % 8 != 0:
raise ValueError(f"""`height` and `width` have to be divisible by 8 but are {height} and {width}.""" )
if (callback_steps is None) or (
callback_steps is not None and (not isinstance(snake_case__ , snake_case__ ) or callback_steps <= 0)
):
raise ValueError(
f"""`callback_steps` has to be a positive integer but is {callback_steps} of type"""
f""" {type(snake_case__ )}.""" )
# get prompt text embeddings
lowercase :List[Any] = self.tokenizer(
snake_case__ , padding='''max_length''' , max_length=self.tokenizer.model_max_length , return_tensors='''pt''' , )
lowercase :int = text_inputs.input_ids
if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
lowercase :List[Any] = self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :] )
logger.warning(
'''The following part of your input was truncated because CLIP can only handle sequences up to'''
f""" {self.tokenizer.model_max_length} tokens: {removed_text}""" )
lowercase :str = text_input_ids[:, : self.tokenizer.model_max_length]
lowercase :str = self.text_encoder(text_input_ids.to(self.device ) )[0]
# duplicate text embeddings for each generation per prompt, using mps friendly method
lowercase , lowercase , lowercase :Optional[Any] = text_embeddings.shape
lowercase :Any = text_embeddings.repeat(1 , snake_case__ , 1 )
lowercase :Optional[int] = text_embeddings.view(bs_embed * num_images_per_prompt , snake_case__ , -1 )
# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
# corresponds to doing no classifier free guidance.
lowercase :List[str] = guidance_scale > 1.0
# get unconditional embeddings for classifier free guidance
if do_classifier_free_guidance:
lowercase :List[str]
if negative_prompt is None:
lowercase :Tuple = [''''''] * batch_size
elif type(snake_case__ ) is not type(snake_case__ ):
raise TypeError(
f"""`negative_prompt` should be the same type to `prompt`, but got {type(snake_case__ )} !="""
f""" {type(snake_case__ )}.""" )
elif isinstance(snake_case__ , snake_case__ ):
lowercase :Tuple = [negative_prompt]
elif batch_size != len(snake_case__ ):
raise ValueError(
f"""`negative_prompt`: {negative_prompt} has batch size {len(snake_case__ )}, but `prompt`:"""
f""" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"""
''' the batch size of `prompt`.''' )
else:
lowercase :List[str] = negative_prompt
lowercase :Optional[Any] = text_input_ids.shape[-1]
lowercase :List[str] = self.tokenizer(
snake_case__ , padding='''max_length''' , max_length=snake_case__ , truncation=snake_case__ , return_tensors='''pt''' , )
lowercase :str = self.text_encoder(uncond_input.input_ids.to(self.device ) )[0]
# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
lowercase :Tuple = uncond_embeddings.shape[1]
lowercase :Any = uncond_embeddings.repeat(1 , snake_case__ , 1 )
lowercase :Dict = uncond_embeddings.view(batch_size * num_images_per_prompt , snake_case__ , -1 )
# For classifier free guidance, we need to do two forward passes.
# Here we concatenate the unconditional and text embeddings into a single batch
# to avoid doing two forward passes
lowercase :Dict = torch.cat([uncond_embeddings, text_embeddings] )
# get the initial random noise unless the user supplied it
# Unlike in other pipelines, latents need to be generated in the target device
# for 1-to-1 results reproducibility with the CompVis implementation.
# However this currently doesn't work in `mps`.
lowercase :Optional[Any] = (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
lowercase :Union[str, Any] = text_embeddings.dtype
if latents is None:
if self.device.type == "mps":
# randn does not exist on mps
lowercase :int = torch.randn(snake_case__ , generator=snake_case__ , device='''cpu''' , dtype=snake_case__ ).to(
self.device )
else:
lowercase :Optional[Any] = torch.randn(snake_case__ , generator=snake_case__ , device=self.device , dtype=snake_case__ )
else:
if latents.shape != latents_shape:
raise ValueError(f"""Unexpected latents shape, got {latents.shape}, expected {latents_shape}""" )
lowercase :Optional[int] = latents.to(self.device )
# set timesteps
self.scheduler.set_timesteps(snake_case__ )
# Some schedulers like PNDM have timesteps as arrays
# It's more optimized to move all timesteps to correct device beforehand
lowercase :List[Any] = self.scheduler.timesteps.to(self.device )
# scale the initial noise by the standard deviation required by the scheduler
lowercase :str = latents * self.scheduler.init_noise_sigma
# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
# and should be between [0, 1]
lowercase :int = '''eta''' in set(inspect.signature(self.scheduler.step ).parameters.keys() )
lowercase :Optional[int] = {}
if accepts_eta:
lowercase :Optional[int] = eta
for i, t in enumerate(self.progress_bar(snake_case__ ) ):
# expand the latents if we are doing classifier free guidance
lowercase :Optional[int] = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents
lowercase :Tuple = self.scheduler.scale_model_input(snake_case__ , snake_case__ )
# predict the noise residual
lowercase :str = self.unet(snake_case__ , snake_case__ , encoder_hidden_states=snake_case__ ).sample
# perform guidance
if do_classifier_free_guidance:
lowercase , lowercase :Tuple = noise_pred.chunk(2 )
lowercase :List[Any] = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
# compute the previous noisy sample x_t -> x_t-1
lowercase :Union[str, Any] = self.scheduler.step(snake_case__ , snake_case__ , snake_case__ , **snake_case__ ).prev_sample
# call the callback, if provided
if callback is not None and i % callback_steps == 0:
callback(snake_case__ , snake_case__ , snake_case__ )
lowercase :int = 1 / 0.1_82_15 * latents
lowercase :int = self.vae.decode(snake_case__ ).sample
lowercase :List[str] = (image / 2 + 0.5).clamp(0 , 1 )
# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
lowercase :str = image.cpu().permute(0 , 2 , 3 , 1 ).float().numpy()
if output_type == "pil":
lowercase :Optional[Any] = self.numpy_to_pil(snake_case__ )
if not return_dict:
return image
return StableDiffusionPipelineOutput(images=snake_case__ , nsfw_content_detected=snake_case__ )
| 677 |
"""simple docstring"""
def lowerCamelCase (a_ :int = 100) -> int:
lowercase :Union[str, Any] = set()
lowercase :List[Any] = 0
lowercase :Dict = n + 1 # maximum limit
for a in range(2 , a_):
for b in range(2 , a_):
lowercase :Tuple = a**b # calculates the current power
collect_powers.add(a_) # adds the result to the set
return len(a_)
if __name__ == "__main__":
print('''Number of terms ''', solution(int(str(input()).strip())))
| 677 | 1 |
"""simple docstring"""
import copy
from typing import Dict, Optional
from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING
from ..detr import DetrConfig
from ..swin import SwinConfig
UpperCAmelCase = {
'''facebook/maskformer-swin-base-ade''': (
'''https://huggingface.co/facebook/maskformer-swin-base-ade/blob/main/config.json'''
)
# See all MaskFormer models at https://huggingface.co/models?filter=maskformer
}
UpperCAmelCase = logging.get_logger(__name__)
class __magic_name__ ( __UpperCAmelCase ):
__A : Optional[int] = "maskformer"
__A : Tuple = {"hidden_size": "mask_feature_size"}
__A : Optional[Any] = ["resnet", "swin"]
__A : List[Any] = ["detr"]
def __init__( self : int , snake_case__ : int = 2_5_6 , snake_case__ : int = 2_5_6 , snake_case__ : float = 0.1 , snake_case__ : bool = False , snake_case__ : Optional[Dict] = None , snake_case__ : Optional[Dict] = None , snake_case__ : float = 0.02 , snake_case__ : float = 1.0 , snake_case__ : float = 1.0 , snake_case__ : float = 1.0 , snake_case__ : float = 20.0 , snake_case__ : Optional[bool] = None , **snake_case__ : List[str] , ):
'''simple docstring'''
if backbone_config is None:
# fall back to https://huggingface.co/microsoft/swin-base-patch4-window12-384-in22k
lowercase :int = SwinConfig(
image_size=3_8_4 , in_channels=3 , patch_size=4 , embed_dim=1_2_8 , depths=[2, 2, 1_8, 2] , num_heads=[4, 8, 1_6, 3_2] , window_size=1_2 , drop_path_rate=0.3 , out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4'''] , )
if isinstance(snake_case__ , snake_case__ ):
lowercase :Optional[Any] = backbone_config.pop('''model_type''' )
lowercase :Tuple = CONFIG_MAPPING[backbone_model_type]
lowercase :Tuple = config_class.from_dict(snake_case__ )
# verify that the backbone is supported
if backbone_config.model_type not in self.backbones_supported:
logger.warning_once(
f"""Backbone {backbone_config.model_type} is not a supported model and may not be compatible with MaskFormer. """
f"""Supported model types: {','.join(self.backbones_supported )}""" )
if decoder_config is None:
# fall back to https://huggingface.co/facebook/detr-resnet-50
lowercase :Optional[int] = DetrConfig()
else:
# verify that the decoder is supported
lowercase :Tuple = (
decoder_config.pop('''model_type''' ) if isinstance(snake_case__ , snake_case__ ) else decoder_config.model_type
)
if decoder_type not in self.decoders_supported:
raise ValueError(
f"""Transformer Decoder {decoder_type} not supported, please use one of"""
f""" {','.join(self.decoders_supported )}""" )
if isinstance(snake_case__ , snake_case__ ):
lowercase :Dict = CONFIG_MAPPING[decoder_type]
lowercase :str = config_class.from_dict(snake_case__ )
lowercase :Any = backbone_config
lowercase :Any = decoder_config
# main feature dimension for the model
lowercase :Any = fpn_feature_size
lowercase :Union[str, Any] = mask_feature_size
# initializer
lowercase :Tuple = init_std
lowercase :List[Any] = init_xavier_std
# Hungarian matcher && loss
lowercase :Union[str, Any] = cross_entropy_weight
lowercase :Union[str, Any] = dice_weight
lowercase :Union[str, Any] = mask_weight
lowercase :Optional[Any] = use_auxiliary_loss
lowercase :Optional[int] = no_object_weight
lowercase :Tuple = output_auxiliary_logits
lowercase :Tuple = self.decoder_config.encoder_attention_heads
lowercase :int = self.decoder_config.num_hidden_layers
super().__init__(**snake_case__ )
@classmethod
def __snake_case ( cls : Any , snake_case__ : PretrainedConfig , snake_case__ : PretrainedConfig , **snake_case__ : int ):
'''simple docstring'''
return cls(
backbone_config=snake_case__ , decoder_config=snake_case__ , **snake_case__ , )
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :List[str] = copy.deepcopy(self.__dict__ )
lowercase :str = self.backbone_config.to_dict()
lowercase :Optional[int] = self.decoder_config.to_dict()
lowercase :List[Any] = self.__class__.model_type
return output
| 677 |
"""simple docstring"""
from typing import Callable, Optional, Union
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''microsoft/xprophetnet-large-wiki100-cased''': (
'''https://huggingface.co/microsoft/xprophetnet-large-wiki100-cased/resolve/main/config.json'''
),
}
class __magic_name__ ( __UpperCAmelCase ):
__A : Optional[Any] = "xlm-prophetnet"
__A : List[str] = ["past_key_values"]
__A : int = {
"num_attention_heads": "num_encoder_attention_heads",
}
def __init__( self : Any , snake_case__ : Optional[float] = 0.1 , snake_case__ : Optional[Union[str, Callable]] = "gelu" , snake_case__ : Optional[int] = 3_0_5_2_2 , snake_case__ : Optional[int] = 1_0_2_4 , snake_case__ : Optional[int] = 4_0_9_6 , snake_case__ : Optional[int] = 1_2 , snake_case__ : Optional[int] = 1_6 , snake_case__ : Optional[int] = 4_0_9_6 , snake_case__ : Optional[int] = 1_2 , snake_case__ : Optional[int] = 1_6 , snake_case__ : Optional[float] = 0.1 , snake_case__ : Optional[float] = 0.1 , snake_case__ : Optional[int] = 5_1_2 , snake_case__ : Optional[float] = 0.02 , snake_case__ : Optional[bool] = True , snake_case__ : Optional[bool] = True , snake_case__ : Optional[int] = 0 , snake_case__ : Optional[int] = 2 , snake_case__ : Optional[int] = 3_2 , snake_case__ : Optional[int] = 1_2_8 , snake_case__ : Optional[bool] = False , snake_case__ : Optional[float] = 0.0 , snake_case__ : Optional[bool] = True , snake_case__ : Optional[int] = 0 , snake_case__ : Optional[int] = 1 , snake_case__ : Optional[int] = 2 , **snake_case__ : List[str] , ):
'''simple docstring'''
lowercase :Tuple = vocab_size
lowercase :Optional[int] = hidden_size
lowercase :Optional[int] = encoder_ffn_dim
lowercase :Optional[int] = num_encoder_layers
lowercase :Dict = num_encoder_attention_heads
lowercase :List[str] = decoder_ffn_dim
lowercase :Dict = num_decoder_layers
lowercase :List[Any] = num_decoder_attention_heads
lowercase :Optional[int] = max_position_embeddings
lowercase :Tuple = init_std # Normal(0, this parameter)
lowercase :int = activation_function
# parameters for xlmprophetnet
lowercase :Dict = ngram
lowercase :Optional[Any] = num_buckets
lowercase :Dict = relative_max_distance
lowercase :List[Any] = disable_ngram_loss
lowercase :Optional[Any] = eps
# 3 Types of Dropout
lowercase :Any = attention_dropout
lowercase :List[str] = activation_dropout
lowercase :List[str] = dropout
lowercase :List[str] = use_cache
super().__init__(
pad_token_id=snake_case__ , bos_token_id=snake_case__ , eos_token_id=snake_case__ , is_encoder_decoder=snake_case__ , add_cross_attention=snake_case__ , decoder_start_token_id=snake_case__ , **snake_case__ , )
@property
def __snake_case ( self : Any ):
'''simple docstring'''
return self.num_encoder_layers + self.num_decoder_layers
@num_hidden_layers.setter
def __snake_case ( self : Optional[Any] , snake_case__ : Optional[Any] ):
'''simple docstring'''
raise NotImplementedError(
'''This model does not support the setting of `num_hidden_layers`. Please set `num_encoder_layers` and'''
''' `num_decoder_layers`.''' )
| 677 | 1 |
"""simple docstring"""
import pytest
from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.text import TextDatasetReader
from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases
def lowerCamelCase (a_ :List[Any] , a_ :Optional[int]) -> Union[str, Any]:
assert isinstance(a_ , a_)
assert dataset.num_rows == 4
assert dataset.num_columns == 1
assert dataset.column_names == ["text"]
for feature, expected_dtype in expected_features.items():
assert dataset.features[feature].dtype == expected_dtype
@pytest.mark.parametrize('''keep_in_memory''' , [False, True])
def lowerCamelCase (a_ :Optional[Any] , a_ :Any , a_ :Dict) -> Optional[Any]:
lowercase :Union[str, Any] = tmp_path / '''cache'''
lowercase :Any = {'''text''': '''string'''}
with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
lowercase :List[str] = TextDatasetReader(a_ , cache_dir=a_ , keep_in_memory=a_).read()
_check_text_dataset(a_ , a_)
@pytest.mark.parametrize(
'''features''' , [
None,
{'''text''': '''string'''},
{'''text''': '''int32'''},
{'''text''': '''float32'''},
] , )
def lowerCamelCase (a_ :int , a_ :str , a_ :List[Any]) -> Tuple:
lowercase :List[str] = tmp_path / '''cache'''
lowercase :int = {'''text''': '''string'''}
lowercase :Optional[int] = features.copy() if features else default_expected_features
lowercase :int = (
Features({feature: Value(a_) for feature, dtype in features.items()}) if features is not None else None
)
lowercase :Optional[Any] = TextDatasetReader(a_ , features=a_ , cache_dir=a_).read()
_check_text_dataset(a_ , a_)
@pytest.mark.parametrize('''split''' , [None, NamedSplit('''train'''), '''train''', '''test'''])
def lowerCamelCase (a_ :Optional[Any] , a_ :int , a_ :Optional[int]) -> str:
lowercase :str = tmp_path / '''cache'''
lowercase :int = {'''text''': '''string'''}
lowercase :List[Any] = TextDatasetReader(a_ , cache_dir=a_ , split=a_).read()
_check_text_dataset(a_ , a_)
assert dataset.split == split if split else "train"
@pytest.mark.parametrize('''path_type''' , [str, list])
def lowerCamelCase (a_ :int , a_ :int , a_ :List[Any]) -> List[Any]:
if issubclass(a_ , a_):
lowercase :Union[str, Any] = text_path
elif issubclass(a_ , a_):
lowercase :Optional[int] = [text_path]
lowercase :Optional[Any] = tmp_path / '''cache'''
lowercase :Any = {'''text''': '''string'''}
lowercase :Optional[Any] = TextDatasetReader(a_ , cache_dir=a_).read()
_check_text_dataset(a_ , a_)
def lowerCamelCase (a_ :Dict , a_ :Dict , a_ :List[str]=("train",)) -> int:
assert isinstance(a_ , a_)
for split in splits:
lowercase :List[Any] = dataset_dict[split]
assert dataset.num_rows == 4
assert dataset.num_columns == 1
assert dataset.column_names == ["text"]
for feature, expected_dtype in expected_features.items():
assert dataset.features[feature].dtype == expected_dtype
@pytest.mark.parametrize('''keep_in_memory''' , [False, True])
def lowerCamelCase (a_ :List[Any] , a_ :Dict , a_ :Tuple) -> Dict:
lowercase :Tuple = tmp_path / '''cache'''
lowercase :Dict = {'''text''': '''string'''}
with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
lowercase :Any = TextDatasetReader({'''train''': text_path} , cache_dir=a_ , keep_in_memory=a_).read()
_check_text_datasetdict(a_ , a_)
@pytest.mark.parametrize(
'''features''' , [
None,
{'''text''': '''string'''},
{'''text''': '''int32'''},
{'''text''': '''float32'''},
] , )
def lowerCamelCase (a_ :List[str] , a_ :Optional[Any] , a_ :Tuple) -> Dict:
lowercase :Optional[Any] = tmp_path / '''cache'''
# CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
lowercase :Union[str, Any] = {'''text''': '''string'''}
lowercase :List[str] = features.copy() if features else default_expected_features
lowercase :List[str] = (
Features({feature: Value(a_) for feature, dtype in features.items()}) if features is not None else None
)
lowercase :Optional[Any] = TextDatasetReader({'''train''': text_path} , features=a_ , cache_dir=a_).read()
_check_text_datasetdict(a_ , a_)
@pytest.mark.parametrize('''split''' , [None, NamedSplit('''train'''), '''train''', '''test'''])
def lowerCamelCase (a_ :str , a_ :Union[str, Any] , a_ :Optional[Any]) -> Union[str, Any]:
if split:
lowercase :Union[str, Any] = {split: text_path}
else:
lowercase :Tuple = '''train'''
lowercase :Tuple = {'''train''': text_path, '''test''': text_path}
lowercase :Union[str, Any] = tmp_path / '''cache'''
lowercase :Dict = {'''text''': '''string'''}
lowercase :Union[str, Any] = TextDatasetReader(a_ , cache_dir=a_).read()
_check_text_datasetdict(a_ , a_ , splits=list(path.keys()))
assert all(dataset[split].split == split for split in path.keys())
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tensorflow_text_available,
is_tf_available,
is_tokenizers_available,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_bert''': ['''BERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BertConfig''', '''BertOnnxConfig'''],
'''tokenization_bert''': ['''BasicTokenizer''', '''BertTokenizer''', '''WordpieceTokenizer'''],
}
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''BertTokenizerFast''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''BertForMaskedLM''',
'''BertForMultipleChoice''',
'''BertForNextSentencePrediction''',
'''BertForPreTraining''',
'''BertForQuestionAnswering''',
'''BertForSequenceClassification''',
'''BertForTokenClassification''',
'''BertLayer''',
'''BertLMHeadModel''',
'''BertModel''',
'''BertPreTrainedModel''',
'''load_tf_weights_in_bert''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''TFBertEmbeddings''',
'''TFBertForMaskedLM''',
'''TFBertForMultipleChoice''',
'''TFBertForNextSentencePrediction''',
'''TFBertForPreTraining''',
'''TFBertForQuestionAnswering''',
'''TFBertForSequenceClassification''',
'''TFBertForTokenClassification''',
'''TFBertLMHeadModel''',
'''TFBertMainLayer''',
'''TFBertModel''',
'''TFBertPreTrainedModel''',
]
try:
if not is_tensorflow_text_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''TFBertTokenizer''']
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxBertForCausalLM''',
'''FlaxBertForMaskedLM''',
'''FlaxBertForMultipleChoice''',
'''FlaxBertForNextSentencePrediction''',
'''FlaxBertForPreTraining''',
'''FlaxBertForQuestionAnswering''',
'''FlaxBertForSequenceClassification''',
'''FlaxBertForTokenClassification''',
'''FlaxBertModel''',
'''FlaxBertPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_bert import BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BertConfig, BertOnnxConfig
from .tokenization_bert import BasicTokenizer, BertTokenizer, WordpieceTokenizer
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_bert_fast import BertTokenizerFast
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_bert import (
BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
BertForMaskedLM,
BertForMultipleChoice,
BertForNextSentencePrediction,
BertForPreTraining,
BertForQuestionAnswering,
BertForSequenceClassification,
BertForTokenClassification,
BertLayer,
BertLMHeadModel,
BertModel,
BertPreTrainedModel,
load_tf_weights_in_bert,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_bert import (
TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
TFBertEmbeddings,
TFBertForMaskedLM,
TFBertForMultipleChoice,
TFBertForNextSentencePrediction,
TFBertForPreTraining,
TFBertForQuestionAnswering,
TFBertForSequenceClassification,
TFBertForTokenClassification,
TFBertLMHeadModel,
TFBertMainLayer,
TFBertModel,
TFBertPreTrainedModel,
)
try:
if not is_tensorflow_text_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_bert_tf import TFBertTokenizer
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_bert import (
FlaxBertForCausalLM,
FlaxBertForMaskedLM,
FlaxBertForMultipleChoice,
FlaxBertForNextSentencePrediction,
FlaxBertForPreTraining,
FlaxBertForQuestionAnswering,
FlaxBertForSequenceClassification,
FlaxBertForTokenClassification,
FlaxBertModel,
FlaxBertPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
import os
def lowerCamelCase () -> str:
lowercase :Any = os.path.join(os.path.dirname(a_) , '''num.txt''')
with open(a_) as file_hand:
return str(sum(int(a_) for line in file_hand))[:10]
if __name__ == "__main__":
print(solution())
| 677 |
"""simple docstring"""
from typing import List, Optional, Union
from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
class __magic_name__ ( __UpperCAmelCase ):
__A : Tuple = ["image_processor", "tokenizer"]
__A : Dict = "BlipImageProcessor"
__A : Dict = "AutoTokenizer"
def __init__( self : Any , snake_case__ : Union[str, Any] , snake_case__ : str ):
'''simple docstring'''
lowercase :Dict = False
super().__init__(snake_case__ , snake_case__ )
lowercase :Union[str, Any] = self.image_processor
def __call__( self : Optional[int] , snake_case__ : ImageInput = None , snake_case__ : Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None , snake_case__ : bool = True , snake_case__ : Union[bool, str, PaddingStrategy] = False , snake_case__ : Union[bool, str, TruncationStrategy] = None , snake_case__ : Optional[int] = None , snake_case__ : int = 0 , snake_case__ : Optional[int] = None , snake_case__ : Optional[bool] = None , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = True , snake_case__ : Optional[Union[str, TensorType]] = None , **snake_case__ : Optional[Any] , ):
'''simple docstring'''
if images is None and text is None:
raise ValueError('''You have to specify either images or text.''' )
# Get only text
if images is None:
lowercase :List[Any] = self.tokenizer
lowercase :str = self.tokenizer(
text=snake_case__ , add_special_tokens=snake_case__ , padding=snake_case__ , truncation=snake_case__ , max_length=snake_case__ , stride=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , return_overflowing_tokens=snake_case__ , return_special_tokens_mask=snake_case__ , return_offsets_mapping=snake_case__ , return_token_type_ids=snake_case__ , return_length=snake_case__ , verbose=snake_case__ , return_tensors=snake_case__ , **snake_case__ , )
return text_encoding
# add pixel_values
lowercase :Union[str, Any] = self.image_processor(snake_case__ , return_tensors=snake_case__ )
if text is not None:
lowercase :int = self.tokenizer(
text=snake_case__ , add_special_tokens=snake_case__ , padding=snake_case__ , truncation=snake_case__ , max_length=snake_case__ , stride=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , return_overflowing_tokens=snake_case__ , return_special_tokens_mask=snake_case__ , return_offsets_mapping=snake_case__ , return_token_type_ids=snake_case__ , return_length=snake_case__ , verbose=snake_case__ , return_tensors=snake_case__ , **snake_case__ , )
else:
lowercase :Optional[int] = None
if text_encoding is not None:
encoding_image_processor.update(snake_case__ )
return encoding_image_processor
def __snake_case ( self : Tuple , *snake_case__ : List[Any] , **snake_case__ : Tuple ):
'''simple docstring'''
return self.tokenizer.batch_decode(*snake_case__ , **snake_case__ )
def __snake_case ( self : List[str] , *snake_case__ : Dict , **snake_case__ : List[Any] ):
'''simple docstring'''
return self.tokenizer.decode(*snake_case__ , **snake_case__ )
@property
# Copied from transformers.models.blip.processing_blip.BlipProcessor.model_input_names
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase :List[Any] = self.tokenizer.model_input_names
lowercase :List[Any] = self.image_processor.model_input_names
return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) )
| 677 | 1 |
"""simple docstring"""
import functools
import operator
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''facebook/wav2vec2-base-960h''': '''https://huggingface.co/facebook/wav2vec2-base-960h/resolve/main/config.json''',
# See all Wav2Vec2 models at https://huggingface.co/models?filter=wav2vec2
}
class __magic_name__ ( __UpperCAmelCase ):
__A : List[Any] = "wav2vec2"
def __init__( self : Optional[Any] , snake_case__ : Any=3_2 , snake_case__ : Optional[Any]=7_6_8 , snake_case__ : str=1_2 , snake_case__ : Any=1_2 , snake_case__ : Union[str, Any]=3_0_7_2 , snake_case__ : List[str]="gelu" , snake_case__ : int=0.1 , snake_case__ : Dict=0.1 , snake_case__ : List[Any]=0.1 , snake_case__ : str=0.0 , snake_case__ : Optional[Any]=0.0 , snake_case__ : Optional[Any]=0.1 , snake_case__ : int=0.1 , snake_case__ : Optional[Any]=0.02 , snake_case__ : Tuple=1e-5 , snake_case__ : Optional[int]="group" , snake_case__ : Union[str, Any]="gelu" , snake_case__ : Tuple=(5_1_2, 5_1_2, 5_1_2, 5_1_2, 5_1_2, 5_1_2, 5_1_2) , snake_case__ : Tuple=(5, 2, 2, 2, 2, 2, 2) , snake_case__ : str=(1_0, 3, 3, 3, 3, 2, 2) , snake_case__ : Optional[int]=False , snake_case__ : Tuple=1_2_8 , snake_case__ : Optional[Any]=1_6 , snake_case__ : Optional[Any]=False , snake_case__ : Union[str, Any]=True , snake_case__ : Tuple=0.05 , snake_case__ : Tuple=1_0 , snake_case__ : List[Any]=2 , snake_case__ : Dict=0.0 , snake_case__ : List[str]=1_0 , snake_case__ : Tuple=0 , snake_case__ : Any=3_2_0 , snake_case__ : Tuple=2 , snake_case__ : Any=0.1 , snake_case__ : Optional[int]=1_0_0 , snake_case__ : Optional[Any]=2_5_6 , snake_case__ : Union[str, Any]=2_5_6 , snake_case__ : Optional[int]=0.1 , snake_case__ : List[str]="sum" , snake_case__ : Any=False , snake_case__ : Optional[int]=False , snake_case__ : int=2_5_6 , snake_case__ : int=(5_1_2, 5_1_2, 5_1_2, 5_1_2, 1_5_0_0) , snake_case__ : Dict=(5, 3, 3, 1, 1) , snake_case__ : str=(1, 2, 3, 1, 1) , snake_case__ : Union[str, Any]=5_1_2 , snake_case__ : Dict=0 , snake_case__ : Any=1 , snake_case__ : Any=2 , snake_case__ : Union[str, Any]=False , snake_case__ : Any=3 , snake_case__ : Optional[Any]=2 , snake_case__ : Dict=3 , snake_case__ : Optional[int]=None , snake_case__ : int=None , **snake_case__ : List[Any] , ):
'''simple docstring'''
super().__init__(**snake_case__ , pad_token_id=snake_case__ , bos_token_id=snake_case__ , eos_token_id=snake_case__ )
lowercase :Tuple = hidden_size
lowercase :Any = feat_extract_norm
lowercase :List[str] = feat_extract_activation
lowercase :Optional[Any] = list(snake_case__ )
lowercase :List[str] = list(snake_case__ )
lowercase :int = list(snake_case__ )
lowercase :Tuple = conv_bias
lowercase :str = num_conv_pos_embeddings
lowercase :Any = num_conv_pos_embedding_groups
lowercase :List[Any] = len(self.conv_dim )
lowercase :List[str] = num_hidden_layers
lowercase :Optional[Any] = intermediate_size
lowercase :Dict = hidden_act
lowercase :str = num_attention_heads
lowercase :Optional[int] = hidden_dropout
lowercase :str = attention_dropout
lowercase :List[str] = activation_dropout
lowercase :Optional[Any] = feat_proj_dropout
lowercase :Optional[int] = final_dropout
lowercase :List[Any] = layerdrop
lowercase :List[Any] = layer_norm_eps
lowercase :int = initializer_range
lowercase :Optional[Any] = vocab_size
lowercase :str = do_stable_layer_norm
lowercase :List[Any] = use_weighted_layer_sum
if (
(len(self.conv_stride ) != self.num_feat_extract_layers)
or (len(self.conv_kernel ) != self.num_feat_extract_layers)
or (len(self.conv_dim ) != self.num_feat_extract_layers)
):
raise ValueError(
'''Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =='''
''' `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ='''
f""" {len(self.conv_dim )}`, `len(config.conv_stride) = {len(self.conv_stride )}`,"""
f""" `len(config.conv_kernel) = {len(self.conv_kernel )}`.""" )
# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
lowercase :Optional[Any] = apply_spec_augment
lowercase :int = mask_time_prob
lowercase :List[str] = mask_time_length
lowercase :Tuple = mask_time_min_masks
lowercase :List[str] = mask_feature_prob
lowercase :str = mask_feature_length
lowercase :List[Any] = mask_feature_min_masks
# parameters for pretraining with codevector quantized representations
lowercase :List[str] = num_codevectors_per_group
lowercase :int = num_codevector_groups
lowercase :Tuple = contrastive_logits_temperature
lowercase :Optional[int] = feat_quantizer_dropout
lowercase :Dict = num_negatives
lowercase :List[Any] = codevector_dim
lowercase :Optional[int] = proj_codevector_dim
lowercase :int = diversity_loss_weight
# ctc loss
lowercase :Tuple = ctc_loss_reduction
lowercase :Dict = ctc_zero_infinity
# adapter
lowercase :Optional[Any] = add_adapter
lowercase :Any = adapter_kernel_size
lowercase :Dict = adapter_stride
lowercase :str = num_adapter_layers
lowercase :List[str] = output_hidden_size or hidden_size
lowercase :Optional[int] = adapter_attn_dim
# SequenceClassification-specific parameter. Feel free to ignore for other classes.
lowercase :Union[str, Any] = classifier_proj_size
# XVector-specific parameters. Feel free to ignore for other classes.
lowercase :List[Any] = list(snake_case__ )
lowercase :Any = list(snake_case__ )
lowercase :Any = list(snake_case__ )
lowercase :List[str] = xvector_output_dim
@property
def __snake_case ( self : int ):
'''simple docstring'''
return functools.reduce(operator.mul , self.conv_stride , 1 )
| 677 |
"""simple docstring"""
import subprocess
import sys
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch
class __magic_name__ ( __UpperCAmelCase ):
@require_torch
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Optional[Any] = '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
'''
lowercase :Any = '''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
'''
lowercase :Tuple = '''
import socket
def offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")
socket.socket = offline_socket
'''
# Force fetching the files so that we can use the cache
lowercase :str = '''hf-internal-testing/tiny-random-bert'''
BertConfig.from_pretrained(snake_case__ )
BertModel.from_pretrained(snake_case__ )
BertTokenizer.from_pretrained(snake_case__ )
pipeline(task='''fill-mask''' , model=snake_case__ )
# baseline - just load from_pretrained with normal network
lowercase :Union[str, Any] = [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]
# should succeed
lowercase :Any = self.get_env()
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :List[Any] = '''1'''
lowercase :List[str] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :List[str] = '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
'''
lowercase :Dict = '''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
'''
lowercase :List[Any] = '''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")
socket.socket = offline_socket
'''
# Force fetching the files so that we can use the cache
lowercase :str = '''hf-internal-testing/tiny-random-bert'''
BertConfig.from_pretrained(snake_case__ )
BertModel.from_pretrained(snake_case__ )
BertTokenizer.from_pretrained(snake_case__ )
pipeline(task='''fill-mask''' , model=snake_case__ )
# baseline - just load from_pretrained with normal network
lowercase :List[str] = [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]
# should succeed
lowercase :str = self.get_env()
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : int ):
'''simple docstring'''
lowercase :str = '''
from transformers import BertConfig, BertModel, BertTokenizer
'''
lowercase :Union[str, Any] = '''
mname = "hf-internal-testing/tiny-random-bert-sharded"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
print("success")
'''
lowercase :Optional[int] = '''
import socket
def offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")
socket.socket = offline_socket
'''
# baseline - just load from_pretrained with normal network
lowercase :Optional[Any] = [sys.executable, '''-c''', '''\n'''.join([load, run] )]
# should succeed
lowercase :Union[str, Any] = self.get_env()
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
# next emulate no network
lowercase :Tuple = [sys.executable, '''-c''', '''\n'''.join([load, mock, run] )]
# Doesn't fail anymore since the model is in the cache due to other tests, so commenting this.
# env["TRANSFORMERS_OFFLINE"] = "0"
# result = subprocess.run(cmd, env=env, check=False, capture_output=True)
# self.assertEqual(result.returncode, 1, result.stderr)
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :Any = '''1'''
lowercase :Optional[Any] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :Dict = '''
from transformers import pipeline
'''
lowercase :Optional[Any] = '''
mname = "hf-internal-testing/tiny-random-bert"
pipe = pipeline(model=mname)
'''
lowercase :Dict = '''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")
socket.socket = offline_socket
'''
lowercase :Tuple = self.get_env()
lowercase :Optional[Any] = '''1'''
lowercase :Optional[int] = [sys.executable, '''-c''', '''\n'''.join([load, mock, run] )]
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 1 , result.stderr )
self.assertIn(
'''You cannot infer task automatically within `pipeline` when using offline mode''' , result.stderr.decode().replace('''\n''' , '''''' ) , )
@require_torch
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = '''
from transformers import AutoModel
'''
lowercase :Union[str, Any] = '''
mname = "hf-internal-testing/test_dynamic_model"
AutoModel.from_pretrained(mname, trust_remote_code=True)
print("success")
'''
# baseline - just load from_pretrained with normal network
lowercase :Union[str, Any] = [sys.executable, '''-c''', '''\n'''.join([load, run] )]
# should succeed
lowercase :List[str] = self.get_env()
lowercase :Optional[int] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :List[Any] = '''1'''
lowercase :Tuple = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
| 677 | 1 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available
UpperCAmelCase = {
'''configuration_longt5''': ['''LONGT5_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''LongT5Config''', '''LongT5OnnxConfig'''],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''LONGT5_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''LongT5EncoderModel''',
'''LongT5ForConditionalGeneration''',
'''LongT5Model''',
'''LongT5PreTrainedModel''',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxLongT5ForConditionalGeneration''',
'''FlaxLongT5Model''',
'''FlaxLongT5PreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_longta import LONGT5_PRETRAINED_CONFIG_ARCHIVE_MAP, LongTaConfig, LongTaOnnxConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_longta import (
LONGT5_PRETRAINED_MODEL_ARCHIVE_LIST,
LongTaEncoderModel,
LongTaForConditionalGeneration,
LongTaModel,
LongTaPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_longta import (
FlaxLongTaForConditionalGeneration,
FlaxLongTaModel,
FlaxLongTaPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 |
"""simple docstring"""
import argparse
import json
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from typing import List
import timm
import torch
import torch.nn as nn
from huggingface_hub import hf_hub_download
from torch import Tensor
from transformers import AutoImageProcessor, ResNetConfig, ResNetForImageClassification
from transformers.utils import logging
logging.set_verbosity_info()
UpperCAmelCase = logging.get_logger()
@dataclass
class __magic_name__ :
__A : nn.Module
__A : List[nn.Module] = field(default_factory=__UpperCAmelCase )
__A : list = field(default_factory=__UpperCAmelCase )
def __snake_case ( self : List[str] , snake_case__ : List[str] , snake_case__ : Tensor , snake_case__ : Tensor ):
'''simple docstring'''
lowercase :List[str] = len(list(m.modules() ) ) == 1 or isinstance(snake_case__ , nn.Convad ) or isinstance(snake_case__ , nn.BatchNormad )
if has_not_submodules:
self.traced.append(snake_case__ )
def __call__( self : int , snake_case__ : Tensor ):
'''simple docstring'''
for m in self.module.modules():
self.handles.append(m.register_forward_hook(self._forward_hook ) )
self.module(snake_case__ )
[x.remove() for x in self.handles]
return self
@property
def __snake_case ( self : int ):
'''simple docstring'''
return list(filter(lambda snake_case__ : len(list(x.state_dict().keys() ) ) > 0 , self.traced ) )
@dataclass
class __magic_name__ :
__A : nn.Module
__A : nn.Module
__A : int = 0
__A : List = field(default_factory=__UpperCAmelCase )
__A : List = field(default_factory=__UpperCAmelCase )
def __call__( self : Dict , snake_case__ : Tensor ):
'''simple docstring'''
lowercase :Dict = Tracker(self.dest )(snake_case__ ).parametrized
lowercase :Optional[Any] = Tracker(self.src )(snake_case__ ).parametrized
lowercase :List[str] = list(filter(lambda snake_case__ : type(snake_case__ ) not in self.src_skip , snake_case__ ) )
lowercase :Tuple = list(filter(lambda snake_case__ : type(snake_case__ ) not in self.dest_skip , snake_case__ ) )
if len(snake_case__ ) != len(snake_case__ ):
raise Exception(
f"""Numbers of operations are different. Source module has {len(snake_case__ )} operations while"""
f""" destination module has {len(snake_case__ )}.""" )
for dest_m, src_m in zip(snake_case__ , snake_case__ ):
dest_m.load_state_dict(src_m.state_dict() )
if self.verbose == 1:
print(f"""Transfered from={src_m} to={dest_m}""" )
def lowerCamelCase (a_ :str , a_ :ResNetConfig , a_ :Path , a_ :bool = True) -> Optional[Any]:
print(F"""Converting {name}...""")
with torch.no_grad():
lowercase :Union[str, Any] = timm.create_model(a_ , pretrained=a_).eval()
lowercase :Tuple = ResNetForImageClassification(a_).eval()
lowercase :int = ModuleTransfer(src=a_ , dest=a_)
lowercase :List[Any] = torch.randn((1, 3, 224, 224))
module_transfer(a_)
assert torch.allclose(from_model(a_) , our_model(a_).logits), "The model logits don't match the original one."
lowercase :List[Any] = F"""resnet{'-'.join(name.split('resnet'))}"""
print(a_)
if push_to_hub:
our_model.push_to_hub(
repo_path_or_name=save_directory / checkpoint_name , commit_message='''Add model''' , use_temp_dir=a_ , )
# we can use the convnext one
lowercase :Any = AutoImageProcessor.from_pretrained('''facebook/convnext-base-224-22k-1k''')
image_processor.push_to_hub(
repo_path_or_name=save_directory / checkpoint_name , commit_message='''Add image processor''' , use_temp_dir=a_ , )
print(F"""Pushed {checkpoint_name}""")
def lowerCamelCase (a_ :Path , a_ :str = None , a_ :bool = True) -> int:
lowercase :Optional[Any] = '''imagenet-1k-id2label.json'''
lowercase :Union[str, Any] = 1000
lowercase :Any = (1, num_labels)
lowercase :Tuple = '''huggingface/label-files'''
lowercase :List[str] = num_labels
lowercase :Union[str, Any] = json.load(open(hf_hub_download(a_ , a_ , repo_type='''dataset''') , '''r'''))
lowercase :Any = {int(a_): v for k, v in idalabel.items()}
lowercase :str = idalabel
lowercase :Any = {v: k for k, v in idalabel.items()}
lowercase :Union[str, Any] = partial(a_ , num_labels=a_ , idalabel=a_ , labelaid=a_)
lowercase :Optional[int] = {
'''resnet18''': ImageNetPreTrainedConfig(
depths=[2, 2, 2, 2] , hidden_sizes=[64, 128, 256, 512] , layer_type='''basic'''),
'''resnet26''': ImageNetPreTrainedConfig(
depths=[2, 2, 2, 2] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet34''': ImageNetPreTrainedConfig(
depths=[3, 4, 6, 3] , hidden_sizes=[64, 128, 256, 512] , layer_type='''basic'''),
'''resnet50''': ImageNetPreTrainedConfig(
depths=[3, 4, 6, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet101''': ImageNetPreTrainedConfig(
depths=[3, 4, 23, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet152''': ImageNetPreTrainedConfig(
depths=[3, 8, 36, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
}
if model_name:
convert_weight_and_push(a_ , names_to_config[model_name] , a_ , a_)
else:
for model_name, config in names_to_config.items():
convert_weight_and_push(a_ , a_ , a_ , a_)
return config, expected_shape
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'''--model_name''',
default=None,
type=str,
help=(
'''The name of the model you wish to convert, it must be one of the supported resnet* architecture,'''
''' currently: resnet18,26,34,50,101,152. If `None`, all of them will the converted.'''
),
)
parser.add_argument(
'''--pytorch_dump_folder_path''',
default=None,
type=Path,
required=True,
help='''Path to the output PyTorch model directory.''',
)
parser.add_argument(
'''--push_to_hub''',
default=True,
type=bool,
required=False,
help='''If True, push model and image processor to the hub.''',
)
UpperCAmelCase = parser.parse_args()
UpperCAmelCase = args.pytorch_dump_folder_path
pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
| 677 | 1 |
"""simple docstring"""
import logging
import numpy as np
import pytest
from scipy.linalg import eigh
logging.basicConfig(level=logging.INFO, format='''%(message)s''')
def lowerCamelCase (a_ :np.ndarray) -> np.ndarray:
return input_array.reshape((input_array.size, 1))
def lowerCamelCase (a_ :np.ndarray , a_ :np.ndarray , a_ :int) -> np.ndarray:
lowercase :Tuple = np.nan
for i in range(a_):
lowercase :Tuple = features[:, labels == i]
lowercase :Tuple = data.mean(1)
# Centralize the data of class i
lowercase :List[Any] = data - column_reshape(a_)
if i > 0:
# If covariance_sum is not None
covariance_sum += np.dot(a_ , centered_data.T)
else:
# If covariance_sum is np.nan (i.e. first loop)
lowercase :List[str] = np.dot(a_ , centered_data.T)
return covariance_sum / features.shape[1]
def lowerCamelCase (a_ :np.ndarray , a_ :np.ndarray , a_ :int) -> np.ndarray:
lowercase :str = features.mean(1)
lowercase :Any = np.nan
for i in range(a_):
lowercase :str = features[:, labels == i]
lowercase :List[str] = data.shape[1]
lowercase :int = data.mean(1)
if i > 0:
# If covariance_sum is not None
covariance_sum += device_data * np.dot(
column_reshape(a_) - column_reshape(a_) , (column_reshape(a_) - column_reshape(a_)).T , )
else:
# If covariance_sum is np.nan (i.e. first loop)
lowercase :List[Any] = device_data * np.dot(
column_reshape(a_) - column_reshape(a_) , (column_reshape(a_) - column_reshape(a_)).T , )
return covariance_sum / features.shape[1]
def lowerCamelCase (a_ :np.ndarray , a_ :int) -> np.ndarray:
# Check if the features have been loaded
if features.any():
lowercase :List[Any] = features.mean(1)
# Center the dataset
lowercase :Dict = features - np.reshape(a_ , (data_mean.size, 1))
lowercase :Dict = np.dot(a_ , centered_data.T) / features.shape[1]
lowercase , lowercase :Any = np.linalg.eigh(a_)
# Take all the columns in the reverse order (-1), and then takes only the first
lowercase :List[str] = eigenvectors[:, ::-1][:, 0:dimensions]
# Project the database on the new space
lowercase :List[Any] = np.dot(filtered_eigenvectors.T , a_)
logging.info('''Principal Component Analysis computed''')
return projected_data
else:
logging.basicConfig(level=logging.ERROR , format='''%(message)s''' , force=a_)
logging.error('''Dataset empty''')
raise AssertionError
def lowerCamelCase (a_ :np.ndarray , a_ :np.ndarray , a_ :int , a_ :int) -> np.ndarray:
assert classes > dimensions
# Check if features have been already loaded
if features.any:
lowercase , lowercase :List[Any] = eigh(
covariance_between_classes(a_ , a_ , a_) , covariance_within_classes(a_ , a_ , a_) , )
lowercase :Union[str, Any] = eigenvectors[:, ::-1][:, :dimensions]
lowercase , lowercase , lowercase :Tuple = np.linalg.svd(a_)
lowercase :List[str] = svd_matrix[:, 0:dimensions]
lowercase :Tuple = np.dot(filtered_svd_matrix.T , a_)
logging.info('''Linear Discriminant Analysis computed''')
return projected_data
else:
logging.basicConfig(level=logging.ERROR , format='''%(message)s''' , force=a_)
logging.error('''Dataset empty''')
raise AssertionError
def lowerCamelCase () -> None:
# Create dummy dataset with 2 classes and 3 features
lowercase :Union[str, Any] = np.array([[1, 2, 3, 4, 5], [2, 3, 4, 5, 6], [3, 4, 5, 6, 7]])
lowercase :List[Any] = np.array([0, 0, 0, 1, 1])
lowercase :List[str] = 2
lowercase :str = 2
# Assert that the function raises an AssertionError if dimensions > classes
with pytest.raises(a_) as error_info:
lowercase :Tuple = linear_discriminant_analysis(
a_ , a_ , a_ , a_)
if isinstance(a_ , np.ndarray):
raise AssertionError(
'''Did not raise AssertionError for dimensions > classes''')
assert error_info.type is AssertionError
def lowerCamelCase () -> None:
lowercase :Any = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
lowercase :Union[str, Any] = 2
lowercase :List[str] = np.array([[6.92_82_03_23, 8.66_02_54_04, 10.39_23_04_85], [3.0, 3.0, 3.0]])
with pytest.raises(a_) as error_info:
lowercase :Optional[Any] = principal_component_analysis(a_ , a_)
if not np.allclose(a_ , a_):
raise AssertionError
assert error_info.type is AssertionError
if __name__ == "__main__":
import doctest
doctest.testmod()
| 677 |
"""simple docstring"""
from __future__ import annotations
import unittest
from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin
if is_tf_available():
import tensorflow as tf
from transformers import (
TF_MODEL_FOR_PRETRAINING_MAPPING,
TFMobileBertForMaskedLM,
TFMobileBertForMultipleChoice,
TFMobileBertForNextSentencePrediction,
TFMobileBertForPreTraining,
TFMobileBertForQuestionAnswering,
TFMobileBertForSequenceClassification,
TFMobileBertForTokenClassification,
TFMobileBertModel,
)
@require_tf
class __magic_name__ ( __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
__A : Any = (
(
TFMobileBertModel,
TFMobileBertForMaskedLM,
TFMobileBertForNextSentencePrediction,
TFMobileBertForPreTraining,
TFMobileBertForQuestionAnswering,
TFMobileBertForSequenceClassification,
TFMobileBertForTokenClassification,
TFMobileBertForMultipleChoice,
)
if is_tf_available()
else ()
)
__A : List[Any] = (
{
"feature-extraction": TFMobileBertModel,
"fill-mask": TFMobileBertForMaskedLM,
"question-answering": TFMobileBertForQuestionAnswering,
"text-classification": TFMobileBertForSequenceClassification,
"token-classification": TFMobileBertForTokenClassification,
"zero-shot": TFMobileBertForSequenceClassification,
}
if is_tf_available()
else {}
)
__A : List[str] = False
__A : int = False
def __snake_case ( self : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Any , snake_case__ : int=False ):
'''simple docstring'''
lowercase :Union[str, Any] = super()._prepare_for_class(snake_case__ , snake_case__ , return_labels=snake_case__ )
if return_labels:
if model_class in get_values(snake_case__ ):
lowercase :Tuple = tf.zeros(self.model_tester.batch_size , dtype=tf.intaa )
return inputs_dict
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Any , snake_case__ : Dict , snake_case__ : Dict=1_3 , snake_case__ : Tuple=7 , snake_case__ : Optional[Any]=True , snake_case__ : Union[str, Any]=True , snake_case__ : str=True , snake_case__ : Optional[Any]=True , snake_case__ : Any=9_9 , snake_case__ : Optional[Any]=3_2 , snake_case__ : Optional[Any]=3_2 , snake_case__ : Any=2 , snake_case__ : Optional[int]=4 , snake_case__ : List[Any]=3_7 , snake_case__ : Optional[int]="gelu" , snake_case__ : List[Any]=0.1 , snake_case__ : str=0.1 , snake_case__ : List[Any]=5_1_2 , snake_case__ : List[str]=1_6 , snake_case__ : Union[str, Any]=2 , snake_case__ : Optional[Any]=0.02 , snake_case__ : Optional[Any]=3 , snake_case__ : Dict=4 , snake_case__ : int=None , ):
'''simple docstring'''
lowercase :Tuple = parent
lowercase :Tuple = batch_size
lowercase :Optional[Any] = seq_length
lowercase :Optional[Any] = is_training
lowercase :Optional[Any] = use_input_mask
lowercase :List[Any] = use_token_type_ids
lowercase :str = use_labels
lowercase :List[str] = vocab_size
lowercase :str = hidden_size
lowercase :Optional[int] = num_hidden_layers
lowercase :Dict = num_attention_heads
lowercase :Any = intermediate_size
lowercase :List[str] = hidden_act
lowercase :Optional[Any] = hidden_dropout_prob
lowercase :List[Any] = attention_probs_dropout_prob
lowercase :List[Any] = max_position_embeddings
lowercase :List[Any] = type_vocab_size
lowercase :Union[str, Any] = type_sequence_label_size
lowercase :Union[str, Any] = initializer_range
lowercase :Any = num_labels
lowercase :int = num_choices
lowercase :Dict = scope
lowercase :Dict = embedding_size
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :Optional[int] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size )
lowercase :int = None
if self.use_input_mask:
lowercase :int = random_attention_mask([self.batch_size, self.seq_length] )
lowercase :Tuple = None
if self.use_token_type_ids:
lowercase :int = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size )
lowercase :Union[str, Any] = None
lowercase :int = None
lowercase :str = None
if self.use_labels:
lowercase :int = ids_tensor([self.batch_size] , self.type_sequence_label_size )
lowercase :str = ids_tensor([self.batch_size, self.seq_length] , self.num_labels )
lowercase :Dict = ids_tensor([self.batch_size] , self.num_choices )
lowercase :Optional[int] = MobileBertConfig(
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 , embedding_size=self.embedding_size , )
return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
def __snake_case ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Any , snake_case__ : Tuple , snake_case__ : Tuple ):
'''simple docstring'''
lowercase :Dict = TFMobileBertModel(config=snake_case__ )
lowercase :Union[str, Any] = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
lowercase :Optional[int] = [input_ids, input_mask]
lowercase :Optional[int] = model(snake_case__ )
lowercase :Union[str, Any] = model(snake_case__ )
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 : List[Any] , snake_case__ : Dict , snake_case__ : Optional[int] , snake_case__ : int , snake_case__ : str , snake_case__ : Dict , snake_case__ : Tuple , snake_case__ : Optional[int] ):
'''simple docstring'''
lowercase :Any = TFMobileBertForMaskedLM(config=snake_case__ )
lowercase :Any = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :int = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) )
def __snake_case ( self : Tuple , snake_case__ : Any , snake_case__ : Optional[Any] , snake_case__ : List[Any] , snake_case__ : Dict , snake_case__ : str , snake_case__ : List[Any] , snake_case__ : Tuple ):
'''simple docstring'''
lowercase :Optional[Any] = TFMobileBertForNextSentencePrediction(config=snake_case__ )
lowercase :Tuple = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :Optional[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, 2) )
def __snake_case ( self : Dict , snake_case__ : Optional[Any] , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : Optional[int] , snake_case__ : int , snake_case__ : Union[str, Any] , snake_case__ : Dict ):
'''simple docstring'''
lowercase :int = TFMobileBertForPreTraining(config=snake_case__ )
lowercase :Any = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
self.parent.assertEqual(
result.prediction_logits.shape , (self.batch_size, self.seq_length, self.vocab_size) )
self.parent.assertEqual(result.seq_relationship_logits.shape , (self.batch_size, 2) )
def __snake_case ( self : Optional[Any] , snake_case__ : Tuple , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Optional[Any] , snake_case__ : List[str] , snake_case__ : Dict , snake_case__ : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = self.num_labels
lowercase :List[Any] = TFMobileBertForSequenceClassification(config=snake_case__ )
lowercase :Dict = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def __snake_case ( self : Any , snake_case__ : Optional[int] , snake_case__ : Tuple , snake_case__ : Union[str, Any] , snake_case__ : List[Any] , snake_case__ : List[Any] , snake_case__ : List[Any] , snake_case__ : Optional[Any] ):
'''simple docstring'''
lowercase :Tuple = self.num_choices
lowercase :Any = TFMobileBertForMultipleChoice(config=snake_case__ )
lowercase :Any = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :Union[str, Any] = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :List[Any] = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :Dict = {
'''input_ids''': multiple_choice_inputs_ids,
'''attention_mask''': multiple_choice_input_mask,
'''token_type_ids''': multiple_choice_token_type_ids,
}
lowercase :Optional[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) )
def __snake_case ( self : Any , snake_case__ : str , snake_case__ : Tuple , snake_case__ : int , snake_case__ : Tuple , snake_case__ : Dict , snake_case__ : Optional[Any] , snake_case__ : Dict ):
'''simple docstring'''
lowercase :List[Any] = self.num_labels
lowercase :List[str] = TFMobileBertForTokenClassification(config=snake_case__ )
lowercase :int = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :int = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) )
def __snake_case ( self : List[str] , snake_case__ : List[Any] , snake_case__ : Optional[int] , snake_case__ : Optional[int] , snake_case__ : List[Any] , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : str ):
'''simple docstring'''
lowercase :Union[str, Any] = TFMobileBertForQuestionAnswering(config=snake_case__ )
lowercase :List[Any] = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :str = model(snake_case__ )
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 : List[Any] ):
'''simple docstring'''
lowercase :Dict = self.prepare_config_and_inputs()
(
(
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) ,
) :Dict = config_and_inputs
lowercase :Optional[Any] = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
return config, inputs_dict
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = TFMobileBertModelTest.TFMobileBertModelTester(self )
lowercase :List[str] = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
self.config_tester.run_common_tests()
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :List[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_model(*snake_case__ )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :List[str] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_masked_lm(*snake_case__ )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :str = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_multiple_choice(*snake_case__ )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :Tuple = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*snake_case__ )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :int = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_pretraining(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Tuple = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_question_answering(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Optional[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_sequence_classification(*snake_case__ )
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_token_classification(*snake_case__ )
@slow
def __snake_case ( self : int ):
'''simple docstring'''
for model_name in ["google/mobilebert-uncased"]:
lowercase :List[str] = TFMobileBertModel.from_pretrained(snake_case__ )
self.assertIsNotNone(snake_case__ )
@require_tf
class __magic_name__ ( unittest.TestCase ):
@slow
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :int = TFMobileBertForPreTraining.from_pretrained('''google/mobilebert-uncased''' )
lowercase :Optional[Any] = tf.constant([[0, 1, 2, 3, 4, 5]] )
lowercase :List[Any] = model(snake_case__ )[0]
lowercase :Union[str, Any] = [1, 6, 3_0_5_2_2]
self.assertEqual(output.shape , snake_case__ )
lowercase :Optional[int] = tf.constant(
[
[
[-4.5_91_95_47, -9.24_82_95, -9.64_52_56],
[-6.7_30_61_75, -6.44_02_84, -6.6_05_28_37],
[-7.2_74_35_06, -6.7_84_79_15, -6.02_46_73],
]
] )
tf.debugging.assert_near(output[:, :3, :3] , snake_case__ , atol=1e-4 )
| 677 | 1 |
"""simple docstring"""
import unittest
from knapsack import knapsack as k
class __magic_name__ ( unittest.TestCase ):
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Union[str, Any] = 0
lowercase :Any = [0]
lowercase :List[Any] = [0]
lowercase :Any = len(snake_case__ )
self.assertEqual(k.knapsack(snake_case__ , snake_case__ , snake_case__ , snake_case__ ) , 0 )
lowercase :Optional[int] = [6_0]
lowercase :int = [1_0]
lowercase :Any = len(snake_case__ )
self.assertEqual(k.knapsack(snake_case__ , snake_case__ , snake_case__ , snake_case__ ) , 0 )
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :int = 3
lowercase :Tuple = [1, 2, 3]
lowercase :Dict = [3, 2, 1]
lowercase :List[str] = len(snake_case__ )
self.assertEqual(k.knapsack(snake_case__ , snake_case__ , snake_case__ , snake_case__ ) , 5 )
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :Optional[Any] = 5_0
lowercase :Dict = [6_0, 1_0_0, 1_2_0]
lowercase :Union[str, Any] = [1_0, 2_0, 3_0]
lowercase :Any = len(snake_case__ )
self.assertEqual(k.knapsack(snake_case__ , snake_case__ , snake_case__ , snake_case__ ) , 2_2_0 )
if __name__ == "__main__":
unittest.main()
| 677 |
"""simple docstring"""
import contextlib
import copy
import random
from typing import Any, Dict, Iterable, Optional, Union
import numpy as np
import torch
from .utils import deprecate, is_transformers_available
if is_transformers_available():
import transformers
def lowerCamelCase (a_ :int) -> List[str]:
random.seed(a_)
np.random.seed(a_)
torch.manual_seed(a_)
torch.cuda.manual_seed_all(a_)
# ^^ safe to call this function even if cuda is not available
class __magic_name__ :
def __init__( self : Optional[Any] , snake_case__ : Iterable[torch.nn.Parameter] , snake_case__ : float = 0.99_99 , snake_case__ : float = 0.0 , snake_case__ : int = 0 , snake_case__ : bool = False , snake_case__ : Union[float, int] = 1.0 , snake_case__ : Union[float, int] = 2 / 3 , snake_case__ : Optional[Any] = None , snake_case__ : Dict[str, Any] = None , **snake_case__ : Tuple , ):
'''simple docstring'''
if isinstance(snake_case__ , torch.nn.Module ):
lowercase :int = (
'''Passing a `torch.nn.Module` to `ExponentialMovingAverage` is deprecated. '''
'''Please pass the parameters of the module instead.'''
)
deprecate(
'''passing a `torch.nn.Module` to `ExponentialMovingAverage`''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ , )
lowercase :Dict = parameters.parameters()
# set use_ema_warmup to True if a torch.nn.Module is passed for backwards compatibility
lowercase :Optional[Any] = True
if kwargs.get('''max_value''' , snake_case__ ) is not None:
lowercase :Optional[Any] = '''The `max_value` argument is deprecated. Please use `decay` instead.'''
deprecate('''max_value''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
lowercase :Optional[int] = kwargs['''max_value''']
if kwargs.get('''min_value''' , snake_case__ ) is not None:
lowercase :List[Any] = '''The `min_value` argument is deprecated. Please use `min_decay` instead.'''
deprecate('''min_value''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
lowercase :str = kwargs['''min_value''']
lowercase :Any = list(snake_case__ )
lowercase :Optional[Any] = [p.clone().detach() for p in parameters]
if kwargs.get('''device''' , snake_case__ ) is not None:
lowercase :str = '''The `device` argument is deprecated. Please use `to` instead.'''
deprecate('''device''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
self.to(device=kwargs['''device'''] )
lowercase :int = None
lowercase :int = decay
lowercase :Union[str, Any] = min_decay
lowercase :List[Any] = update_after_step
lowercase :Union[str, Any] = use_ema_warmup
lowercase :Any = inv_gamma
lowercase :Any = power
lowercase :str = 0
lowercase :int = None # set in `step()`
lowercase :List[str] = model_cls
lowercase :Any = model_config
@classmethod
def __snake_case ( cls : int , snake_case__ : Tuple , snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase , lowercase :int = model_cls.load_config(snake_case__ , return_unused_kwargs=snake_case__ )
lowercase :List[Any] = model_cls.from_pretrained(snake_case__ )
lowercase :Optional[int] = cls(model.parameters() , model_cls=snake_case__ , model_config=model.config )
ema_model.load_state_dict(snake_case__ )
return ema_model
def __snake_case ( self : int , snake_case__ : Union[str, Any] ):
'''simple docstring'''
if self.model_cls is None:
raise ValueError('''`save_pretrained` can only be used if `model_cls` was defined at __init__.''' )
if self.model_config is None:
raise ValueError('''`save_pretrained` can only be used if `model_config` was defined at __init__.''' )
lowercase :Dict = self.model_cls.from_config(self.model_config )
lowercase :Tuple = self.state_dict()
state_dict.pop('''shadow_params''' , snake_case__ )
model.register_to_config(**snake_case__ )
self.copy_to(model.parameters() )
model.save_pretrained(snake_case__ )
def __snake_case ( self : int , snake_case__ : int ):
'''simple docstring'''
lowercase :Union[str, Any] = max(0 , optimization_step - self.update_after_step - 1 )
if step <= 0:
return 0.0
if self.use_ema_warmup:
lowercase :int = 1 - (1 + step / self.inv_gamma) ** -self.power
else:
lowercase :Dict = (1 + step) / (1_0 + step)
lowercase :Optional[int] = min(snake_case__ , self.decay )
# make sure decay is not smaller than min_decay
lowercase :Optional[int] = max(snake_case__ , self.min_decay )
return cur_decay_value
@torch.no_grad()
def __snake_case ( self : Any , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
if isinstance(snake_case__ , torch.nn.Module ):
lowercase :Tuple = (
'''Passing a `torch.nn.Module` to `ExponentialMovingAverage.step` is deprecated. '''
'''Please pass the parameters of the module instead.'''
)
deprecate(
'''passing a `torch.nn.Module` to `ExponentialMovingAverage.step`''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ , )
lowercase :Union[str, Any] = parameters.parameters()
lowercase :Optional[Any] = list(snake_case__ )
self.optimization_step += 1
# Compute the decay factor for the exponential moving average.
lowercase :List[Any] = self.get_decay(self.optimization_step )
lowercase :Optional[Any] = decay
lowercase :List[Any] = 1 - decay
lowercase :List[str] = contextlib.nullcontext
if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
import deepspeed
for s_param, param in zip(self.shadow_params , snake_case__ ):
if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
lowercase :Union[str, Any] = deepspeed.zero.GatheredParameters(snake_case__ , modifier_rank=snake_case__ )
with context_manager():
if param.requires_grad:
s_param.sub_(one_minus_decay * (s_param - param) )
else:
s_param.copy_(snake_case__ )
def __snake_case ( self : str , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
lowercase :Optional[Any] = list(snake_case__ )
for s_param, param in zip(self.shadow_params , snake_case__ ):
param.data.copy_(s_param.to(param.device ).data )
def __snake_case ( self : Optional[int] , snake_case__ : Dict=None , snake_case__ : Dict=None ):
'''simple docstring'''
lowercase :str = [
p.to(device=snake_case__ , dtype=snake_case__ ) if p.is_floating_point() else p.to(device=snake_case__ )
for p in self.shadow_params
]
def __snake_case ( self : Dict ):
'''simple docstring'''
return {
"decay": self.decay,
"min_decay": self.min_decay,
"optimization_step": self.optimization_step,
"update_after_step": self.update_after_step,
"use_ema_warmup": self.use_ema_warmup,
"inv_gamma": self.inv_gamma,
"power": self.power,
"shadow_params": self.shadow_params,
}
def __snake_case ( self : Optional[int] , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
lowercase :str = [param.detach().cpu().clone() for param in parameters]
def __snake_case ( self : List[Any] , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
if self.temp_stored_params is None:
raise RuntimeError('''This ExponentialMovingAverage has no `store()`ed weights ''' '''to `restore()`''' )
for c_param, param in zip(self.temp_stored_params , snake_case__ ):
param.data.copy_(c_param.data )
# Better memory-wise.
lowercase :Dict = None
def __snake_case ( self : Union[str, Any] , snake_case__ : dict ):
'''simple docstring'''
lowercase :List[str] = copy.deepcopy(snake_case__ )
lowercase :Any = state_dict.get('''decay''' , self.decay )
if self.decay < 0.0 or self.decay > 1.0:
raise ValueError('''Decay must be between 0 and 1''' )
lowercase :int = state_dict.get('''min_decay''' , self.min_decay )
if not isinstance(self.min_decay , snake_case__ ):
raise ValueError('''Invalid min_decay''' )
lowercase :List[Any] = state_dict.get('''optimization_step''' , self.optimization_step )
if not isinstance(self.optimization_step , snake_case__ ):
raise ValueError('''Invalid optimization_step''' )
lowercase :int = state_dict.get('''update_after_step''' , self.update_after_step )
if not isinstance(self.update_after_step , snake_case__ ):
raise ValueError('''Invalid update_after_step''' )
lowercase :Optional[int] = state_dict.get('''use_ema_warmup''' , self.use_ema_warmup )
if not isinstance(self.use_ema_warmup , snake_case__ ):
raise ValueError('''Invalid use_ema_warmup''' )
lowercase :Any = state_dict.get('''inv_gamma''' , self.inv_gamma )
if not isinstance(self.inv_gamma , (float, int) ):
raise ValueError('''Invalid inv_gamma''' )
lowercase :Dict = state_dict.get('''power''' , self.power )
if not isinstance(self.power , (float, int) ):
raise ValueError('''Invalid power''' )
lowercase :Optional[int] = state_dict.get('''shadow_params''' , snake_case__ )
if shadow_params is not None:
lowercase :List[Any] = shadow_params
if not isinstance(self.shadow_params , snake_case__ ):
raise ValueError('''shadow_params must be a list''' )
if not all(isinstance(snake_case__ , torch.Tensor ) for p in self.shadow_params ):
raise ValueError('''shadow_params must all be Tensors''' )
| 677 | 1 |
"""simple docstring"""
from __future__ import annotations
def lowerCamelCase (a_ :list[int]) -> bool:
return len(set(a_)) == len(a_)
if __name__ == "__main__":
import doctest
doctest.testmod()
| 677 |
"""simple docstring"""
import argparse
import collections
import numpy as np
import torch
from flax import traverse_util
from tax import checkpoints
from transformers import MTaConfig, UMTaEncoderModel, UMTaForConditionalGeneration
from transformers.utils import logging
logging.set_verbosity_info()
def lowerCamelCase (a_ :int , a_ :Union[str, Any] , a_ :List[Any]) -> List[str]:
return params[F"""{prefix}/{prefix}/relpos_bias/rel_embedding"""][:, i, :]
def lowerCamelCase (a_ :Optional[Any] , a_ :Optional[int] , a_ :str , a_ :Any="attention") -> Optional[int]:
lowercase :Tuple = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/key/kernel"""][:, i, :, :])
lowercase :int = k_tmp.reshape(k_tmp.shape[0] , k_tmp.shape[1] * k_tmp.shape[2])
lowercase :str = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/out/kernel"""][:, i, :, :])
lowercase :Any = o_tmp.reshape(o_tmp.shape[0] * o_tmp.shape[1] , o_tmp.shape[2])
lowercase :int = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/query/kernel"""][:, i, :, :])
lowercase :List[str] = q_tmp.reshape(q_tmp.shape[0] , q_tmp.shape[1] * q_tmp.shape[2])
lowercase :List[Any] = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/value/kernel"""][:, i, :, :])
lowercase :Optional[int] = v_tmp.reshape(v_tmp.shape[0] , v_tmp.shape[1] * v_tmp.shape[2])
return k, o, q, v
def lowerCamelCase (a_ :Any , a_ :Union[str, Any] , a_ :Union[str, Any] , a_ :Union[str, Any]=False) -> List[Any]:
if split_mlp_wi:
lowercase :List[Any] = params[F"""{prefix}/{prefix}/mlp/wi_0/kernel"""][:, i, :]
lowercase :Optional[int] = params[F"""{prefix}/{prefix}/mlp/wi_1/kernel"""][:, i, :]
lowercase :Dict = (wi_a, wi_a)
else:
lowercase :Optional[Any] = params[F"""{prefix}/{prefix}/mlp/wi/kernel"""][:, i, :]
lowercase :Union[str, Any] = params[F"""{prefix}/{prefix}/mlp/wo/kernel"""][:, i, :]
return wi, wo
def lowerCamelCase (a_ :Any , a_ :Optional[Any] , a_ :Optional[Any] , a_ :Union[str, Any]) -> Optional[Any]:
return params[F"""{prefix}/{prefix}/{layer_name}/scale"""][:, i]
def lowerCamelCase (a_ :dict , *, a_ :int , a_ :bool , a_ :bool = False) -> int:
lowercase :Dict = traverse_util.flatten_dict(variables['''target'''])
lowercase :Optional[Any] = {'''/'''.join(a_): v for k, v in old.items()}
# v1.1 models have a gated GeLU with wi_0 and wi_1 instead of wi
lowercase :str = '''encoder/encoder/mlp/wi_0/kernel''' in old
print('''Split MLP:''' , a_)
lowercase :str = collections.OrderedDict()
# Shared embeddings.
lowercase :int = old['''token_embedder/embedding''']
# Encoder.
for i in range(a_):
# Block i, layer 0 (Self Attention).
lowercase :Union[str, Any] = tax_layer_norm_lookup(a_ , a_ , '''encoder''' , '''pre_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :Tuple = tax_attention_lookup(a_ , a_ , '''encoder''' , '''attention''')
lowercase :Dict = layer_norm
lowercase :Dict = k.T
lowercase :Union[str, Any] = o.T
lowercase :List[Any] = q.T
lowercase :int = v.T
# Block i, layer 1 (MLP).
lowercase :Optional[int] = tax_layer_norm_lookup(a_ , a_ , '''encoder''' , '''pre_mlp_layer_norm''')
lowercase , lowercase :str = tax_mlp_lookup(a_ , a_ , '''encoder''' , a_)
lowercase :int = layer_norm
if split_mlp_wi:
lowercase :Tuple = wi[0].T
lowercase :Tuple = wi[1].T
else:
lowercase :int = wi.T
lowercase :Tuple = wo.T
if scalable_attention:
# convert the rel_embedding of each layer
lowercase :Dict = tax_relpos_bias_lookup(
a_ , a_ , '''encoder''').T
lowercase :str = old['''encoder/encoder_norm/scale''']
if not scalable_attention:
lowercase :str = tax_relpos_bias_lookup(
a_ , 0 , '''encoder''').T
lowercase :List[Any] = tax_relpos_bias_lookup(
a_ , 0 , '''decoder''').T
if not is_encoder_only:
# Decoder.
for i in range(a_):
# Block i, layer 0 (Self Attention).
lowercase :Any = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_self_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :str = tax_attention_lookup(a_ , a_ , '''decoder''' , '''self_attention''')
lowercase :List[str] = layer_norm
lowercase :Dict = k.T
lowercase :List[Any] = o.T
lowercase :List[Any] = q.T
lowercase :Any = v.T
# Block i, layer 1 (Cross Attention).
lowercase :Tuple = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_cross_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :int = tax_attention_lookup(a_ , a_ , '''decoder''' , '''encoder_decoder_attention''')
lowercase :int = layer_norm
lowercase :Dict = k.T
lowercase :int = o.T
lowercase :List[Any] = q.T
lowercase :Tuple = v.T
# Block i, layer 2 (MLP).
lowercase :Any = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_mlp_layer_norm''')
lowercase , lowercase :Tuple = tax_mlp_lookup(a_ , a_ , '''decoder''' , a_)
lowercase :Any = layer_norm
if split_mlp_wi:
lowercase :int = wi[0].T
lowercase :Union[str, Any] = wi[1].T
else:
lowercase :int = wi.T
lowercase :List[Any] = wo.T
if scalable_attention:
# convert the rel_embedding of each layer
lowercase :Union[str, Any] = tax_relpos_bias_lookup(a_ , a_ , '''decoder''').T
lowercase :Union[str, Any] = old['''decoder/decoder_norm/scale''']
# LM Head (only in v1.1 checkpoints, in v1.0 embeddings are used instead)
if "decoder/logits_dense/kernel" in old:
lowercase :int = old['''decoder/logits_dense/kernel'''].T
return new
def lowerCamelCase (a_ :Dict , a_ :bool) -> Tuple:
lowercase :str = collections.OrderedDict([(k, torch.from_numpy(v.copy())) for (k, v) in converted_params.items()])
# Add what is missing.
if "encoder.embed_tokens.weight" not in state_dict:
lowercase :Any = state_dict['''shared.weight''']
if not is_encoder_only:
if "decoder.embed_tokens.weight" not in state_dict:
lowercase :Optional[Any] = state_dict['''shared.weight''']
if "lm_head.weight" not in state_dict: # For old 1.0 models.
print('''Using shared word embeddings as lm_head.''')
lowercase :Optional[int] = state_dict['''shared.weight''']
return state_dict
def lowerCamelCase (a_ :List[str] , a_ :List[str] , a_ :Tuple , a_ :Optional[int] , a_ :List[str]) -> List[str]:
lowercase :Optional[Any] = checkpoints.load_tax_checkpoint(a_)
lowercase :Optional[int] = convert_tax_to_pytorch(
a_ , num_layers=config.num_layers , is_encoder_only=a_ , scalable_attention=a_)
lowercase :Union[str, Any] = make_state_dict(a_ , a_)
model.load_state_dict(a_ , strict=a_)
def lowerCamelCase (a_ :str , a_ :Optional[int] , a_ :Any , a_ :bool = False , a_ :bool = False , ) -> Tuple:
lowercase :Optional[int] = MTaConfig.from_json_file(a_)
print(F"""Building PyTorch model from configuration: {config}""")
# Non-v1.1 checkpoints could also use T5Model, but this works for all.
# The v1.0 checkpoints will simply have an LM head that is the word embeddings.
if is_encoder_only:
lowercase :Union[str, Any] = UMTaEncoderModel(a_)
else:
lowercase :int = UMTaForConditionalGeneration(a_)
# Load weights from tf checkpoint
load_tax_weights_in_ta(a_ , a_ , a_ , a_ , a_)
# Save pytorch-model
print(F"""Save PyTorch model to {pytorch_dump_path}""")
model.save_pretrained(a_)
# Verify that we can load the checkpoint.
model.from_pretrained(a_)
print('''Done''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser(description='''Converts a native T5X checkpoint into a PyTorch checkpoint.''')
# Required parameters
parser.add_argument(
'''--t5x_checkpoint_path''', default=None, type=str, required=True, help='''Path to the T5X checkpoint.'''
)
parser.add_argument(
'''--config_file''',
default=None,
type=str,
required=True,
help='''The config json file corresponding to the pre-trained T5 model.\nThis specifies the model architecture.''',
)
parser.add_argument(
'''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
)
parser.add_argument(
'''--is_encoder_only''', action='''store_true''', help='''Check if the model is encoder-decoder model''', default=False
)
parser.add_argument(
'''--scalable_attention''',
action='''store_true''',
help='''Whether the model uses scaled attention (umt5 model)''',
default=False,
)
UpperCAmelCase = parser.parse_args()
convert_tax_checkpoint_to_pytorch(
args.tax_checkpoint_path,
args.config_file,
args.pytorch_dump_path,
args.is_encoder_only,
args.scalable_attention,
)
| 677 | 1 |
"""simple docstring"""
import json
from typing import List, Optional, Tuple
from tokenizers import normalizers
from tokenizers.pre_tokenizers import BertPreTokenizer, PreTokenizer
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_roformer import RoFormerTokenizer
from .tokenization_utils import JiebaPreTokenizer
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}
UpperCAmelCase = {
'''vocab_file''': {
'''junnyu/roformer_chinese_small''': '''https://huggingface.co/junnyu/roformer_chinese_small/resolve/main/vocab.txt''',
'''junnyu/roformer_chinese_base''': '''https://huggingface.co/junnyu/roformer_chinese_base/resolve/main/vocab.txt''',
'''junnyu/roformer_chinese_char_small''': (
'''https://huggingface.co/junnyu/roformer_chinese_char_small/resolve/main/vocab.txt'''
),
'''junnyu/roformer_chinese_char_base''': (
'''https://huggingface.co/junnyu/roformer_chinese_char_base/resolve/main/vocab.txt'''
),
'''junnyu/roformer_small_discriminator''': (
'''https://huggingface.co/junnyu/roformer_small_discriminator/resolve/main/vocab.txt'''
),
'''junnyu/roformer_small_generator''': (
'''https://huggingface.co/junnyu/roformer_small_generator/resolve/main/vocab.txt'''
),
}
}
UpperCAmelCase = {
'''junnyu/roformer_chinese_small''': 1_536,
'''junnyu/roformer_chinese_base''': 1_536,
'''junnyu/roformer_chinese_char_small''': 512,
'''junnyu/roformer_chinese_char_base''': 512,
'''junnyu/roformer_small_discriminator''': 128,
'''junnyu/roformer_small_generator''': 128,
}
UpperCAmelCase = {
'''junnyu/roformer_chinese_small''': {'''do_lower_case''': True},
'''junnyu/roformer_chinese_base''': {'''do_lower_case''': True},
'''junnyu/roformer_chinese_char_small''': {'''do_lower_case''': True},
'''junnyu/roformer_chinese_char_base''': {'''do_lower_case''': True},
'''junnyu/roformer_small_discriminator''': {'''do_lower_case''': True},
'''junnyu/roformer_small_generator''': {'''do_lower_case''': True},
}
class __magic_name__ ( __UpperCAmelCase ):
__A : Any = VOCAB_FILES_NAMES
__A : Any = PRETRAINED_VOCAB_FILES_MAP
__A : Optional[int] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
__A : List[Any] = PRETRAINED_INIT_CONFIGURATION
__A : List[str] = RoFormerTokenizer
def __init__( self : int , snake_case__ : Optional[int]=None , snake_case__ : Optional[int]=None , snake_case__ : Dict=True , snake_case__ : Union[str, Any]="[UNK]" , snake_case__ : Union[str, Any]="[SEP]" , snake_case__ : str="[PAD]" , snake_case__ : Optional[Any]="[CLS]" , snake_case__ : int="[MASK]" , snake_case__ : int=True , snake_case__ : Union[str, Any]=None , **snake_case__ : Any , ):
'''simple docstring'''
super().__init__(
snake_case__ , tokenizer_file=snake_case__ , do_lower_case=snake_case__ , unk_token=snake_case__ , sep_token=snake_case__ , pad_token=snake_case__ , cls_token=snake_case__ , mask_token=snake_case__ , tokenize_chinese_chars=snake_case__ , strip_accents=snake_case__ , **snake_case__ , )
lowercase :Union[str, Any] = json.loads(self.backend_tokenizer.normalizer.__getstate__() )
if (
pre_tok_state.get('''lowercase''' , snake_case__ ) != do_lower_case
or pre_tok_state.get('''strip_accents''' , snake_case__ ) != strip_accents
):
lowercase :Tuple = getattr(snake_case__ , pre_tok_state.pop('''type''' ) )
lowercase :Any = do_lower_case
lowercase :Tuple = strip_accents
lowercase :int = pre_tok_class(**snake_case__ )
lowercase :int = do_lower_case
def __getstate__( self : List[str] ):
'''simple docstring'''
lowercase :Optional[Any] = self.__dict__.copy()
lowercase :List[Any] = BertPreTokenizer()
return state
def __setstate__( self : List[Any] , snake_case__ : str ):
'''simple docstring'''
lowercase :str = d
lowercase :Tuple = self.__dict__['''_tokenizer'''].get_vocab()
lowercase :Tuple = PreTokenizer.custom(JiebaPreTokenizer(snake_case__ ) )
def __snake_case ( self : List[str] , snake_case__ : str , snake_case__ : Tuple=None ):
'''simple docstring'''
lowercase :str = [self.cls_token_id] + token_ids_a + [self.sep_token_id]
if token_ids_a:
output += token_ids_a + [self.sep_token_id]
return output
def __snake_case ( self : Optional[int] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ):
'''simple docstring'''
lowercase :Optional[int] = [self.sep_token_id]
lowercase :Optional[Any] = [self.cls_token_id]
if token_ids_a is None:
return len(cls + token_ids_a + sep ) * [0]
return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]
def __snake_case ( self : Union[str, Any] , snake_case__ : str , snake_case__ : Optional[str] = None ):
'''simple docstring'''
lowercase :Union[str, Any] = self._tokenizer.model.save(snake_case__ , name=snake_case__ )
return tuple(snake_case__ )
def __snake_case ( self : List[str] , snake_case__ : Dict , snake_case__ : int=None , snake_case__ : Union[str, Any]=None , snake_case__ : Any=False , **snake_case__ : List[str] , ):
'''simple docstring'''
lowercase :Optional[int] = BertPreTokenizer()
return super().save_pretrained(snake_case__ , snake_case__ , snake_case__ , snake_case__ , **snake_case__ )
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tf_available,
is_tokenizers_available,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_blenderbot''': [
'''BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''BlenderbotConfig''',
'''BlenderbotOnnxConfig''',
],
'''tokenization_blenderbot''': ['''BlenderbotTokenizer'''],
}
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''BlenderbotTokenizerFast''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''BlenderbotForCausalLM''',
'''BlenderbotForConditionalGeneration''',
'''BlenderbotModel''',
'''BlenderbotPreTrainedModel''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TFBlenderbotForConditionalGeneration''',
'''TFBlenderbotModel''',
'''TFBlenderbotPreTrainedModel''',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxBlenderbotForConditionalGeneration''',
'''FlaxBlenderbotModel''',
'''FlaxBlenderbotPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_blenderbot import (
BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP,
BlenderbotConfig,
BlenderbotOnnxConfig,
)
from .tokenization_blenderbot import BlenderbotTokenizer
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_blenderbot_fast import BlenderbotTokenizerFast
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_blenderbot import (
BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST,
BlenderbotForCausalLM,
BlenderbotForConditionalGeneration,
BlenderbotModel,
BlenderbotPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_blenderbot import (
TFBlenderbotForConditionalGeneration,
TFBlenderbotModel,
TFBlenderbotPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_blenderbot import (
FlaxBlenderbotForConditionalGeneration,
FlaxBlenderbotModel,
FlaxBlenderbotPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
class __magic_name__ ( __UpperCAmelCase ):
__A : Optional[int] = "ClapFeatureExtractor"
__A : Optional[Any] = ("RobertaTokenizer", "RobertaTokenizerFast")
def __init__( self : Dict , snake_case__ : Any , snake_case__ : Tuple ):
'''simple docstring'''
super().__init__(snake_case__ , snake_case__ )
def __call__( self : Tuple , snake_case__ : Dict=None , snake_case__ : int=None , snake_case__ : Dict=None , **snake_case__ : Optional[Any] ):
'''simple docstring'''
lowercase :Dict = kwargs.pop('''sampling_rate''' , snake_case__ )
if text is None and audios is None:
raise ValueError('''You have to specify either text or audios. Both cannot be none.''' )
if text is not None:
lowercase :List[Any] = self.tokenizer(snake_case__ , return_tensors=snake_case__ , **snake_case__ )
if audios is not None:
lowercase :str = self.feature_extractor(
snake_case__ , sampling_rate=snake_case__ , return_tensors=snake_case__ , **snake_case__ )
if text is not None and audios is not None:
lowercase :int = audio_features.input_features
return encoding
elif text is not None:
return encoding
else:
return BatchEncoding(data=dict(**snake_case__ ) , tensor_type=snake_case__ )
def __snake_case ( self : Any , *snake_case__ : Dict , **snake_case__ : Any ):
'''simple docstring'''
return self.tokenizer.batch_decode(*snake_case__ , **snake_case__ )
def __snake_case ( self : Any , *snake_case__ : Tuple , **snake_case__ : Union[str, Any] ):
'''simple docstring'''
return self.tokenizer.decode(*snake_case__ , **snake_case__ )
@property
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :str = self.tokenizer.model_input_names
lowercase :int = self.feature_extractor.model_input_names
return list(dict.fromkeys(tokenizer_input_names + feature_extractor_input_names ) )
| 677 |
"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''naver-clova-ix/donut-base''': '''https://huggingface.co/naver-clova-ix/donut-base/resolve/main/config.json''',
# See all Donut models at https://huggingface.co/models?filter=donut-swin
}
class __magic_name__ ( __UpperCAmelCase ):
__A : Tuple = "donut-swin"
__A : Optional[Any] = {
"num_attention_heads": "num_heads",
"num_hidden_layers": "num_layers",
}
def __init__( self : List[str] , snake_case__ : Any=2_2_4 , snake_case__ : Tuple=4 , snake_case__ : str=3 , snake_case__ : Dict=9_6 , snake_case__ : Optional[Any]=[2, 2, 6, 2] , snake_case__ : Any=[3, 6, 1_2, 2_4] , snake_case__ : List[str]=7 , snake_case__ : Dict=4.0 , snake_case__ : str=True , snake_case__ : Optional[int]=0.0 , snake_case__ : Tuple=0.0 , snake_case__ : Any=0.1 , snake_case__ : List[str]="gelu" , snake_case__ : Tuple=False , snake_case__ : int=0.02 , snake_case__ : Optional[Any]=1e-5 , **snake_case__ : Any , ):
'''simple docstring'''
super().__init__(**snake_case__ )
lowercase :Union[str, Any] = image_size
lowercase :Optional[Any] = patch_size
lowercase :List[str] = num_channels
lowercase :Optional[int] = embed_dim
lowercase :Optional[Any] = depths
lowercase :List[Any] = len(snake_case__ )
lowercase :Optional[Any] = num_heads
lowercase :int = window_size
lowercase :str = mlp_ratio
lowercase :Optional[int] = qkv_bias
lowercase :Dict = hidden_dropout_prob
lowercase :Any = attention_probs_dropout_prob
lowercase :Any = drop_path_rate
lowercase :int = hidden_act
lowercase :int = use_absolute_embeddings
lowercase :List[str] = layer_norm_eps
lowercase :Union[str, Any] = initializer_range
# we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
# this indicates the channel dimension after the last stage of the model
lowercase :str = int(embed_dim * 2 ** (len(snake_case__ ) - 1) )
| 677 | 1 |
"""simple docstring"""
from __future__ import annotations
from typing import Any
class __magic_name__ :
def __init__( self : str , snake_case__ : int ):
'''simple docstring'''
lowercase :List[str] = num_of_nodes
lowercase :list[list[int]] = []
lowercase :dict[int, int] = {}
def __snake_case ( self : List[str] , snake_case__ : int , snake_case__ : int , snake_case__ : int ):
'''simple docstring'''
self.m_edges.append([u_node, v_node, weight] )
def __snake_case ( self : Optional[Any] , snake_case__ : int ):
'''simple docstring'''
if self.m_component[u_node] == u_node:
return u_node
return self.find_component(self.m_component[u_node] )
def __snake_case ( self : List[Any] , snake_case__ : int ):
'''simple docstring'''
if self.m_component[u_node] != u_node:
for k in self.m_component:
lowercase :str = self.find_component(snake_case__ )
def __snake_case ( self : Union[str, Any] , snake_case__ : list[int] , snake_case__ : int , snake_case__ : int ):
'''simple docstring'''
if component_size[u_node] <= component_size[v_node]:
lowercase :List[str] = v_node
component_size[v_node] += component_size[u_node]
self.set_component(snake_case__ )
elif component_size[u_node] >= component_size[v_node]:
lowercase :int = self.find_component(snake_case__ )
component_size[u_node] += component_size[v_node]
self.set_component(snake_case__ )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :Any = []
lowercase :List[str] = 0
lowercase :list[Any] = [-1] * self.m_num_of_nodes
# A list of components (initialized to all of the nodes)
for node in range(self.m_num_of_nodes ):
self.m_component.update({node: node} )
component_size.append(1 )
lowercase :List[Any] = self.m_num_of_nodes
while num_of_components > 1:
for edge in self.m_edges:
lowercase , lowercase , lowercase :Optional[Any] = edge
lowercase :Union[str, Any] = self.m_component[u]
lowercase :List[Any] = self.m_component[v]
if u_component != v_component:
for component in (u_component, v_component):
if (
minimum_weight_edge[component] == -1
or minimum_weight_edge[component][2] > w
):
lowercase :List[Any] = [u, v, w]
for edge in minimum_weight_edge:
if isinstance(snake_case__ , snake_case__ ):
lowercase , lowercase , lowercase :Union[str, Any] = edge
lowercase :Optional[int] = self.m_component[u]
lowercase :Any = self.m_component[v]
if u_component != v_component:
mst_weight += w
self.union(snake_case__ , snake_case__ , snake_case__ )
print(f"""Added edge [{u} - {v}]\nAdded weight: {w}\n""" )
num_of_components -= 1
lowercase :Union[str, Any] = [-1] * self.m_num_of_nodes
print(f"""The total weight of the minimal spanning tree is: {mst_weight}""" )
def lowerCamelCase () -> None:
pass
if __name__ == "__main__":
import doctest
doctest.testmod()
| 677 |
"""simple docstring"""
import argparse
import os
import shutil
from pathlib import Path
import onnx
import torch
from packaging import version
from torch.onnx import export
from diffusers import OnnxRuntimeModel, OnnxStableDiffusionPipeline, StableDiffusionPipeline
UpperCAmelCase = version.parse(version.parse(torch.__version__).base_version) < version.parse('''1.11''')
def lowerCamelCase (a_ :Optional[int] , a_ :tuple , a_ :Path , a_ :str , a_ :int , a_ :List[Any] , a_ :Any , a_ :Union[str, Any]=False , ) -> Dict:
output_path.parent.mkdir(parents=a_ , exist_ok=a_)
# PyTorch deprecated the `enable_onnx_checker` and `use_external_data_format` arguments in v1.11,
# so we check the torch version for backwards compatibility
if is_torch_less_than_1_11:
export(
a_ , a_ , f=output_path.as_posix() , input_names=a_ , output_names=a_ , dynamic_axes=a_ , do_constant_folding=a_ , use_external_data_format=a_ , enable_onnx_checker=a_ , opset_version=a_ , )
else:
export(
a_ , a_ , f=output_path.as_posix() , input_names=a_ , output_names=a_ , dynamic_axes=a_ , do_constant_folding=a_ , opset_version=a_ , )
@torch.no_grad()
def lowerCamelCase (a_ :str , a_ :str , a_ :int , a_ :bool = False) -> Union[str, Any]:
lowercase :Any = torch.floataa if fpaa else torch.floataa
if fpaa and torch.cuda.is_available():
lowercase :Union[str, Any] = '''cuda'''
elif fpaa and not torch.cuda.is_available():
raise ValueError('''`float16` model export is only supported on GPUs with CUDA''')
else:
lowercase :List[str] = '''cpu'''
lowercase :List[str] = StableDiffusionPipeline.from_pretrained(a_ , torch_dtype=a_).to(a_)
lowercase :List[Any] = Path(a_)
# TEXT ENCODER
lowercase :List[Any] = pipeline.text_encoder.config.max_position_embeddings
lowercase :Dict = pipeline.text_encoder.config.hidden_size
lowercase :Union[str, Any] = pipeline.tokenizer(
'''A sample prompt''' , padding='''max_length''' , max_length=pipeline.tokenizer.model_max_length , truncation=a_ , return_tensors='''pt''' , )
onnx_export(
pipeline.text_encoder , model_args=(text_input.input_ids.to(device=a_ , dtype=torch.intaa)) , output_path=output_path / '''text_encoder''' / '''model.onnx''' , ordered_input_names=['''input_ids'''] , output_names=['''last_hidden_state''', '''pooler_output'''] , dynamic_axes={
'''input_ids''': {0: '''batch''', 1: '''sequence'''},
} , opset=a_ , )
del pipeline.text_encoder
# UNET
lowercase :Any = pipeline.unet.config.in_channels
lowercase :List[Any] = pipeline.unet.config.sample_size
lowercase :Optional[int] = output_path / '''unet''' / '''model.onnx'''
onnx_export(
pipeline.unet , model_args=(
torch.randn(2 , a_ , a_ , a_).to(device=a_ , dtype=a_),
torch.randn(2).to(device=a_ , dtype=a_),
torch.randn(2 , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=a_ , ordered_input_names=['''sample''', '''timestep''', '''encoder_hidden_states''', '''return_dict'''] , output_names=['''out_sample'''] , dynamic_axes={
'''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
'''timestep''': {0: '''batch'''},
'''encoder_hidden_states''': {0: '''batch''', 1: '''sequence'''},
} , opset=a_ , use_external_data_format=a_ , )
lowercase :List[Any] = str(unet_path.absolute().as_posix())
lowercase :str = os.path.dirname(a_)
lowercase :Optional[Any] = onnx.load(a_)
# clean up existing tensor files
shutil.rmtree(a_)
os.mkdir(a_)
# collate external tensor files into one
onnx.save_model(
a_ , a_ , save_as_external_data=a_ , all_tensors_to_one_file=a_ , location='''weights.pb''' , convert_attribute=a_ , )
del pipeline.unet
# VAE ENCODER
lowercase :Tuple = pipeline.vae
lowercase :Optional[Any] = vae_encoder.config.in_channels
lowercase :Any = vae_encoder.config.sample_size
# need to get the raw tensor output (sample) from the encoder
lowercase :Any = lambda a_ , a_: vae_encoder.encode(a_ , a_)[0].sample()
onnx_export(
a_ , model_args=(
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=output_path / '''vae_encoder''' / '''model.onnx''' , ordered_input_names=['''sample''', '''return_dict'''] , output_names=['''latent_sample'''] , dynamic_axes={
'''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
} , opset=a_ , )
# VAE DECODER
lowercase :Any = pipeline.vae
lowercase :Dict = vae_decoder.config.latent_channels
lowercase :Union[str, Any] = vae_decoder.config.out_channels
# forward only through the decoder part
lowercase :List[Any] = vae_encoder.decode
onnx_export(
a_ , model_args=(
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=output_path / '''vae_decoder''' / '''model.onnx''' , ordered_input_names=['''latent_sample''', '''return_dict'''] , output_names=['''sample'''] , dynamic_axes={
'''latent_sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
} , opset=a_ , )
del pipeline.vae
# SAFETY CHECKER
if pipeline.safety_checker is not None:
lowercase :Dict = pipeline.safety_checker
lowercase :str = safety_checker.config.vision_config.num_channels
lowercase :str = safety_checker.config.vision_config.image_size
lowercase :List[str] = safety_checker.forward_onnx
onnx_export(
pipeline.safety_checker , model_args=(
torch.randn(
1 , a_ , a_ , a_ , ).to(device=a_ , dtype=a_),
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
) , output_path=output_path / '''safety_checker''' / '''model.onnx''' , ordered_input_names=['''clip_input''', '''images'''] , output_names=['''out_images''', '''has_nsfw_concepts'''] , dynamic_axes={
'''clip_input''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
'''images''': {0: '''batch''', 1: '''height''', 2: '''width''', 3: '''channels'''},
} , opset=a_ , )
del pipeline.safety_checker
lowercase :Tuple = OnnxRuntimeModel.from_pretrained(output_path / '''safety_checker''')
lowercase :Optional[Any] = pipeline.feature_extractor
else:
lowercase :int = None
lowercase :Union[str, Any] = None
lowercase :Optional[int] = OnnxStableDiffusionPipeline(
vae_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_encoder''') , vae_decoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_decoder''') , text_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''text_encoder''') , tokenizer=pipeline.tokenizer , unet=OnnxRuntimeModel.from_pretrained(output_path / '''unet''') , scheduler=pipeline.scheduler , safety_checker=a_ , feature_extractor=a_ , requires_safety_checker=safety_checker is not None , )
onnx_pipeline.save_pretrained(a_)
print('''ONNX pipeline saved to''' , a_)
del pipeline
del onnx_pipeline
lowercase :Tuple = OnnxStableDiffusionPipeline.from_pretrained(a_ , provider='''CPUExecutionProvider''')
print('''ONNX pipeline is loadable''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
parser.add_argument(
'''--model_path''',
type=str,
required=True,
help='''Path to the `diffusers` checkpoint to convert (either a local directory or on the Hub).''',
)
parser.add_argument('''--output_path''', type=str, required=True, help='''Path to the output model.''')
parser.add_argument(
'''--opset''',
default=14,
type=int,
help='''The version of the ONNX operator set to use.''',
)
parser.add_argument('''--fp16''', action='''store_true''', default=False, help='''Export the models in `float16` mode''')
UpperCAmelCase = parser.parse_args()
convert_models(args.model_path, args.output_path, args.opset, args.fpaa)
| 677 | 1 |
"""simple docstring"""
# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING
import numpy as np
import pyarrow as pa
from .. import config
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter
if TYPE_CHECKING:
import torch
class __magic_name__ ( TensorFormatter[Mapping, "torch.Tensor", Mapping] ):
def __init__( self : Dict , snake_case__ : str=None , **snake_case__ : List[Any] ):
'''simple docstring'''
super().__init__(features=snake_case__ )
lowercase :Optional[Any] = torch_tensor_kwargs
import torch # noqa import torch at initialization
def __snake_case ( self : Optional[Any] , snake_case__ : Tuple ):
'''simple docstring'''
import torch
if isinstance(snake_case__ , snake_case__ ) and column:
if all(
isinstance(snake_case__ , torch.Tensor ) and x.shape == column[0].shape and x.dtype == column[0].dtype
for x in column ):
return torch.stack(snake_case__ )
return column
def __snake_case ( self : Union[str, Any] , snake_case__ : Union[str, Any] ):
'''simple docstring'''
import torch
if isinstance(snake_case__ , (str, bytes, type(snake_case__ )) ):
return value
elif isinstance(snake_case__ , (np.character, np.ndarray) ) and np.issubdtype(value.dtype , np.character ):
return value.tolist()
lowercase :List[str] = {}
if isinstance(snake_case__ , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.integer ):
lowercase :Optional[Any] = {'''dtype''': torch.intaa}
elif isinstance(snake_case__ , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.floating ):
lowercase :Optional[int] = {'''dtype''': torch.floataa}
elif config.PIL_AVAILABLE and "PIL" in sys.modules:
import PIL.Image
if isinstance(snake_case__ , PIL.Image.Image ):
lowercase :List[str] = np.asarray(snake_case__ )
return torch.tensor(snake_case__ , **{**default_dtype, **self.torch_tensor_kwargs} )
def __snake_case ( self : Tuple , snake_case__ : List[str] ):
'''simple docstring'''
import torch
# support for torch, tf, jax etc.
if hasattr(snake_case__ , '''__array__''' ) and not isinstance(snake_case__ , torch.Tensor ):
lowercase :Optional[int] = data_struct.__array__()
# support for nested types like struct of list of struct
if isinstance(snake_case__ , np.ndarray ):
if data_struct.dtype == object: # torch tensors cannot be instantied from an array of objects
return self._consolidate([self.recursive_tensorize(snake_case__ ) for substruct in data_struct] )
elif isinstance(snake_case__ , (list, tuple) ):
return self._consolidate([self.recursive_tensorize(snake_case__ ) for substruct in data_struct] )
return self._tensorize(snake_case__ )
def __snake_case ( self : Dict , snake_case__ : dict ):
'''simple docstring'''
return map_nested(self._recursive_tensorize , snake_case__ , map_list=snake_case__ )
def __snake_case ( self : Any , snake_case__ : pa.Table ):
'''simple docstring'''
lowercase :List[str] = self.numpy_arrow_extractor().extract_row(snake_case__ )
lowercase :Tuple = self.python_features_decoder.decode_row(snake_case__ )
return self.recursive_tensorize(snake_case__ )
def __snake_case ( self : List[Any] , snake_case__ : pa.Table ):
'''simple docstring'''
lowercase :str = self.numpy_arrow_extractor().extract_column(snake_case__ )
lowercase :int = self.python_features_decoder.decode_column(snake_case__ , pa_table.column_names[0] )
lowercase :Optional[Any] = self.recursive_tensorize(snake_case__ )
lowercase :Any = self._consolidate(snake_case__ )
return column
def __snake_case ( self : str , snake_case__ : pa.Table ):
'''simple docstring'''
lowercase :Optional[Any] = self.numpy_arrow_extractor().extract_batch(snake_case__ )
lowercase :str = self.python_features_decoder.decode_batch(snake_case__ )
lowercase :Optional[int] = self.recursive_tensorize(snake_case__ )
for column_name in batch:
lowercase :Any = self._consolidate(batch[column_name] )
return batch
| 677 |
"""simple docstring"""
import itertools
import json
import linecache
import os
import pickle
import re
import socket
import string
from collections import Counter
from logging import getLogger
from pathlib import Path
from typing import Callable, Dict, Iterable, List
import git
import torch
from torch.utils.data import Dataset
from transformers import BartTokenizer, RagTokenizer, TaTokenizer
def lowerCamelCase (a_ :List[Any] , a_ :Union[str, Any] , a_ :Tuple , a_ :List[str] , a_ :str=True , a_ :str="pt") -> List[str]:
lowercase :Optional[int] = {'''add_prefix_space''': True} if isinstance(a_ , a_) and not line.startswith(''' ''') else {}
lowercase :Optional[int] = padding_side
return tokenizer(
[line] , max_length=a_ , padding='''max_length''' if pad_to_max_length else None , truncation=a_ , return_tensors=a_ , add_special_tokens=a_ , **a_ , )
def lowerCamelCase (a_ :str , a_ :Tuple , a_ :Optional[Any]=None , ) -> Tuple:
lowercase :Optional[Any] = input_ids.ne(a_).any(dim=0)
if attention_mask is None:
return input_ids[:, keep_column_mask]
else:
return (input_ids[:, keep_column_mask], attention_mask[:, keep_column_mask])
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Union[str, Any] , snake_case__ : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : str="train" , snake_case__ : Optional[Any]=None , snake_case__ : Tuple=None , snake_case__ : Any=None , snake_case__ : Dict="" , ):
'''simple docstring'''
super().__init__()
lowercase :Tuple = Path(snake_case__ ).joinpath(type_path + '''.source''' )
lowercase :Union[str, Any] = Path(snake_case__ ).joinpath(type_path + '''.target''' )
lowercase :List[Any] = self.get_char_lens(self.src_file )
lowercase :Tuple = max_source_length
lowercase :Optional[int] = max_target_length
assert min(self.src_lens ) > 0, f"""found empty line in {self.src_file}"""
lowercase :Any = tokenizer
lowercase :Tuple = prefix
if n_obs is not None:
lowercase :List[str] = self.src_lens[:n_obs]
lowercase :List[Any] = src_lang
lowercase :str = tgt_lang
def __len__( self : Any ):
'''simple docstring'''
return len(self.src_lens )
def __getitem__( self : str , snake_case__ : Any ):
'''simple docstring'''
lowercase :Optional[int] = index + 1 # linecache starts at 1
lowercase :Optional[Any] = self.prefix + linecache.getline(str(self.src_file ) , snake_case__ ).rstrip('''\n''' )
lowercase :Dict = linecache.getline(str(self.tgt_file ) , snake_case__ ).rstrip('''\n''' )
assert source_line, f"""empty source line for index {index}"""
assert tgt_line, f"""empty tgt line for index {index}"""
# Need to add eos token manually for T5
if isinstance(self.tokenizer , snake_case__ ):
source_line += self.tokenizer.eos_token
tgt_line += self.tokenizer.eos_token
# Pad source and target to the right
lowercase :Dict = (
self.tokenizer.question_encoder if isinstance(self.tokenizer , snake_case__ ) else self.tokenizer
)
lowercase :Optional[int] = self.tokenizer.generator if isinstance(self.tokenizer , snake_case__ ) else self.tokenizer
lowercase :Optional[int] = encode_line(snake_case__ , snake_case__ , self.max_source_length , '''right''' )
lowercase :Tuple = encode_line(snake_case__ , snake_case__ , self.max_target_length , '''right''' )
lowercase :List[str] = source_inputs['''input_ids'''].squeeze()
lowercase :Optional[Any] = target_inputs['''input_ids'''].squeeze()
lowercase :List[str] = source_inputs['''attention_mask'''].squeeze()
return {
"input_ids": source_ids,
"attention_mask": src_mask,
"decoder_input_ids": target_ids,
}
@staticmethod
def __snake_case ( snake_case__ : Optional[int] ):
'''simple docstring'''
return [len(snake_case__ ) for x in Path(snake_case__ ).open().readlines()]
def __snake_case ( self : Tuple , snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase :Optional[Any] = torch.stack([x['''input_ids'''] for x in batch] )
lowercase :Tuple = torch.stack([x['''attention_mask'''] for x in batch] )
lowercase :Tuple = torch.stack([x['''decoder_input_ids'''] for x in batch] )
lowercase :str = (
self.tokenizer.generator.pad_token_id
if isinstance(self.tokenizer , snake_case__ )
else self.tokenizer.pad_token_id
)
lowercase :Optional[int] = (
self.tokenizer.question_encoder.pad_token_id
if isinstance(self.tokenizer , snake_case__ )
else self.tokenizer.pad_token_id
)
lowercase :List[Any] = trim_batch(snake_case__ , snake_case__ )
lowercase , lowercase :List[str] = trim_batch(snake_case__ , snake_case__ , attention_mask=snake_case__ )
lowercase :Optional[int] = {
'''input_ids''': source_ids,
'''attention_mask''': source_mask,
'''decoder_input_ids''': y,
}
return batch
UpperCAmelCase = getLogger(__name__)
def lowerCamelCase (a_ :List[List]) -> Tuple:
return list(itertools.chain.from_iterable(a_))
def lowerCamelCase (a_ :str) -> None:
lowercase :List[str] = get_git_info()
save_json(a_ , os.path.join(a_ , '''git_log.json'''))
def lowerCamelCase (a_ :Optional[int] , a_ :Optional[int] , a_ :Optional[Any]=4 , **a_ :Optional[Any]) -> str:
with open(a_ , '''w''') as f:
json.dump(a_ , a_ , indent=a_ , **a_)
def lowerCamelCase (a_ :Dict) -> Union[str, Any]:
with open(a_) as f:
return json.load(a_)
def lowerCamelCase () -> List[str]:
lowercase :Dict = git.Repo(search_parent_directories=a_)
lowercase :int = {
'''repo_id''': str(a_),
'''repo_sha''': str(repo.head.object.hexsha),
'''repo_branch''': str(repo.active_branch),
'''hostname''': str(socket.gethostname()),
}
return repo_infos
def lowerCamelCase (a_ :Callable , a_ :Iterable) -> List:
return list(map(a_ , a_))
def lowerCamelCase (a_ :Optional[Any] , a_ :str) -> Any:
with open(a_ , '''wb''') as f:
return pickle.dump(a_ , a_)
def lowerCamelCase (a_ :List[str]) -> List[str]:
def remove_articles(a_ :Union[str, Any]):
return re.sub(R'''\b(a|an|the)\b''' , ''' ''' , a_)
def white_space_fix(a_ :Tuple):
return " ".join(text.split())
def remove_punc(a_ :int):
lowercase :List[Any] = set(string.punctuation)
return "".join(ch for ch in text if ch not in exclude)
def lower(a_ :int):
return text.lower()
return white_space_fix(remove_articles(remove_punc(lower(a_))))
def lowerCamelCase (a_ :List[str] , a_ :Any) -> List[str]:
lowercase :Dict = normalize_answer(a_).split()
lowercase :int = normalize_answer(a_).split()
lowercase :List[Any] = Counter(a_) & Counter(a_)
lowercase :Optional[int] = sum(common.values())
if num_same == 0:
return 0
lowercase :str = 1.0 * num_same / len(a_)
lowercase :Tuple = 1.0 * num_same / len(a_)
lowercase :Tuple = (2 * precision * recall) / (precision + recall)
return fa
def lowerCamelCase (a_ :Tuple , a_ :Optional[Any]) -> List[Any]:
return normalize_answer(a_) == normalize_answer(a_)
def lowerCamelCase (a_ :List[str] , a_ :List[str]) -> Dict:
assert len(a_) == len(a_)
lowercase :Any = 0
for hypo, pred in zip(a_ , a_):
em += exact_match_score(a_ , a_)
if len(a_) > 0:
em /= len(a_)
return {"em": em}
def lowerCamelCase (a_ :Union[str, Any]) -> Optional[Any]:
return model_prefix.startswith('''rag''')
def lowerCamelCase (a_ :List[str] , a_ :Tuple , a_ :List[str]) -> Any:
lowercase :List[str] = {p: p for p in extra_params}
# T5 models don't have `dropout` param, they have `dropout_rate` instead
lowercase :str = '''dropout_rate'''
for p in extra_params:
if getattr(a_ , a_ , a_):
if not hasattr(a_ , a_) and not hasattr(a_ , equivalent_param[p]):
logger.info('''config doesn\'t have a `{}` attribute'''.format(a_))
delattr(a_ , a_)
continue
lowercase :List[str] = p if hasattr(a_ , a_) else equivalent_param[p]
setattr(a_ , a_ , getattr(a_ , a_))
delattr(a_ , a_)
return hparams, config
| 677 | 1 |
"""simple docstring"""
import warnings
from ...utils import logging
from .image_processing_mobilevit import MobileViTImageProcessor
UpperCAmelCase = logging.get_logger(__name__)
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Any , *snake_case__ : str , **snake_case__ : int ):
'''simple docstring'''
warnings.warn(
'''The class MobileViTFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'''
''' Please use MobileViTImageProcessor instead.''' , snake_case__ , )
super().__init__(*snake_case__ , **snake_case__ )
| 677 |
"""simple docstring"""
def lowerCamelCase (a_ :Tuple , a_ :int , a_ :Tuple , a_ :List[Any]) -> str:
if height >= 1:
move_tower(height - 1 , a_ , a_ , a_)
move_disk(a_ , a_)
move_tower(height - 1 , a_ , a_ , a_)
def lowerCamelCase (a_ :int , a_ :Union[str, Any]) -> str:
print('''moving disk from''' , a_ , '''to''' , a_)
def lowerCamelCase () -> Tuple:
lowercase :int = int(input('''Height of hanoi: ''').strip())
move_tower(a_ , '''A''' , '''B''' , '''C''')
if __name__ == "__main__":
main()
| 677 | 1 |
"""simple docstring"""
def lowerCamelCase (a_ :list[int] , a_ :list[int]) -> None:
lowercase :Optional[int] = len(a_)
print('''The following activities are selected:''')
# The first activity is always selected
lowercase :Dict = 0
print(a_ , end=''',''')
# Consider rest of the activities
for j in range(a_):
# If this activity has start time greater than
# or equal to the finish time of previously
# selected activity, then select it
if start[j] >= finish[i]:
print(a_ , end=''',''')
lowercase :str = j
if __name__ == "__main__":
import doctest
doctest.testmod()
UpperCAmelCase = [1, 3, 0, 5, 8, 5]
UpperCAmelCase = [2, 4, 6, 7, 9, 9]
print_max_activities(start, finish)
| 677 |
"""simple docstring"""
from sklearn.metrics import mean_squared_error
import datasets
UpperCAmelCase = '''\
@article{scikit-learn,
title={Scikit-learn: Machine Learning in {P}ython},
author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
journal={Journal of Machine Learning Research},
volume={12},
pages={2825--2830},
year={2011}
}
'''
UpperCAmelCase = '''\
Mean Squared Error(MSE) is the average of the square of difference between the predicted
and actual values.
'''
UpperCAmelCase = '''
Args:
predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)
Estimated target values.
references: array-like of shape (n_samples,) or (n_samples, n_outputs)
Ground truth (correct) target values.
sample_weight: array-like of shape (n_samples,), default=None
Sample weights.
multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"
Defines aggregating of multiple output values. Array-like value defines weights used to average errors.
"raw_values" : Returns a full set of errors in case of multioutput input.
"uniform_average" : Errors of all outputs are averaged with uniform weight.
squared : bool, default=True
If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.
Returns:
mse : mean squared error.
Examples:
>>> mse_metric = datasets.load_metric("mse")
>>> predictions = [2.5, 0.0, 2, 8]
>>> references = [3, -0.5, 2, 7]
>>> results = mse_metric.compute(predictions=predictions, references=references)
>>> print(results)
{\'mse\': 0.375}
>>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)
>>> print(rmse_result)
{\'mse\': 0.6123724356957945}
If you\'re using multi-dimensional lists, then set the config as follows :
>>> mse_metric = datasets.load_metric("mse", "multilist")
>>> predictions = [[0.5, 1], [-1, 1], [7, -6]]
>>> references = [[0, 2], [-1, 2], [8, -5]]
>>> results = mse_metric.compute(predictions=predictions, references=references)
>>> print(results)
{\'mse\': 0.7083333333333334}
>>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')
>>> print(results) # doctest: +NORMALIZE_WHITESPACE
{\'mse\': array([0.41666667, 1. ])}
'''
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class __magic_name__ ( datasets.Metric ):
def __snake_case ( self : int ):
'''simple docstring'''
return datasets.MetricInfo(
description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(self._get_feature_types() ) , reference_urls=[
'''https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html'''
] , )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
if self.config_name == "multilist":
return {
"predictions": datasets.Sequence(datasets.Value('''float''' ) ),
"references": datasets.Sequence(datasets.Value('''float''' ) ),
}
else:
return {
"predictions": datasets.Value('''float''' ),
"references": datasets.Value('''float''' ),
}
def __snake_case ( self : List[Any] , snake_case__ : str , snake_case__ : int , snake_case__ : str=None , snake_case__ : List[Any]="uniform_average" , snake_case__ : Dict=True ):
'''simple docstring'''
lowercase :Dict = mean_squared_error(
snake_case__ , snake_case__ , sample_weight=snake_case__ , multioutput=snake_case__ , squared=snake_case__ )
return {"mse": mse}
| 677 | 1 |
"""simple docstring"""
from graphs.minimum_spanning_tree_kruskal import kruskal
def lowerCamelCase () -> Dict:
lowercase :List[Any] = 9
lowercase :Optional[Any] = [
[0, 1, 4],
[0, 7, 8],
[1, 2, 8],
[7, 8, 7],
[7, 6, 1],
[2, 8, 2],
[8, 6, 6],
[2, 3, 7],
[2, 5, 4],
[6, 5, 2],
[3, 5, 14],
[3, 4, 9],
[5, 4, 10],
[1, 7, 11],
]
lowercase :Union[str, Any] = kruskal(a_ , a_)
lowercase :Tuple = [
[7, 6, 1],
[2, 8, 2],
[6, 5, 2],
[0, 1, 4],
[2, 5, 4],
[2, 3, 7],
[0, 7, 8],
[3, 4, 9],
]
assert sorted(a_) == sorted(a_)
| 677 |
"""simple docstring"""
from abc import ABC, abstractmethod
from argparse import ArgumentParser
class __magic_name__ ( __UpperCAmelCase ):
@staticmethod
@abstractmethod
def __snake_case ( snake_case__ : ArgumentParser ):
'''simple docstring'''
raise NotImplementedError()
@abstractmethod
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
raise NotImplementedError()
| 677 | 1 |
"""simple docstring"""
def lowerCamelCase (a_ :int) -> bool:
if not isinstance(a_ , a_):
raise ValueError('''check_bouncy() accepts only integer arguments''')
lowercase :Union[str, Any] = str(a_)
lowercase :Any = ''''''.join(sorted(a_))
return sorted_str_n != str_n and sorted_str_n[::-1] != str_n
def lowerCamelCase (a_ :float = 99) -> int:
if not 0 < percent < 100:
raise ValueError('''solution() only accepts values from 0 to 100''')
lowercase :str = 0
lowercase :Any = 1
while True:
if check_bouncy(a_):
bouncy_num += 1
if (bouncy_num / num) * 100 >= percent:
return num
num += 1
if __name__ == "__main__":
from doctest import testmod
testmod()
print(F"""{solution(99)}""")
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_encodec''': [
'''ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''EncodecConfig''',
],
'''feature_extraction_encodec''': ['''EncodecFeatureExtractor'''],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''EncodecModel''',
'''EncodecPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_encodec import (
ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP,
EncodecConfig,
)
from .feature_extraction_encodec import EncodecFeatureExtractor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_encodec import (
ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST,
EncodecModel,
EncodecPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
from typing import List, Optional, Tuple
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_herbert import HerbertTokenizer
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt''', '''tokenizer_file''': '''tokenizer.json'''}
UpperCAmelCase = {
'''vocab_file''': {
'''allegro/herbert-base-cased''': '''https://huggingface.co/allegro/herbert-base-cased/resolve/main/vocab.json'''
},
'''merges_file''': {
'''allegro/herbert-base-cased''': '''https://huggingface.co/allegro/herbert-base-cased/resolve/main/merges.txt'''
},
}
UpperCAmelCase = {'''allegro/herbert-base-cased''': 514}
UpperCAmelCase = {}
class __magic_name__ ( __UpperCAmelCase ):
__A : str = VOCAB_FILES_NAMES
__A : Tuple = PRETRAINED_VOCAB_FILES_MAP
__A : Dict = PRETRAINED_INIT_CONFIGURATION
__A : int = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
__A : List[str] = HerbertTokenizer
def __init__( self : Any , snake_case__ : Tuple=None , snake_case__ : List[str]=None , snake_case__ : List[Any]=None , snake_case__ : Any="<s>" , snake_case__ : Union[str, Any]="<unk>" , snake_case__ : Dict="<pad>" , snake_case__ : Union[str, Any]="<mask>" , snake_case__ : int="</s>" , **snake_case__ : Any , ):
'''simple docstring'''
super().__init__(
snake_case__ , snake_case__ , tokenizer_file=snake_case__ , cls_token=snake_case__ , unk_token=snake_case__ , pad_token=snake_case__ , mask_token=snake_case__ , sep_token=snake_case__ , **snake_case__ , )
def __snake_case ( self : Union[str, Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ):
'''simple docstring'''
lowercase :Dict = [self.cls_token_id]
lowercase :Union[str, Any] = [self.sep_token_id]
if token_ids_a is None:
return cls + token_ids_a + sep
return cls + token_ids_a + sep + token_ids_a + sep
def __snake_case ( self : Dict , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None , snake_case__ : bool = False ):
'''simple docstring'''
if already_has_special_tokens:
return super().get_special_tokens_mask(
token_ids_a=snake_case__ , token_ids_a=snake_case__ , already_has_special_tokens=snake_case__ )
if token_ids_a is None:
return [1] + ([0] * len(snake_case__ )) + [1]
return [1] + ([0] * len(snake_case__ )) + [1] + ([0] * len(snake_case__ )) + [1]
def __snake_case ( self : List[Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ):
'''simple docstring'''
lowercase :List[str] = [self.sep_token_id]
lowercase :List[str] = [self.cls_token_id]
if token_ids_a is None:
return len(cls + token_ids_a + sep ) * [0]
return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]
def __snake_case ( self : Dict , snake_case__ : str , snake_case__ : Optional[str] = None ):
'''simple docstring'''
lowercase :List[str] = self._tokenizer.model.save(snake_case__ , name=snake_case__ )
return tuple(snake_case__ )
| 677 |
"""simple docstring"""
import inspect
import unittest
from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available
from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor
if is_flax_available():
import jax
import jax.numpy as jnp
from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel
if is_vision_available():
from PIL import Image
from transformers import AutoImageProcessor
class __magic_name__ ( unittest.TestCase ):
def __init__( self : List[Any] , snake_case__ : Optional[int] , snake_case__ : List[str]=3 , snake_case__ : int=3_2 , snake_case__ : int=3 , snake_case__ : str=1_0 , snake_case__ : str=[1_0, 2_0, 3_0, 4_0] , snake_case__ : int=[1, 1, 2, 1] , snake_case__ : List[Any]=True , snake_case__ : Tuple=True , snake_case__ : Optional[Any]="relu" , snake_case__ : Optional[int]=3 , snake_case__ : Optional[Any]=None , ):
'''simple docstring'''
lowercase :Union[str, Any] = parent
lowercase :Optional[Any] = batch_size
lowercase :Dict = image_size
lowercase :Any = num_channels
lowercase :List[str] = embeddings_size
lowercase :Union[str, Any] = hidden_sizes
lowercase :Any = depths
lowercase :Dict = is_training
lowercase :Any = use_labels
lowercase :Any = hidden_act
lowercase :List[str] = num_labels
lowercase :List[Any] = scope
lowercase :int = len(snake_case__ )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :Optional[int] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
lowercase :Union[str, Any] = self.get_config()
return config, pixel_values
def __snake_case ( self : Dict ):
'''simple docstring'''
return RegNetConfig(
num_channels=self.num_channels , embeddings_size=self.embeddings_size , hidden_sizes=self.hidden_sizes , depths=self.depths , hidden_act=self.hidden_act , num_labels=self.num_labels , image_size=self.image_size , )
def __snake_case ( self : str , snake_case__ : Tuple , snake_case__ : List[Any] ):
'''simple docstring'''
lowercase :Any = FlaxRegNetModel(config=snake_case__ )
lowercase :str = model(snake_case__ )
# Output shape (b, c, h, w)
self.parent.assertEqual(
result.last_hidden_state.shape , (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2) , )
def __snake_case ( self : List[str] , snake_case__ : Optional[int] , snake_case__ : str ):
'''simple docstring'''
lowercase :Tuple = self.num_labels
lowercase :str = FlaxRegNetForImageClassification(config=snake_case__ )
lowercase :Union[str, Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :int = self.prepare_config_and_inputs()
lowercase , lowercase :Tuple = config_and_inputs
lowercase :Union[str, Any] = {'''pixel_values''': pixel_values}
return config, inputs_dict
@require_flax
class __magic_name__ ( __UpperCAmelCase , unittest.TestCase ):
__A : List[Any] = (FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()
__A : str = False
__A : Tuple = False
__A : Dict = False
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :Dict = FlaxRegNetModelTester(self )
lowercase :Tuple = ConfigTester(self , config_class=snake_case__ , has_text_modality=snake_case__ )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
self.create_and_test_config_common_properties()
self.config_tester.create_and_test_config_to_json_string()
self.config_tester.create_and_test_config_to_json_file()
self.config_tester.create_and_test_config_from_and_save_pretrained()
self.config_tester.create_and_test_config_with_num_labels()
self.config_tester.check_config_can_be_init_without_params()
self.config_tester.check_config_arguments_init()
def __snake_case ( self : List[Any] ):
'''simple docstring'''
return
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :Dict = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_image_classification(*snake_case__ )
@unittest.skip(reason='''RegNet does not use inputs_embeds''' )
def __snake_case ( self : Tuple ):
'''simple docstring'''
pass
@unittest.skip(reason='''RegNet does not support input and output embeddings''' )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
pass
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :Union[str, Any] = model_class(snake_case__ )
lowercase :int = inspect.signature(model.__call__ )
# signature.parameters is an OrderedDict => so arg_names order is deterministic
lowercase :Tuple = [*signature.parameters.keys()]
lowercase :Tuple = ['''pixel_values''']
self.assertListEqual(arg_names[:1] , snake_case__ )
def __snake_case ( self : Tuple ):
'''simple docstring'''
def check_hidden_states_output(snake_case__ : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[int] ):
lowercase :int = model_class(snake_case__ )
lowercase :Tuple = model(**self._prepare_for_class(snake_case__ , snake_case__ ) )
lowercase :Any = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
lowercase :Dict = self.model_tester.num_stages
self.assertEqual(len(snake_case__ ) , expected_num_stages + 1 )
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :Optional[int] = True
check_hidden_states_output(snake_case__ , snake_case__ , snake_case__ )
# check that output_hidden_states also work using config
del inputs_dict["output_hidden_states"]
lowercase :str = True
check_hidden_states_output(snake_case__ , snake_case__ , snake_case__ )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase , lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
with self.subTest(model_class.__name__ ):
lowercase :Optional[Any] = self._prepare_for_class(snake_case__ , snake_case__ )
lowercase :List[Any] = model_class(snake_case__ )
@jax.jit
def model_jitted(snake_case__ : str , **snake_case__ : Optional[int] ):
return model(pixel_values=snake_case__ , **snake_case__ )
with self.subTest('''JIT Enabled''' ):
lowercase :Optional[int] = model_jitted(**snake_case__ ).to_tuple()
with self.subTest('''JIT Disabled''' ):
with jax.disable_jit():
lowercase :Optional[int] = model_jitted(**snake_case__ ).to_tuple()
self.assertEqual(len(snake_case__ ) , len(snake_case__ ) )
for jitted_output, output in zip(snake_case__ , snake_case__ ):
self.assertEqual(jitted_output.shape , output.shape )
def lowerCamelCase () -> Tuple:
lowercase :Tuple = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
return image
@require_flax
class __magic_name__ ( unittest.TestCase ):
@cached_property
def __snake_case ( self : int ):
'''simple docstring'''
return AutoImageProcessor.from_pretrained('''facebook/regnet-y-040''' ) if is_vision_available() else None
@slow
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :int = FlaxRegNetForImageClassification.from_pretrained('''facebook/regnet-y-040''' )
lowercase :Optional[Any] = self.default_image_processor
lowercase :Dict = prepare_img()
lowercase :Any = image_processor(images=snake_case__ , return_tensors='''np''' )
lowercase :List[str] = model(**snake_case__ )
# verify the logits
lowercase :Any = (1, 1_0_0_0)
self.assertEqual(outputs.logits.shape , snake_case__ )
lowercase :List[Any] = jnp.array([-0.41_80, -1.50_51, -3.48_36] )
self.assertTrue(jnp.allclose(outputs.logits[0, :3] , snake_case__ , atol=1e-4 ) )
| 677 | 1 |
"""simple docstring"""
class __magic_name__ :
def __init__( self : Optional[int] , snake_case__ : Any ):
'''simple docstring'''
lowercase :int = arr.split(''',''' )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :str = [int(self.array[0] )] * len(self.array )
lowercase :List[str] = [int(self.array[0] )] * len(self.array )
for i in range(1 , len(self.array ) ):
lowercase :int = max(
int(self.array[i] ) + sum_value[i - 1] , int(self.array[i] ) )
lowercase :int = max(sum_value[i] , rear[i - 1] )
return rear[len(self.array ) - 1]
if __name__ == "__main__":
UpperCAmelCase = input('''please input some numbers:''')
UpperCAmelCase = SubArray(whole_array)
UpperCAmelCase = array.solve_sub_array()
print(('''the results is:''', re))
| 677 |
"""simple docstring"""
UpperCAmelCase = {
'''A''': ['''B''', '''C''', '''E'''],
'''B''': ['''A''', '''D''', '''E'''],
'''C''': ['''A''', '''F''', '''G'''],
'''D''': ['''B'''],
'''E''': ['''A''', '''B''', '''D'''],
'''F''': ['''C'''],
'''G''': ['''C'''],
}
def lowerCamelCase (a_ :dict , a_ :List[str] , a_ :Tuple) -> list[str]:
lowercase :str = set()
# keep track of all the paths to be checked
lowercase :Dict = [[start]]
# return path if start is goal
if start == goal:
return [start]
# keeps looping until all possible paths have been checked
while queue:
# pop the first path from the queue
lowercase :Optional[int] = queue.pop(0)
# get the last node from the path
lowercase :Any = path[-1]
if node not in explored:
lowercase :int = graph[node]
# go through all neighbour nodes, construct a new path and
# push it into the queue
for neighbour in neighbours:
lowercase :List[Any] = list(a_)
new_path.append(a_)
queue.append(a_)
# return path if neighbour is goal
if neighbour == goal:
return new_path
# mark node as explored
explored.add(a_)
# in case there's no path between the 2 nodes
return []
def lowerCamelCase (a_ :dict , a_ :List[Any] , a_ :List[Any]) -> int:
if not graph or start not in graph or target not in graph:
return -1
if start == target:
return 0
lowercase :List[str] = [start]
lowercase :Optional[Any] = set(a_)
# Keep tab on distances from `start` node.
lowercase :Union[str, Any] = {start: 0, target: -1}
while queue:
lowercase :Union[str, Any] = queue.pop(0)
if node == target:
lowercase :Any = (
dist[node] if dist[target] == -1 else min(dist[target] , dist[node])
)
for adjacent in graph[node]:
if adjacent not in visited:
visited.add(a_)
queue.append(a_)
lowercase :Dict = dist[node] + 1
return dist[target]
if __name__ == "__main__":
print(bfs_shortest_path(demo_graph, '''G''', '''D''')) # returns ['G', 'C', 'A', 'B', 'D']
print(bfs_shortest_path_distance(demo_graph, '''G''', '''D''')) # returns 4
| 677 | 1 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_swiftformer''': [
'''SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''SwiftFormerConfig''',
'''SwiftFormerOnnxConfig''',
]
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''SwiftFormerForImageClassification''',
'''SwiftFormerModel''',
'''SwiftFormerPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_swiftformer import (
SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
SwiftFormerConfig,
SwiftFormerOnnxConfig,
)
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_swiftformer import (
SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
SwiftFormerForImageClassification,
SwiftFormerModel,
SwiftFormerPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 |
"""simple docstring"""
import logging
import os
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from tempfile import TemporaryDirectory
from typing import List, Optional
import faiss
import torch
from datasets import Features, Sequence, Value, load_dataset
from transformers import DPRContextEncoder, DPRContextEncoderTokenizerFast, HfArgumentParser
UpperCAmelCase = logging.getLogger(__name__)
torch.set_grad_enabled(False)
UpperCAmelCase = '''cuda''' if torch.cuda.is_available() else '''cpu'''
def lowerCamelCase (a_ :str , a_ :List[str]=100 , a_ :Optional[Any]=" ") -> List[str]:
lowercase :str = text.split(a_)
return [character.join(text[i : i + n]).strip() for i in range(0 , len(a_) , a_)]
def lowerCamelCase (a_ :dict) -> dict:
lowercase , lowercase :str = [], []
for title, text in zip(documents['''title'''] , documents['''text''']):
if text is not None:
for passage in split_text(a_):
titles.append(title if title is not None else '''''')
texts.append(a_)
return {"title": titles, "text": texts}
def lowerCamelCase (a_ :dict , a_ :DPRContextEncoder , a_ :DPRContextEncoderTokenizerFast) -> dict:
lowercase :Tuple = ctx_tokenizer(
documents['''title'''] , documents['''text'''] , truncation=a_ , padding='''longest''' , return_tensors='''pt''')['''input_ids''']
lowercase :Optional[Any] = ctx_encoder(input_ids.to(device=a_) , return_dict=a_).pooler_output
return {"embeddings": embeddings.detach().cpu().numpy()}
def lowerCamelCase (a_ :"RagExampleArguments" , a_ :"ProcessingArguments" , a_ :"IndexHnswArguments" , ) -> Any:
######################################
logger.info('''Step 1 - Create the dataset''')
######################################
# The dataset needed for RAG must have three columns:
# - title (string): title of the document
# - text (string): text of a passage of the document
# - embeddings (array of dimension d): DPR representation of the passage
# Let's say you have documents in tab-separated csv files with columns "title" and "text"
assert os.path.isfile(rag_example_args.csv_path), "Please provide a valid path to a csv file"
# You can load a Dataset object this way
lowercase :List[Any] = load_dataset(
'''csv''' , data_files=[rag_example_args.csv_path] , split='''train''' , delimiter='''\t''' , column_names=['''title''', '''text'''])
# More info about loading csv files in the documentation: https://huggingface.co/docs/datasets/loading_datasets.html?highlight=csv#csv-files
# Then split the documents into passages of 100 words
lowercase :Optional[Any] = dataset.map(a_ , batched=a_ , num_proc=processing_args.num_proc)
# And compute the embeddings
lowercase :str = DPRContextEncoder.from_pretrained(rag_example_args.dpr_ctx_encoder_model_name).to(device=a_)
lowercase :Dict = DPRContextEncoderTokenizerFast.from_pretrained(rag_example_args.dpr_ctx_encoder_model_name)
lowercase :str = Features(
{'''text''': Value('''string'''), '''title''': Value('''string'''), '''embeddings''': Sequence(Value('''float32'''))}) # optional, save as float32 instead of float64 to save space
lowercase :Optional[Any] = dataset.map(
partial(a_ , ctx_encoder=a_ , ctx_tokenizer=a_) , batched=a_ , batch_size=processing_args.batch_size , features=a_ , )
# And finally save your dataset
lowercase :str = os.path.join(rag_example_args.output_dir , '''my_knowledge_dataset''')
dataset.save_to_disk(a_)
# from datasets import load_from_disk
# dataset = load_from_disk(passages_path) # to reload the dataset
######################################
logger.info('''Step 2 - Index the dataset''')
######################################
# Let's use the Faiss implementation of HNSW for fast approximate nearest neighbor search
lowercase :str = faiss.IndexHNSWFlat(index_hnsw_args.d , index_hnsw_args.m , faiss.METRIC_INNER_PRODUCT)
dataset.add_faiss_index('''embeddings''' , custom_index=a_)
# And save the index
lowercase :Optional[Any] = os.path.join(rag_example_args.output_dir , '''my_knowledge_dataset_hnsw_index.faiss''')
dataset.get_index('''embeddings''').save(a_)
# dataset.load_faiss_index("embeddings", index_path) # to reload the index
@dataclass
class __magic_name__ :
__A : str = field(
default=str(Path(__UpperCAmelCase ).parent / "test_run" / "dummy-kb" / "my_knowledge_dataset.csv" ) , metadata={"help": "Path to a tab-separated csv file with columns 'title' and 'text'"} , )
__A : Optional[str] = field(
default=__UpperCAmelCase , metadata={"help": "Question that is passed as input to RAG. Default is 'What does Moses' rod turn into ?'."} , )
__A : str = field(
default="facebook/rag-sequence-nq" , metadata={"help": "The RAG model to use. Either 'facebook/rag-sequence-nq' or 'facebook/rag-token-nq'"} , )
__A : str = field(
default="facebook/dpr-ctx_encoder-multiset-base" , metadata={
"help": (
"The DPR context encoder model to use. Either 'facebook/dpr-ctx_encoder-single-nq-base' or"
" 'facebook/dpr-ctx_encoder-multiset-base'"
)
} , )
__A : Optional[str] = field(
default=str(Path(__UpperCAmelCase ).parent / "test_run" / "dummy-kb" ) , metadata={"help": "Path to a directory where the dataset passages and the index will be saved"} , )
@dataclass
class __magic_name__ :
__A : Optional[int] = field(
default=__UpperCAmelCase , metadata={
"help": "The number of processes to use to split the documents into passages. Default is single process."
} , )
__A : int = field(
default=16 , metadata={
"help": "The batch size to use when computing the passages embeddings using the DPR context encoder."
} , )
@dataclass
class __magic_name__ :
__A : int = field(
default=7_68 , metadata={"help": "The dimension of the embeddings to pass to the HNSW Faiss index."} , )
__A : int = field(
default=1_28 , metadata={
"help": (
"The number of bi-directional links created for every new element during the HNSW index construction."
)
} , )
if __name__ == "__main__":
logging.basicConfig(level=logging.WARNING)
logger.setLevel(logging.INFO)
UpperCAmelCase = HfArgumentParser((RagExampleArguments, ProcessingArguments, IndexHnswArguments))
UpperCAmelCase , UpperCAmelCase , UpperCAmelCase = parser.parse_args_into_dataclasses()
with TemporaryDirectory() as tmp_dir:
UpperCAmelCase = rag_example_args.output_dir or tmp_dir
main(rag_example_args, processing_args, index_hnsw_args)
| 677 | 1 |
"""simple docstring"""
import copy
import inspect
import unittest
from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available
from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor
if is_torch_available():
import torch
from transformers import TimmBackbone, TimmBackboneConfig
from ...test_pipeline_mixin import PipelineTesterMixin
class __magic_name__ :
def __init__( self : str , snake_case__ : Optional[int] , snake_case__ : Tuple=None , snake_case__ : Dict=None , snake_case__ : Tuple=None , snake_case__ : List[str]="resnet50" , snake_case__ : List[Any]=3 , snake_case__ : int=3_2 , snake_case__ : Optional[Any]=3 , snake_case__ : List[Any]=True , snake_case__ : List[str]=True , ):
'''simple docstring'''
lowercase :Tuple = parent
lowercase :Optional[Any] = out_indices if out_indices is not None else [4]
lowercase :Union[str, Any] = stage_names
lowercase :List[str] = out_features
lowercase :Dict = backbone
lowercase :Optional[Any] = batch_size
lowercase :List[Any] = image_size
lowercase :List[Any] = num_channels
lowercase :Optional[int] = use_pretrained_backbone
lowercase :Any = is_training
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :Union[str, Any] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
lowercase :List[str] = self.get_config()
return config, pixel_values
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
return TimmBackboneConfig(
image_size=self.image_size , num_channels=self.num_channels , out_features=self.out_features , out_indices=self.out_indices , stage_names=self.stage_names , use_pretrained_backbone=self.use_pretrained_backbone , backbone=self.backbone , )
def __snake_case ( self : Union[str, Any] , snake_case__ : Any , snake_case__ : int ):
'''simple docstring'''
lowercase :Dict = TimmBackbone(config=snake_case__ )
model.to(snake_case__ )
model.eval()
with torch.no_grad():
lowercase :List[str] = model(snake_case__ )
self.parent.assertEqual(
result.feature_map[-1].shape , (self.batch_size, model.channels[-1], 1_4, 1_4) , )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = self.prepare_config_and_inputs()
lowercase , lowercase :Optional[Any] = config_and_inputs
lowercase :List[str] = {'''pixel_values''': pixel_values}
return config, inputs_dict
@require_torch
@require_timm
class __magic_name__ ( __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
__A : Tuple = (TimmBackbone,) if is_torch_available() else ()
__A : Dict = {"feature-extraction": TimmBackbone} if is_torch_available() else {}
__A : Dict = False
__A : List[str] = False
__A : Optional[int] = False
__A : Optional[Any] = False
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :Dict = TimmBackboneModelTester(self )
lowercase :int = ConfigTester(self , config_class=snake_case__ , has_text_modality=snake_case__ )
def __snake_case ( self : Dict ):
'''simple docstring'''
self.config_tester.create_and_test_config_to_json_string()
self.config_tester.create_and_test_config_to_json_file()
self.config_tester.create_and_test_config_from_and_save_pretrained()
self.config_tester.create_and_test_config_with_num_labels()
self.config_tester.check_config_can_be_init_without_params()
self.config_tester.check_config_arguments_init()
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Optional[Any] = '''resnet18'''
lowercase :Optional[Any] = '''microsoft/resnet-18'''
lowercase :str = AutoBackbone.from_pretrained(snake_case__ , use_timm_backbone=snake_case__ )
lowercase :Any = AutoBackbone.from_pretrained(snake_case__ )
self.assertEqual(len(timm_model.out_features ) , len(transformers_model.out_features ) )
self.assertEqual(len(timm_model.stage_names ) , len(transformers_model.stage_names ) )
self.assertEqual(timm_model.channels , transformers_model.channels )
# Out indices are set to the last layer by default. For timm models, we don't know
# the number of layers in advance, so we set it to (-1,), whereas for transformers
# models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
self.assertEqual(timm_model.out_indices , (-1,) )
self.assertEqual(transformers_model.out_indices , [len(timm_model.stage_names ) - 1] )
lowercase :str = AutoBackbone.from_pretrained(snake_case__ , use_timm_backbone=snake_case__ , out_indices=[1, 2, 3] )
lowercase :Tuple = AutoBackbone.from_pretrained(snake_case__ , out_indices=[1, 2, 3] )
self.assertEqual(timm_model.out_indices , transformers_model.out_indices )
self.assertEqual(len(timm_model.out_features ) , len(transformers_model.out_features ) )
self.assertEqual(timm_model.channels , transformers_model.channels )
@unittest.skip('''TimmBackbone doesn\'t support feed forward chunking''' )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
pass
@unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute''' )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
pass
@unittest.skip('''TimmBackbone initialization is managed on the timm side''' )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
pass
@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds''' )
def __snake_case ( self : Any ):
'''simple docstring'''
pass
@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds''' )
def __snake_case ( self : int ):
'''simple docstring'''
pass
@unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint''' )
def __snake_case ( self : Tuple ):
'''simple docstring'''
pass
@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''' )
def __snake_case ( self : Dict ):
'''simple docstring'''
pass
@unittest.skip('''model weights aren\'t tied in TimmBackbone.''' )
def __snake_case ( self : Tuple ):
'''simple docstring'''
pass
@unittest.skip('''model weights aren\'t tied in TimmBackbone.''' )
def __snake_case ( self : str ):
'''simple docstring'''
pass
@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''' )
def __snake_case ( self : Tuple ):
'''simple docstring'''
pass
@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''' )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
pass
@unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.''' )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
pass
@unittest.skip('''TimmBackbone doesn\'t support output_attentions.''' )
def __snake_case ( self : Any ):
'''simple docstring'''
pass
@unittest.skip('''Safetensors is not supported by timm.''' )
def __snake_case ( self : List[str] ):
'''simple docstring'''
pass
@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''' )
def __snake_case ( self : Dict ):
'''simple docstring'''
pass
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase , lowercase :List[str] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :Optional[Any] = model_class(snake_case__ )
lowercase :int = inspect.signature(model.forward )
# signature.parameters is an OrderedDict => so arg_names order is deterministic
lowercase :Dict = [*signature.parameters.keys()]
lowercase :Union[str, Any] = ['''pixel_values''']
self.assertListEqual(arg_names[:1] , snake_case__ )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase , lowercase :str = self.model_tester.prepare_config_and_inputs_for_common()
lowercase :Union[str, Any] = True
lowercase :List[str] = self.has_attentions
# no need to test all models as different heads yield the same functionality
lowercase :Tuple = self.all_model_classes[0]
lowercase :str = model_class(snake_case__ )
model.to(snake_case__ )
lowercase :List[Any] = self._prepare_for_class(snake_case__ , snake_case__ )
lowercase :Any = model(**snake_case__ )
lowercase :Any = outputs[0][-1]
# Encoder-/Decoder-only models
lowercase :Dict = outputs.hidden_states[0]
hidden_states.retain_grad()
if self.has_attentions:
lowercase :int = outputs.attentions[0]
attentions.retain_grad()
output.flatten()[0].backward(retain_graph=snake_case__ )
self.assertIsNotNone(hidden_states.grad )
if self.has_attentions:
self.assertIsNotNone(attentions.grad )
def __snake_case ( self : str ):
'''simple docstring'''
lowercase , lowercase :List[Any] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase :Union[str, Any] = model_class(snake_case__ )
model.to(snake_case__ )
model.eval()
lowercase :Any = model(**snake_case__ )
self.assertEqual(len(result.feature_maps ) , len(config.out_indices ) )
self.assertEqual(len(model.channels ) , len(config.out_indices ) )
# Check output of last stage is taken if out_features=None, out_indices=None
lowercase :Dict = copy.deepcopy(snake_case__ )
lowercase :str = None
lowercase :List[Any] = model_class(snake_case__ )
model.to(snake_case__ )
model.eval()
lowercase :str = model(**snake_case__ )
self.assertEqual(len(result.feature_maps ) , 1 )
self.assertEqual(len(model.channels ) , 1 )
# Check backbone can be initialized with fresh weights
lowercase :List[str] = copy.deepcopy(snake_case__ )
lowercase :Optional[int] = False
lowercase :Tuple = model_class(snake_case__ )
model.to(snake_case__ )
model.eval()
lowercase :List[Any] = model(**snake_case__ )
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available
UpperCAmelCase = {
'''configuration_longt5''': ['''LONGT5_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''LongT5Config''', '''LongT5OnnxConfig'''],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''LONGT5_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''LongT5EncoderModel''',
'''LongT5ForConditionalGeneration''',
'''LongT5Model''',
'''LongT5PreTrainedModel''',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxLongT5ForConditionalGeneration''',
'''FlaxLongT5Model''',
'''FlaxLongT5PreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_longta import LONGT5_PRETRAINED_CONFIG_ARCHIVE_MAP, LongTaConfig, LongTaOnnxConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_longta import (
LONGT5_PRETRAINED_MODEL_ARCHIVE_LIST,
LongTaEncoderModel,
LongTaForConditionalGeneration,
LongTaModel,
LongTaPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_longta import (
FlaxLongTaForConditionalGeneration,
FlaxLongTaModel,
FlaxLongTaPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''google/fnet-base''': '''https://huggingface.co/google/fnet-base/resolve/main/config.json''',
'''google/fnet-large''': '''https://huggingface.co/google/fnet-large/resolve/main/config.json'''
# See all FNet models at https://huggingface.co/models?filter=fnet
}
class __magic_name__ ( __UpperCAmelCase ):
__A : Optional[int] = "fnet"
def __init__( self : List[str] , snake_case__ : Any=3_2_0_0_0 , snake_case__ : List[Any]=7_6_8 , snake_case__ : int=1_2 , snake_case__ : Tuple=3_0_7_2 , snake_case__ : Optional[int]="gelu_new" , snake_case__ : Tuple=0.1 , snake_case__ : int=5_1_2 , snake_case__ : Optional[Any]=4 , snake_case__ : List[Any]=0.02 , snake_case__ : Any=1e-1_2 , snake_case__ : List[str]=False , snake_case__ : Any=5_1_2 , snake_case__ : List[Any]=3 , snake_case__ : Dict=1 , snake_case__ : Dict=2 , **snake_case__ : List[Any] , ):
'''simple docstring'''
super().__init__(pad_token_id=snake_case__ , bos_token_id=snake_case__ , eos_token_id=snake_case__ , **snake_case__ )
lowercase :Tuple = vocab_size
lowercase :Dict = max_position_embeddings
lowercase :int = hidden_size
lowercase :Any = num_hidden_layers
lowercase :Any = intermediate_size
lowercase :List[Any] = hidden_act
lowercase :Any = hidden_dropout_prob
lowercase :Any = initializer_range
lowercase :Union[str, Any] = type_vocab_size
lowercase :str = layer_norm_eps
lowercase :Any = use_tpu_fourier_optimizations
lowercase :List[Any] = tpu_short_seq_length
| 677 |
"""simple docstring"""
import uuid
from typing import Any, Dict, List, Optional, Union
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline
if is_tf_available():
import tensorflow as tf
if is_torch_available():
import torch
UpperCAmelCase = logging.get_logger(__name__)
class __magic_name__ :
def __init__( self : Tuple , snake_case__ : str = None , snake_case__ : uuid.UUID = None , snake_case__ : Optional[int]=None , snake_case__ : Tuple=None ):
'''simple docstring'''
if not conversation_id:
lowercase :List[Any] = uuid.uuida()
if past_user_inputs is None:
lowercase :Union[str, Any] = []
if generated_responses is None:
lowercase :List[str] = []
lowercase :uuid.UUID = conversation_id
lowercase :List[str] = past_user_inputs
lowercase :List[str] = generated_responses
lowercase :Optional[str] = text
def __eq__( self : Optional[Any] , snake_case__ : str ):
'''simple docstring'''
if not isinstance(snake_case__ , snake_case__ ):
return False
if self.uuid == other.uuid:
return True
return (
self.new_user_input == other.new_user_input
and self.past_user_inputs == other.past_user_inputs
and self.generated_responses == other.generated_responses
)
def __snake_case ( self : Optional[int] , snake_case__ : str , snake_case__ : bool = False ):
'''simple docstring'''
if self.new_user_input:
if overwrite:
logger.warning(
f"""User input added while unprocessed input was existing: \"{self.new_user_input}\" was overwritten """
f"""with: \"{text}\".""" )
lowercase :List[str] = text
else:
logger.warning(
f"""User input added while unprocessed input was existing: \"{self.new_user_input}\" new input """
f"""ignored: \"{text}\". Set `overwrite` to True to overwrite unprocessed user input""" )
else:
lowercase :Optional[int] = text
def __snake_case ( self : Any ):
'''simple docstring'''
if self.new_user_input:
self.past_user_inputs.append(self.new_user_input )
lowercase :Tuple = None
def __snake_case ( self : Tuple , snake_case__ : str ):
'''simple docstring'''
self.generated_responses.append(snake_case__ )
def __snake_case ( self : Tuple ):
'''simple docstring'''
for user_input, generated_response in zip(self.past_user_inputs , self.generated_responses ):
yield True, user_input
yield False, generated_response
if self.new_user_input:
yield True, self.new_user_input
def __repr__( self : Dict ):
'''simple docstring'''
lowercase :int = f"""Conversation id: {self.uuid} \n"""
for is_user, text in self.iter_texts():
lowercase :Dict = '''user''' if is_user else '''bot'''
output += f"""{name} >> {text} \n"""
return output
@add_end_docstrings(
__UpperCAmelCase , R"\n min_length_for_response (`int`, *optional*, defaults to 32):\n The minimum length (in number of tokens) for a response.\n minimum_tokens (`int`, *optional*, defaults to 10):\n The minimum length of tokens to leave for a response.\n " , )
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Optional[Any] , *snake_case__ : Optional[Any] , **snake_case__ : List[Any] ):
'''simple docstring'''
super().__init__(*snake_case__ , **snake_case__ )
if self.tokenizer.pad_token_id is None:
lowercase :Any = self.tokenizer.eos_token
def __snake_case ( self : List[Any] , snake_case__ : Optional[int]=None , snake_case__ : Union[str, Any]=None , snake_case__ : List[str]=None , **snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase :str = {}
lowercase :List[str] = {}
lowercase :Tuple = {}
if min_length_for_response is not None:
lowercase :Dict = min_length_for_response
if minimum_tokens is not None:
lowercase :Union[str, Any] = minimum_tokens
if "max_length" in generate_kwargs:
lowercase :List[Any] = generate_kwargs['''max_length''']
# self.max_length = generate_kwargs.get("max_length", self.model.config.max_length)
if clean_up_tokenization_spaces is not None:
lowercase :Dict = clean_up_tokenization_spaces
if generate_kwargs:
forward_params.update(snake_case__ )
return preprocess_params, forward_params, postprocess_params
def __call__( self : List[Any] , snake_case__ : Union[Conversation, List[Conversation]] , snake_case__ : int=0 , **snake_case__ : int ):
'''simple docstring'''
lowercase :int = super().__call__(snake_case__ , num_workers=snake_case__ , **snake_case__ )
if isinstance(snake_case__ , snake_case__ ) and len(snake_case__ ) == 1:
return outputs[0]
return outputs
def __snake_case ( self : List[Any] , snake_case__ : Conversation , snake_case__ : Any=3_2 ):
'''simple docstring'''
if not isinstance(snake_case__ , snake_case__ ):
raise ValueError('''ConversationalPipeline, expects Conversation as inputs''' )
if conversation.new_user_input is None:
raise ValueError(
f"""Conversation with UUID {type(conversation.uuid )} does not contain new user input to process. """
'''Add user inputs with the conversation\'s `add_user_input` method''' )
if hasattr(self.tokenizer , '''_build_conversation_input_ids''' ):
lowercase :List[str] = self.tokenizer._build_conversation_input_ids(snake_case__ )
else:
# If the tokenizer cannot handle conversations, we default to only the old version
lowercase :List[str] = self._legacy_parse_and_tokenize(snake_case__ )
if self.framework == "pt":
lowercase :int = torch.LongTensor([input_ids] )
elif self.framework == "tf":
lowercase :Any = tf.constant([input_ids] )
return {"input_ids": input_ids, "conversation": conversation}
def __snake_case ( self : int , snake_case__ : Union[str, Any] , snake_case__ : Any=1_0 , **snake_case__ : int ):
'''simple docstring'''
lowercase :Dict = generate_kwargs.get('''max_length''' , self.model.config.max_length )
lowercase :Optional[Any] = model_inputs['''input_ids'''].shape[1]
if max_length - minimum_tokens < n:
logger.warning(f"""Conversation input is to long ({n}), trimming it to ({max_length} - {minimum_tokens})""" )
lowercase :int = max_length - minimum_tokens
lowercase :int = model_inputs['''input_ids'''][:, -trim:]
if "attention_mask" in model_inputs:
lowercase :int = model_inputs['''attention_mask'''][:, -trim:]
lowercase :int = model_inputs.pop('''conversation''' )
lowercase :Union[str, Any] = max_length
lowercase :Dict = self.model.generate(**snake_case__ , **snake_case__ )
if self.model.config.is_encoder_decoder:
lowercase :List[Any] = 1
else:
lowercase :Optional[Any] = n
return {"output_ids": output_ids[:, start_position:], "conversation": conversation}
def __snake_case ( self : Optional[int] , snake_case__ : List[Any] , snake_case__ : Optional[Any]=True ):
'''simple docstring'''
lowercase :Dict = model_outputs['''output_ids''']
lowercase :Dict = self.tokenizer.decode(
output_ids[0] , skip_special_tokens=snake_case__ , clean_up_tokenization_spaces=snake_case__ , )
lowercase :Optional[int] = model_outputs['''conversation''']
conversation.mark_processed()
conversation.append_response(snake_case__ )
return conversation
def __snake_case ( self : List[Any] , snake_case__ : Conversation ):
'''simple docstring'''
lowercase :str = self.tokenizer.eos_token_id
lowercase :List[Any] = []
for is_user, text in conversation.iter_texts():
if eos_token_id is not None:
input_ids.extend(self.tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ ) + [eos_token_id] )
else:
input_ids.extend(self.tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ ) )
if len(snake_case__ ) > self.tokenizer.model_max_length:
lowercase :List[Any] = input_ids[-self.tokenizer.model_max_length :]
return input_ids
| 677 | 1 |
"""simple docstring"""
import unittest
from transformers import JukeboxTokenizer
from transformers.testing_utils import require_torch
class __magic_name__ ( unittest.TestCase ):
__A : Tuple = JukeboxTokenizer
__A : List[Any] = {
"artist": "Zac Brown Band",
"genres": "Country",
"lyrics": "I met a traveller from an antique land,\n Who said \"Two vast and trunkless legs of stone\n Stand in the desert. . . . Near them, on the sand,\n Half sunk a shattered visage lies, whose frown,\n And wrinkled lip, and sneer of cold command,\n Tell that its sculptor well those passions read\n Which yet survive, stamped on these lifeless things,\n The hand that mocked them, and the heart that fed;\n And on the pedestal, these words appear:\n My name is Ozymandias, King of Kings;\n Look on my Works, ye Mighty, and despair!\n Nothing beside remains. Round the decay\n Of that colossal Wreck, boundless and bare\n The lone and level sands stretch far away\n ",
}
@require_torch
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
import torch
lowercase :str = JukeboxTokenizer.from_pretrained('''openai/jukebox-1b-lyrics''' )
lowercase :List[str] = tokenizer(**self.metas )['''input_ids''']
# fmt: off
lowercase :Optional[Any] = [
torch.tensor([[
0, 0, 0, 7_1_6_9, 5_0_7, 9, 7_6, 3_9, 3_1, 4_6, 7_6, 2_7,
7_6, 4_6, 4_4, 2_7, 4_8, 3_1, 3_8, 3_8, 3_1, 4_4, 7_6, 3_2,
4_4, 4_1, 3_9, 7_6, 2_7, 4_0, 7_6, 2_7, 4_0, 4_6, 3_5, 4_3,
4_7, 3_1, 7_6, 3_8, 2_7, 4_0, 3_0, 6_4, 7_8, 7_6, 7_6, 7_6,
7_6, 7_6, 7_6, 7_6, 7_6, 2_3, 3_4, 4_1, 7_6, 4_5, 2_7, 3_5,
3_0, 7_6, 7_1, 2_0, 4_9, 4_1, 7_6, 4_8, 2_7, 4_5, 4_6, 7_6,
2_7, 4_0, 3_0, 7_6, 4_6, 4_4, 4_7, 4_0, 3_7, 3_8, 3_1, 4_5,
4_5, 7_6, 3_8, 3_1, 3_3, 4_5, 7_6, 4_1, 3_2, 7_6, 4_5, 4_6,
4_1, 4_0, 3_1, 7_8, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6,
1_9, 4_6, 2_7, 4_0, 3_0, 7_6, 3_5, 4_0, 7_6, 4_6, 3_4, 3_1,
7_6, 3_0, 3_1, 4_5, 3_1, 4_4, 4_6, 6_3, 7_6, 6_3, 7_6, 6_3,
7_6, 6_3, 7_6, 1_4, 3_1, 2_7, 4_4, 7_6, 4_6, 3_4, 3_1, 3_9,
6_4, 7_6, 4_1, 4_0, 7_6, 4_6, 3_4, 3_1, 7_6, 4_5, 2_7, 4_0,
3_0, 6_4, 7_8, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 8,
2_7, 3_8, 3_2, 7_6, 4_5, 4_7, 4_0, 3_7, 7_6, 2_7, 7_6, 4_5,
3_4, 2_7, 4_6, 4_6, 3_1, 4_4, 3_1, 3_0, 7_6, 4_8, 3_5, 4_5,
2_7, 3_3, 3_1, 7_6, 3_8, 3_5, 3_1, 4_5, 6_4, 7_6, 4_9, 3_4,
4_1, 4_5, 3_1, 7_6, 3_2, 4_4, 4_1, 4_9, 4_0, 6_4, 7_8, 7_6,
7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 1, 4_0, 3_0, 7_6, 4_9,
4_4, 3_5, 4_0, 3_7, 3_8, 3_1, 3_0, 7_6, 3_8, 3_5, 4_2, 6_4,
7_6, 2_7, 4_0, 3_0, 7_6, 4_5, 4_0, 3_1, 3_1, 4_4, 7_6, 4_1,
3_2, 7_6, 2_9, 4_1, 3_8, 3_0, 7_6, 2_9, 4_1, 3_9, 3_9, 2_7,
4_0, 3_0, 6_4, 7_8, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6,
2_0, 3_1, 3_8, 3_8, 7_6, 4_6, 3_4, 2_7, 4_6, 7_6, 3_5, 4_6,
4_5, 7_6, 4_5, 2_9, 4_7, 3_8, 4_2, 4_6, 4_1, 4_4, 7_6, 4_9,
3_1, 3_8, 3_8, 7_6, 4_6, 3_4, 4_1, 4_5, 3_1, 7_6, 4_2, 2_7,
4_5, 4_5, 3_5, 4_1, 4_0, 4_5, 7_6, 4_4, 3_1, 2_7, 3_0, 7_8,
7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 2_3, 3_4, 3_5, 2_9,
3_4, 7_6, 5_1, 3_1, 4_6, 7_6, 4_5, 4_7, 4_4, 4_8, 3_5, 4_8,
3_1, 6_4, 7_6, 4_5, 4_6, 2_7, 3_9, 4_2, 3_1, 3_0, 7_6, 4_1,
4_0, 7_6, 4_6, 3_4, 3_1, 4_5, 3_1, 7_6, 3_8, 3_5, 3_2, 3_1,
3_8, 3_1, 4_5, 4_5, 7_6, 4_6, 3_4, 3_5, 4_0, 3_3, 4_5, 6_4,
7_8, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 2_0, 3_4, 3_1,
7_6, 3_4, 2_7, 4_0, 3_0, 7_6, 4_6, 3_4, 2_7, 4_6, 7_6, 3_9,
4_1, 2_9, 3_7, 3_1, 3_0, 7_6, 4_6, 3_4, 3_1, 3_9, 6_4, 7_6,
2_7, 4_0, 3_0, 7_6, 4_6, 3_4, 3_1, 7_6, 3_4, 3_1, 2_7, 4_4,
4_6, 7_6, 4_6, 3_4, 2_7, 4_6, 7_6, 3_2, 3_1, 3_0, 6_6, 7_8,
7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 1, 4_0, 3_0, 7_6,
4_1, 4_0, 7_6, 4_6, 3_4, 3_1, 7_6, 4_2, 3_1, 3_0, 3_1, 4_5,
4_6, 2_7, 3_8, 6_4, 7_6, 4_6, 3_4, 3_1, 4_5, 3_1, 7_6, 4_9,
4_1, 4_4, 3_0, 4_5, 7_6, 2_7, 4_2, 4_2, 3_1, 2_7, 4_4, 6_5,
7_8, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 1_3, 5_1, 7_6,
4_0, 2_7, 3_9, 3_1, 7_6, 3_5, 4_5, 7_6, 1_5, 5_2, 5_1, 3_9,
2_7, 4_0, 3_0, 3_5, 2_7, 4_5, 6_4, 7_6, 1_1, 3_5, 4_0, 3_3,
7_6, 4_1, 3_2, 7_6, 1_1, 3_5, 4_0, 3_3, 4_5, 6_6, 7_8, 7_6,
7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 1_2, 4_1, 4_1, 3_7, 7_6,
4_1, 4_0, 7_6, 3_9, 5_1, 7_6, 2_3, 4_1, 4_4, 3_7, 4_5, 6_4,
7_6, 5_1, 3_1, 7_6, 1_3, 3_5, 3_3, 3_4, 4_6, 5_1, 6_4, 7_6,
2_7, 4_0, 3_0, 7_6, 3_0, 3_1, 4_5, 4_2, 2_7, 3_5, 4_4, 6_7,
7_8, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 1_4, 4_1, 4_6,
3_4, 3_5, 4_0, 3_3, 7_6, 2_8, 3_1, 4_5, 3_5, 3_0, 3_1, 7_6,
4_4, 3_1, 3_9, 2_7, 3_5, 4_0, 4_5, 6_3, 7_6, 1_8, 4_1, 4_7,
4_0, 3_0, 7_6, 4_6, 3_4, 3_1, 7_6, 3_0, 3_1, 2_9, 2_7, 5_1,
7_8, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 1_5, 3_2, 7_6,
4_6, 3_4, 2_7, 4_6, 7_6, 2_9, 4_1, 3_8, 4_1, 4_5, 4_5, 2_7,
3_8, 7_6, 2_3, 4_4, 3_1, 2_9, 3_7, 6_4, 7_6, 2_8, 4_1, 4_7,
4_0, 3_0, 3_8, 3_1, 4_5, 4_5, 7_6, 2_7, 4_0, 3_0, 7_6, 2_8,
2_7, 4_4, 3_1, 7_8, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6,
2_0, 3_4, 3_1, 7_6, 3_8, 4_1, 4_0, 3_1, 7_6, 2_7, 4_0, 3_0,
7_6, 3_8, 3_1, 4_8, 3_1, 3_8, 7_6, 4_5, 2_7, 4_0, 3_0, 4_5,
7_6, 4_5, 4_6, 4_4, 3_1, 4_6, 2_9, 3_4, 7_6, 3_2, 2_7, 4_4,
7_6, 2_7, 4_9, 2_7, 5_1, 7_8, 7_6, 7_6, 7_6, 7_6, 7_6, 7_6,
7_6, 7_6]] ),
torch.tensor([[0, 0, 0, 1_0_6_9, 1_1]] ),
torch.tensor([[0, 0, 0, 1_0_6_9, 1_1]] ),
]
# fmt: on
self.assertTrue(torch.allclose(tokens[0] , EXPECTED_OUTPUT[0] ) )
self.assertTrue(torch.allclose(tokens[1] , EXPECTED_OUTPUT[1] ) )
self.assertTrue(torch.allclose(tokens[2] , EXPECTED_OUTPUT[2] ) )
@require_torch
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
import torch
lowercase :Tuple = JukeboxTokenizer.from_pretrained('''openai/jukebox-5b-lyrics''' )
lowercase :Union[str, Any] = tokenizer(**self.metas )['''input_ids''']
# fmt: off
lowercase :str = [
torch.tensor([[
0, 0, 0, 1_0_6_9, 1_1, -1, -1, -1, -1, 9, 7_7, 3_9,
3_1, 4_6, 7_7, 2_7, 7_7, 4_6, 4_4, 2_7, 4_8, 3_1, 3_8, 3_8,
3_1, 4_4, 7_7, 3_2, 4_4, 4_1, 3_9, 7_7, 2_7, 4_0, 7_7, 2_7,
4_0, 4_6, 3_5, 4_3, 4_7, 3_1, 7_7, 3_8, 2_7, 4_0, 3_0, 6_4,
7_9, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 2_3, 3_4, 4_1,
7_7, 4_5, 2_7, 3_5, 3_0, 7_7, 7_2, 2_0, 4_9, 4_1, 7_7, 4_8,
2_7, 4_5, 4_6, 7_7, 2_7, 4_0, 3_0, 7_7, 4_6, 4_4, 4_7, 4_0,
3_7, 3_8, 3_1, 4_5, 4_5, 7_7, 3_8, 3_1, 3_3, 4_5, 7_7, 4_1,
3_2, 7_7, 4_5, 4_6, 4_1, 4_0, 3_1, 7_9, 7_7, 7_7, 7_7, 7_7,
7_7, 7_7, 7_7, 7_7, 1_9, 4_6, 2_7, 4_0, 3_0, 7_7, 3_5, 4_0,
7_7, 4_6, 3_4, 3_1, 7_7, 3_0, 3_1, 4_5, 3_1, 4_4, 4_6, 6_3,
7_7, 6_3, 7_7, 6_3, 7_7, 6_3, 7_7, 1_4, 3_1, 2_7, 4_4, 7_7,
4_6, 3_4, 3_1, 3_9, 6_4, 7_7, 4_1, 4_0, 7_7, 4_6, 3_4, 3_1,
7_7, 4_5, 2_7, 4_0, 3_0, 6_4, 7_9, 7_7, 7_7, 7_7, 7_7, 7_7,
7_7, 7_7, 7_7, 8, 2_7, 3_8, 3_2, 7_7, 4_5, 4_7, 4_0, 3_7,
7_7, 2_7, 7_7, 4_5, 3_4, 2_7, 4_6, 4_6, 3_1, 4_4, 3_1, 3_0,
7_7, 4_8, 3_5, 4_5, 2_7, 3_3, 3_1, 7_7, 3_8, 3_5, 3_1, 4_5,
6_4, 7_7, 4_9, 3_4, 4_1, 4_5, 3_1, 7_7, 3_2, 4_4, 4_1, 4_9,
4_0, 6_4, 7_9, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 1,
4_0, 3_0, 7_7, 4_9, 4_4, 3_5, 4_0, 3_7, 3_8, 3_1, 3_0, 7_7,
3_8, 3_5, 4_2, 6_4, 7_7, 2_7, 4_0, 3_0, 7_7, 4_5, 4_0, 3_1,
3_1, 4_4, 7_7, 4_1, 3_2, 7_7, 2_9, 4_1, 3_8, 3_0, 7_7, 2_9,
4_1, 3_9, 3_9, 2_7, 4_0, 3_0, 6_4, 7_9, 7_7, 7_7, 7_7, 7_7,
7_7, 7_7, 7_7, 7_7, 2_0, 3_1, 3_8, 3_8, 7_7, 4_6, 3_4, 2_7,
4_6, 7_7, 3_5, 4_6, 4_5, 7_7, 4_5, 2_9, 4_7, 3_8, 4_2, 4_6,
4_1, 4_4, 7_7, 4_9, 3_1, 3_8, 3_8, 7_7, 4_6, 3_4, 4_1, 4_5,
3_1, 7_7, 4_2, 2_7, 4_5, 4_5, 3_5, 4_1, 4_0, 4_5, 7_7, 4_4,
3_1, 2_7, 3_0, 7_9, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7,
2_3, 3_4, 3_5, 2_9, 3_4, 7_7, 5_1, 3_1, 4_6, 7_7, 4_5, 4_7,
4_4, 4_8, 3_5, 4_8, 3_1, 6_4, 7_7, 4_5, 4_6, 2_7, 3_9, 4_2,
3_1, 3_0, 7_7, 4_1, 4_0, 7_7, 4_6, 3_4, 3_1, 4_5, 3_1, 7_7,
3_8, 3_5, 3_2, 3_1, 3_8, 3_1, 4_5, 4_5, 7_7, 4_6, 3_4, 3_5,
4_0, 3_3, 4_5, 6_4, 7_9, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7,
7_7, 2_0, 3_4, 3_1, 7_7, 3_4, 2_7, 4_0, 3_0, 7_7, 4_6, 3_4,
2_7, 4_6, 7_7, 3_9, 4_1, 2_9, 3_7, 3_1, 3_0, 7_7, 4_6, 3_4,
3_1, 3_9, 6_4, 7_7, 2_7, 4_0, 3_0, 7_7, 4_6, 3_4, 3_1, 7_7,
3_4, 3_1, 2_7, 4_4, 4_6, 7_7, 4_6, 3_4, 2_7, 4_6, 7_7, 3_2,
3_1, 3_0, 6_6, 7_9, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7,
1, 4_0, 3_0, 7_7, 4_1, 4_0, 7_7, 4_6, 3_4, 3_1, 7_7, 4_2,
3_1, 3_0, 3_1, 4_5, 4_6, 2_7, 3_8, 6_4, 7_7, 4_6, 3_4, 3_1,
4_5, 3_1, 7_7, 4_9, 4_1, 4_4, 3_0, 4_5, 7_7, 2_7, 4_2, 4_2,
3_1, 2_7, 4_4, 6_5, 7_9, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7,
7_7, 1_3, 5_1, 7_7, 4_0, 2_7, 3_9, 3_1, 7_7, 3_5, 4_5, 7_7,
1_5, 5_2, 5_1, 3_9, 2_7, 4_0, 3_0, 3_5, 2_7, 4_5, 6_4, 7_7,
1_1, 3_5, 4_0, 3_3, 7_7, 4_1, 3_2, 7_7, 1_1, 3_5, 4_0, 3_3,
4_5, 6_6, 7_9, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 1_2,
4_1, 4_1, 3_7, 7_7, 4_1, 4_0, 7_7, 3_9, 5_1, 7_7, 2_3, 4_1,
4_4, 3_7, 4_5, 6_4, 7_7, 5_1, 3_1, 7_7, 1_3, 3_5, 3_3, 3_4,
4_6, 5_1, 6_4, 7_7, 2_7, 4_0, 3_0, 7_7, 3_0, 3_1, 4_5, 4_2,
2_7, 3_5, 4_4, 6_7, 7_9, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7,
7_7, 1_4, 4_1, 4_6, 3_4, 3_5, 4_0, 3_3, 7_7, 2_8, 3_1, 4_5,
3_5, 3_0, 3_1, 7_7, 4_4, 3_1, 3_9, 2_7, 3_5, 4_0, 4_5, 6_3,
7_7, 1_8, 4_1, 4_7, 4_0, 3_0, 7_7, 4_6, 3_4, 3_1, 7_7, 3_0,
3_1, 2_9, 2_7, 5_1, 7_9, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7, 7_7,
7_7, 1_5, 3_2, 7_7, 4_6, 3_4, 2_7, 4_6, 7_7, 2_9, 4_1, 3_8,
4_1, 4_5, 4_5, 2_7, 3_8, 7_7, 2_3, 4_4, 3_1, 2_9, 3_7, 6_4,
7_7, 2_8, 4_1, 4_7, 4_0, 3_0, 3_8, 3_1, 4_5, 4_5, 7_7, 2_7,
4_0, 3_0, 7_7, 2_8, 2_7, 4_4, 3_1, 7_9, 7_7, 7_7, 7_7, 7_7,
7_7, 7_7, 7_7, 7_7, 2_0, 3_4, 3_1, 7_7, 3_8, 4_1, 4_0, 3_1,
7_7, 2_7, 4_0, 3_0, 7_7, 3_8, 3_1, 4_8, 3_1, 3_8, 7_7, 4_5,
2_7, 4_0, 3_0, 4_5, 7_7, 4_5, 4_6, 4_4, 3_1, 4_6, 2_9, 3_4,
7_7, 3_2, 2_7, 4_4, 7_7, 2_7, 4_9, 2_7, 5_1, 7_9, 7_7, 7_7,
7_7, 7_7, 7_7, 7_7, 7_7, 7_7]] ),
torch.tensor([[0, 0, 0, 1_0_6_9, 1_1, -1, -1, -1, -1]] ),
torch.tensor([[0, 0, 0, 1_0_6_9, 1_1, -1, -1, -1, -1]] ),
]
# fmt: on
self.assertTrue(torch.allclose(tokens[0] , EXPECTED_OUTPUT[0] ) )
self.assertTrue(torch.allclose(tokens[1] , EXPECTED_OUTPUT[1] ) )
self.assertTrue(torch.allclose(tokens[2] , EXPECTED_OUTPUT[2] ) )
| 677 |
"""simple docstring"""
def lowerCamelCase (a_ :int = 100) -> int:
lowercase :Union[str, Any] = set()
lowercase :List[Any] = 0
lowercase :Dict = n + 1 # maximum limit
for a in range(2 , a_):
for b in range(2 , a_):
lowercase :Tuple = a**b # calculates the current power
collect_powers.add(a_) # adds the result to the set
return len(a_)
if __name__ == "__main__":
print('''Number of terms ''', solution(int(str(input()).strip())))
| 677 | 1 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tf_available,
is_tokenizers_available,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_distilbert''': [
'''DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''DistilBertConfig''',
'''DistilBertOnnxConfig''',
],
'''tokenization_distilbert''': ['''DistilBertTokenizer'''],
}
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''DistilBertTokenizerFast''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''DistilBertForMaskedLM''',
'''DistilBertForMultipleChoice''',
'''DistilBertForQuestionAnswering''',
'''DistilBertForSequenceClassification''',
'''DistilBertForTokenClassification''',
'''DistilBertModel''',
'''DistilBertPreTrainedModel''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''TFDistilBertForMaskedLM''',
'''TFDistilBertForMultipleChoice''',
'''TFDistilBertForQuestionAnswering''',
'''TFDistilBertForSequenceClassification''',
'''TFDistilBertForTokenClassification''',
'''TFDistilBertMainLayer''',
'''TFDistilBertModel''',
'''TFDistilBertPreTrainedModel''',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxDistilBertForMaskedLM''',
'''FlaxDistilBertForMultipleChoice''',
'''FlaxDistilBertForQuestionAnswering''',
'''FlaxDistilBertForSequenceClassification''',
'''FlaxDistilBertForTokenClassification''',
'''FlaxDistilBertModel''',
'''FlaxDistilBertPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_distilbert import (
DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
DistilBertConfig,
DistilBertOnnxConfig,
)
from .tokenization_distilbert import DistilBertTokenizer
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_distilbert_fast import DistilBertTokenizerFast
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_distilbert import (
DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
DistilBertForMaskedLM,
DistilBertForMultipleChoice,
DistilBertForQuestionAnswering,
DistilBertForSequenceClassification,
DistilBertForTokenClassification,
DistilBertModel,
DistilBertPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_distilbert import (
TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
TFDistilBertForMaskedLM,
TFDistilBertForMultipleChoice,
TFDistilBertForQuestionAnswering,
TFDistilBertForSequenceClassification,
TFDistilBertForTokenClassification,
TFDistilBertMainLayer,
TFDistilBertModel,
TFDistilBertPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_distilbert import (
FlaxDistilBertForMaskedLM,
FlaxDistilBertForMultipleChoice,
FlaxDistilBertForQuestionAnswering,
FlaxDistilBertForSequenceClassification,
FlaxDistilBertForTokenClassification,
FlaxDistilBertModel,
FlaxDistilBertPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 |
"""simple docstring"""
from typing import Callable, Optional, Union
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''microsoft/xprophetnet-large-wiki100-cased''': (
'''https://huggingface.co/microsoft/xprophetnet-large-wiki100-cased/resolve/main/config.json'''
),
}
class __magic_name__ ( __UpperCAmelCase ):
__A : Optional[Any] = "xlm-prophetnet"
__A : List[str] = ["past_key_values"]
__A : int = {
"num_attention_heads": "num_encoder_attention_heads",
}
def __init__( self : Any , snake_case__ : Optional[float] = 0.1 , snake_case__ : Optional[Union[str, Callable]] = "gelu" , snake_case__ : Optional[int] = 3_0_5_2_2 , snake_case__ : Optional[int] = 1_0_2_4 , snake_case__ : Optional[int] = 4_0_9_6 , snake_case__ : Optional[int] = 1_2 , snake_case__ : Optional[int] = 1_6 , snake_case__ : Optional[int] = 4_0_9_6 , snake_case__ : Optional[int] = 1_2 , snake_case__ : Optional[int] = 1_6 , snake_case__ : Optional[float] = 0.1 , snake_case__ : Optional[float] = 0.1 , snake_case__ : Optional[int] = 5_1_2 , snake_case__ : Optional[float] = 0.02 , snake_case__ : Optional[bool] = True , snake_case__ : Optional[bool] = True , snake_case__ : Optional[int] = 0 , snake_case__ : Optional[int] = 2 , snake_case__ : Optional[int] = 3_2 , snake_case__ : Optional[int] = 1_2_8 , snake_case__ : Optional[bool] = False , snake_case__ : Optional[float] = 0.0 , snake_case__ : Optional[bool] = True , snake_case__ : Optional[int] = 0 , snake_case__ : Optional[int] = 1 , snake_case__ : Optional[int] = 2 , **snake_case__ : List[str] , ):
'''simple docstring'''
lowercase :Tuple = vocab_size
lowercase :Optional[int] = hidden_size
lowercase :Optional[int] = encoder_ffn_dim
lowercase :Optional[int] = num_encoder_layers
lowercase :Dict = num_encoder_attention_heads
lowercase :List[str] = decoder_ffn_dim
lowercase :Dict = num_decoder_layers
lowercase :List[Any] = num_decoder_attention_heads
lowercase :Optional[int] = max_position_embeddings
lowercase :Tuple = init_std # Normal(0, this parameter)
lowercase :int = activation_function
# parameters for xlmprophetnet
lowercase :Dict = ngram
lowercase :Optional[Any] = num_buckets
lowercase :Dict = relative_max_distance
lowercase :List[Any] = disable_ngram_loss
lowercase :Optional[Any] = eps
# 3 Types of Dropout
lowercase :Any = attention_dropout
lowercase :List[str] = activation_dropout
lowercase :List[str] = dropout
lowercase :List[str] = use_cache
super().__init__(
pad_token_id=snake_case__ , bos_token_id=snake_case__ , eos_token_id=snake_case__ , is_encoder_decoder=snake_case__ , add_cross_attention=snake_case__ , decoder_start_token_id=snake_case__ , **snake_case__ , )
@property
def __snake_case ( self : Any ):
'''simple docstring'''
return self.num_encoder_layers + self.num_decoder_layers
@num_hidden_layers.setter
def __snake_case ( self : Optional[Any] , snake_case__ : Optional[Any] ):
'''simple docstring'''
raise NotImplementedError(
'''This model does not support the setting of `num_hidden_layers`. Please set `num_encoder_layers` and'''
''' `num_decoder_layers`.''' )
| 677 | 1 |
"""simple docstring"""
from __future__ import annotations
import unittest
from transformers import BlenderbotSmallConfig, BlenderbotSmallTokenizer, is_tf_available
from transformers.testing_utils import require_tf, require_tokenizers, slow
from transformers.utils import cached_property
from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin
if is_tf_available():
import tensorflow as tf
from transformers import TFAutoModelForSeqaSeqLM, TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel
@require_tf
class __magic_name__ :
__A : str = BlenderbotSmallConfig
__A : Union[str, Any] = {}
__A : List[Any] = "gelu"
def __init__( self : Dict , snake_case__ : Any , snake_case__ : List[str]=1_3 , snake_case__ : List[str]=7 , snake_case__ : List[str]=True , snake_case__ : Optional[Any]=False , snake_case__ : List[Any]=9_9 , snake_case__ : str=3_2 , snake_case__ : Tuple=2 , snake_case__ : int=4 , snake_case__ : List[str]=3_7 , snake_case__ : List[str]=0.1 , snake_case__ : Dict=0.1 , snake_case__ : Dict=2_0 , snake_case__ : int=2 , snake_case__ : Union[str, Any]=1 , snake_case__ : int=0 , ):
'''simple docstring'''
lowercase :Optional[Any] = parent
lowercase :Dict = batch_size
lowercase :Union[str, Any] = seq_length
lowercase :Any = is_training
lowercase :Optional[Any] = use_labels
lowercase :Optional[Any] = vocab_size
lowercase :Optional[Any] = hidden_size
lowercase :Union[str, Any] = num_hidden_layers
lowercase :Tuple = num_attention_heads
lowercase :List[Any] = intermediate_size
lowercase :Tuple = hidden_dropout_prob
lowercase :Optional[int] = attention_probs_dropout_prob
lowercase :Any = max_position_embeddings
lowercase :List[Any] = eos_token_id
lowercase :int = pad_token_id
lowercase :Optional[int] = bos_token_id
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :Tuple = ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size )
lowercase :Union[str, Any] = tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size ) , 1 )
lowercase :int = tf.concat([input_ids, eos_tensor] , axis=1 )
lowercase :List[str] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size )
lowercase :Dict = self.config_cls(
vocab_size=self.vocab_size , d_model=self.hidden_size , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_ids=[2] , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.pad_token_id , **self.config_updates , )
lowercase :Union[str, Any] = prepare_blenderbot_small_inputs_dict(snake_case__ , snake_case__ , snake_case__ )
return config, inputs_dict
def __snake_case ( self : Optional[Any] , snake_case__ : str , snake_case__ : Tuple ):
'''simple docstring'''
lowercase :Dict = TFBlenderbotSmallModel(config=snake_case__ ).get_decoder()
lowercase :Tuple = inputs_dict['''input_ids''']
lowercase :Tuple = input_ids[:1, :]
lowercase :Optional[int] = inputs_dict['''attention_mask'''][:1, :]
lowercase :int = inputs_dict['''head_mask''']
lowercase :Tuple = 1
# first forward pass
lowercase :Optional[int] = model(snake_case__ , attention_mask=snake_case__ , head_mask=snake_case__ , use_cache=snake_case__ )
lowercase , lowercase :Optional[int] = outputs.to_tuple()
# create hypothetical next token and extent to next_input_ids
lowercase :Any = ids_tensor((self.batch_size, 3) , config.vocab_size )
lowercase :Dict = tf.cast(ids_tensor((self.batch_size, 3) , 2 ) , tf.inta )
# append to next input_ids and
lowercase :Optional[Any] = tf.concat([input_ids, next_tokens] , axis=-1 )
lowercase :Optional[int] = tf.concat([attention_mask, next_attn_mask] , axis=-1 )
lowercase :Any = model(snake_case__ , attention_mask=snake_case__ )[0]
lowercase :Tuple = model(snake_case__ , attention_mask=snake_case__ , past_key_values=snake_case__ )[0]
self.parent.assertEqual(next_tokens.shape[1] , output_from_past.shape[1] )
# select random slice
lowercase :Union[str, Any] = int(ids_tensor((1,) , output_from_past.shape[-1] ) )
lowercase :Optional[int] = output_from_no_past[:, -3:, random_slice_idx]
lowercase :Any = output_from_past[:, :, random_slice_idx]
# test that outputs are equal for slice
tf.debugging.assert_near(snake_case__ , snake_case__ , rtol=1e-3 )
def lowerCamelCase (a_ :Dict , a_ :str , a_ :str , a_ :str=None , a_ :Any=None , a_ :Any=None , a_ :int=None , a_ :List[str]=None , ) -> List[str]:
if attention_mask is None:
lowercase :Tuple = tf.cast(tf.math.not_equal(a_ , config.pad_token_id) , tf.inta)
if decoder_attention_mask is None:
lowercase :Tuple = tf.concat(
[
tf.ones(decoder_input_ids[:, :1].shape , dtype=tf.inta),
tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:] , config.pad_token_id) , tf.inta),
] , axis=-1 , )
if head_mask is None:
lowercase :Tuple = tf.ones((config.encoder_layers, config.encoder_attention_heads))
if decoder_head_mask is None:
lowercase :int = tf.ones((config.decoder_layers, config.decoder_attention_heads))
if cross_attn_head_mask is None:
lowercase :int = tf.ones((config.decoder_layers, config.decoder_attention_heads))
return {
"input_ids": input_ids,
"decoder_input_ids": decoder_input_ids,
"attention_mask": attention_mask,
"decoder_attention_mask": decoder_attention_mask,
"head_mask": head_mask,
"decoder_head_mask": decoder_head_mask,
"cross_attn_head_mask": cross_attn_head_mask,
}
@require_tf
class __magic_name__ ( __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
__A : Optional[int] = (
(TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel) if is_tf_available() else ()
)
__A : Dict = (TFBlenderbotSmallForConditionalGeneration,) if is_tf_available() else ()
__A : int = (
{
"conversational": TFBlenderbotSmallForConditionalGeneration,
"feature-extraction": TFBlenderbotSmallModel,
"summarization": TFBlenderbotSmallForConditionalGeneration,
"text2text-generation": TFBlenderbotSmallForConditionalGeneration,
"translation": TFBlenderbotSmallForConditionalGeneration,
}
if is_tf_available()
else {}
)
__A : Tuple = True
__A : Optional[int] = False
__A : int = False
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = TFBlenderbotSmallModelTester(self )
lowercase :Tuple = ConfigTester(self , config_class=snake_case__ )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
self.config_tester.run_common_tests()
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :Tuple = self.model_tester.prepare_config_and_inputs_for_common()
self.model_tester.check_decoder_model_past_large_inputs(*snake_case__ )
@require_tokenizers
@require_tf
class __magic_name__ ( unittest.TestCase ):
__A : Optional[Any] = [
"Social anxiety\nWow, I am never shy. Do you have anxiety?\nYes. I end up sweating and blushing and feel like "
" i'm going to throw up.\nand why is that?"
]
__A : Tuple = "facebook/blenderbot_small-90M"
@cached_property
def __snake_case ( self : Dict ):
'''simple docstring'''
return BlenderbotSmallTokenizer.from_pretrained('''facebook/blenderbot-90M''' )
@cached_property
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :str = TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name )
return model
@slow
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :Dict = self.tokenizer(self.src_text , return_tensors='''tf''' )
lowercase :Optional[int] = self.model.generate(
model_inputs.input_ids , attention_mask=model_inputs.attention_mask , num_beams=2 , use_cache=snake_case__ , )
lowercase :List[str] = self.tokenizer.batch_decode(generated_ids.numpy() , skip_special_tokens=snake_case__ )[0]
assert generated_words in (
"i don't know. i just feel like i'm going to throw up. it's not fun.",
"i'm not sure. i just feel like i've been feeling like i have to be in a certain place",
"i'm not sure. i just feel like i've been in a bad situation.",
)
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tensorflow_text_available,
is_tf_available,
is_tokenizers_available,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_bert''': ['''BERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BertConfig''', '''BertOnnxConfig'''],
'''tokenization_bert''': ['''BasicTokenizer''', '''BertTokenizer''', '''WordpieceTokenizer'''],
}
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''BertTokenizerFast''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''BertForMaskedLM''',
'''BertForMultipleChoice''',
'''BertForNextSentencePrediction''',
'''BertForPreTraining''',
'''BertForQuestionAnswering''',
'''BertForSequenceClassification''',
'''BertForTokenClassification''',
'''BertLayer''',
'''BertLMHeadModel''',
'''BertModel''',
'''BertPreTrainedModel''',
'''load_tf_weights_in_bert''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''TFBertEmbeddings''',
'''TFBertForMaskedLM''',
'''TFBertForMultipleChoice''',
'''TFBertForNextSentencePrediction''',
'''TFBertForPreTraining''',
'''TFBertForQuestionAnswering''',
'''TFBertForSequenceClassification''',
'''TFBertForTokenClassification''',
'''TFBertLMHeadModel''',
'''TFBertMainLayer''',
'''TFBertModel''',
'''TFBertPreTrainedModel''',
]
try:
if not is_tensorflow_text_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''TFBertTokenizer''']
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxBertForCausalLM''',
'''FlaxBertForMaskedLM''',
'''FlaxBertForMultipleChoice''',
'''FlaxBertForNextSentencePrediction''',
'''FlaxBertForPreTraining''',
'''FlaxBertForQuestionAnswering''',
'''FlaxBertForSequenceClassification''',
'''FlaxBertForTokenClassification''',
'''FlaxBertModel''',
'''FlaxBertPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_bert import BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BertConfig, BertOnnxConfig
from .tokenization_bert import BasicTokenizer, BertTokenizer, WordpieceTokenizer
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_bert_fast import BertTokenizerFast
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_bert import (
BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
BertForMaskedLM,
BertForMultipleChoice,
BertForNextSentencePrediction,
BertForPreTraining,
BertForQuestionAnswering,
BertForSequenceClassification,
BertForTokenClassification,
BertLayer,
BertLMHeadModel,
BertModel,
BertPreTrainedModel,
load_tf_weights_in_bert,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_bert import (
TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
TFBertEmbeddings,
TFBertForMaskedLM,
TFBertForMultipleChoice,
TFBertForNextSentencePrediction,
TFBertForPreTraining,
TFBertForQuestionAnswering,
TFBertForSequenceClassification,
TFBertForTokenClassification,
TFBertLMHeadModel,
TFBertMainLayer,
TFBertModel,
TFBertPreTrainedModel,
)
try:
if not is_tensorflow_text_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_bert_tf import TFBertTokenizer
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_bert import (
FlaxBertForCausalLM,
FlaxBertForMaskedLM,
FlaxBertForMultipleChoice,
FlaxBertForNextSentencePrediction,
FlaxBertForPreTraining,
FlaxBertForQuestionAnswering,
FlaxBertForSequenceClassification,
FlaxBertForTokenClassification,
FlaxBertModel,
FlaxBertPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
class __magic_name__ :
def __init__( self : Optional[Any] , snake_case__ : int ):
'''simple docstring'''
lowercase :List[str] = n
lowercase :List[Any] = [None] * self.n
lowercase :Tuple = 0 # index of the first element
lowercase :Any = 0
lowercase :int = 0
def __len__( self : Tuple ):
'''simple docstring'''
return self.size
def __snake_case ( self : str ):
'''simple docstring'''
return self.size == 0
def __snake_case ( self : Any ):
'''simple docstring'''
return False if self.is_empty() else self.array[self.front]
def __snake_case ( self : Optional[int] , snake_case__ : Optional[int] ):
'''simple docstring'''
if self.size >= self.n:
raise Exception('''QUEUE IS FULL''' )
lowercase :Optional[Any] = data
lowercase :Optional[Any] = (self.rear + 1) % self.n
self.size += 1
return self
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
if self.size == 0:
raise Exception('''UNDERFLOW''' )
lowercase :Dict = self.array[self.front]
lowercase :Union[str, Any] = None
lowercase :str = (self.front + 1) % self.n
self.size -= 1
return temp
| 677 |
"""simple docstring"""
from typing import List, Optional, Union
from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
class __magic_name__ ( __UpperCAmelCase ):
__A : Tuple = ["image_processor", "tokenizer"]
__A : Dict = "BlipImageProcessor"
__A : Dict = "AutoTokenizer"
def __init__( self : Any , snake_case__ : Union[str, Any] , snake_case__ : str ):
'''simple docstring'''
lowercase :Dict = False
super().__init__(snake_case__ , snake_case__ )
lowercase :Union[str, Any] = self.image_processor
def __call__( self : Optional[int] , snake_case__ : ImageInput = None , snake_case__ : Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None , snake_case__ : bool = True , snake_case__ : Union[bool, str, PaddingStrategy] = False , snake_case__ : Union[bool, str, TruncationStrategy] = None , snake_case__ : Optional[int] = None , snake_case__ : int = 0 , snake_case__ : Optional[int] = None , snake_case__ : Optional[bool] = None , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = True , snake_case__ : Optional[Union[str, TensorType]] = None , **snake_case__ : Optional[Any] , ):
'''simple docstring'''
if images is None and text is None:
raise ValueError('''You have to specify either images or text.''' )
# Get only text
if images is None:
lowercase :List[Any] = self.tokenizer
lowercase :str = self.tokenizer(
text=snake_case__ , add_special_tokens=snake_case__ , padding=snake_case__ , truncation=snake_case__ , max_length=snake_case__ , stride=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , return_overflowing_tokens=snake_case__ , return_special_tokens_mask=snake_case__ , return_offsets_mapping=snake_case__ , return_token_type_ids=snake_case__ , return_length=snake_case__ , verbose=snake_case__ , return_tensors=snake_case__ , **snake_case__ , )
return text_encoding
# add pixel_values
lowercase :Union[str, Any] = self.image_processor(snake_case__ , return_tensors=snake_case__ )
if text is not None:
lowercase :int = self.tokenizer(
text=snake_case__ , add_special_tokens=snake_case__ , padding=snake_case__ , truncation=snake_case__ , max_length=snake_case__ , stride=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , return_overflowing_tokens=snake_case__ , return_special_tokens_mask=snake_case__ , return_offsets_mapping=snake_case__ , return_token_type_ids=snake_case__ , return_length=snake_case__ , verbose=snake_case__ , return_tensors=snake_case__ , **snake_case__ , )
else:
lowercase :Optional[int] = None
if text_encoding is not None:
encoding_image_processor.update(snake_case__ )
return encoding_image_processor
def __snake_case ( self : Tuple , *snake_case__ : List[Any] , **snake_case__ : Tuple ):
'''simple docstring'''
return self.tokenizer.batch_decode(*snake_case__ , **snake_case__ )
def __snake_case ( self : List[str] , *snake_case__ : Dict , **snake_case__ : List[Any] ):
'''simple docstring'''
return self.tokenizer.decode(*snake_case__ , **snake_case__ )
@property
# Copied from transformers.models.blip.processing_blip.BlipProcessor.model_input_names
def __snake_case ( self : List[Any] ):
'''simple docstring'''
lowercase :List[Any] = self.tokenizer.model_input_names
lowercase :List[Any] = self.image_processor.model_input_names
return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) )
| 677 | 1 |
"""simple docstring"""
from __future__ import annotations
import typing
from collections.abc import Iterable
import numpy as np
UpperCAmelCase = typing.Union[Iterable[float], Iterable[int], np.ndarray] # noqa: UP007
UpperCAmelCase = typing.Union[np.floataa, int, float] # noqa: UP007
def lowerCamelCase (a_ :Vector , a_ :Vector) -> VectorOut:
return np.sqrt(np.sum((np.asarray(a_) - np.asarray(a_)) ** 2))
def lowerCamelCase (a_ :Vector , a_ :Vector) -> VectorOut:
return sum((va - va) ** 2 for va, va in zip(a_ , a_)) ** (1 / 2)
if __name__ == "__main__":
def lowerCamelCase () -> None:
from timeit import timeit
print('''Without Numpy''')
print(
timeit(
'''euclidean_distance_no_np([1, 2, 3], [4, 5, 6])''' , number=1_0000 , globals=globals() , ))
print('''With Numpy''')
print(
timeit(
'''euclidean_distance([1, 2, 3], [4, 5, 6])''' , number=1_0000 , globals=globals() , ))
benchmark()
| 677 |
"""simple docstring"""
import subprocess
import sys
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch
class __magic_name__ ( __UpperCAmelCase ):
@require_torch
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Optional[Any] = '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
'''
lowercase :Any = '''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
'''
lowercase :Tuple = '''
import socket
def offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")
socket.socket = offline_socket
'''
# Force fetching the files so that we can use the cache
lowercase :str = '''hf-internal-testing/tiny-random-bert'''
BertConfig.from_pretrained(snake_case__ )
BertModel.from_pretrained(snake_case__ )
BertTokenizer.from_pretrained(snake_case__ )
pipeline(task='''fill-mask''' , model=snake_case__ )
# baseline - just load from_pretrained with normal network
lowercase :Union[str, Any] = [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]
# should succeed
lowercase :Any = self.get_env()
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :List[Any] = '''1'''
lowercase :List[str] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :List[str] = '''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
'''
lowercase :Dict = '''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
'''
lowercase :List[Any] = '''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")
socket.socket = offline_socket
'''
# Force fetching the files so that we can use the cache
lowercase :str = '''hf-internal-testing/tiny-random-bert'''
BertConfig.from_pretrained(snake_case__ )
BertModel.from_pretrained(snake_case__ )
BertTokenizer.from_pretrained(snake_case__ )
pipeline(task='''fill-mask''' , model=snake_case__ )
# baseline - just load from_pretrained with normal network
lowercase :List[str] = [sys.executable, '''-c''', '''\n'''.join([load, run, mock] )]
# should succeed
lowercase :str = self.get_env()
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : int ):
'''simple docstring'''
lowercase :str = '''
from transformers import BertConfig, BertModel, BertTokenizer
'''
lowercase :Union[str, Any] = '''
mname = "hf-internal-testing/tiny-random-bert-sharded"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
print("success")
'''
lowercase :Optional[int] = '''
import socket
def offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")
socket.socket = offline_socket
'''
# baseline - just load from_pretrained with normal network
lowercase :Optional[Any] = [sys.executable, '''-c''', '''\n'''.join([load, run] )]
# should succeed
lowercase :Union[str, Any] = self.get_env()
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
# next emulate no network
lowercase :Tuple = [sys.executable, '''-c''', '''\n'''.join([load, mock, run] )]
# Doesn't fail anymore since the model is in the cache due to other tests, so commenting this.
# env["TRANSFORMERS_OFFLINE"] = "0"
# result = subprocess.run(cmd, env=env, check=False, capture_output=True)
# self.assertEqual(result.returncode, 1, result.stderr)
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :Any = '''1'''
lowercase :Optional[Any] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
@require_torch
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :Dict = '''
from transformers import pipeline
'''
lowercase :Optional[Any] = '''
mname = "hf-internal-testing/tiny-random-bert"
pipe = pipeline(model=mname)
'''
lowercase :Dict = '''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")
socket.socket = offline_socket
'''
lowercase :Tuple = self.get_env()
lowercase :Optional[Any] = '''1'''
lowercase :Optional[int] = [sys.executable, '''-c''', '''\n'''.join([load, mock, run] )]
lowercase :str = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 1 , result.stderr )
self.assertIn(
'''You cannot infer task automatically within `pipeline` when using offline mode''' , result.stderr.decode().replace('''\n''' , '''''' ) , )
@require_torch
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = '''
from transformers import AutoModel
'''
lowercase :Union[str, Any] = '''
mname = "hf-internal-testing/test_dynamic_model"
AutoModel.from_pretrained(mname, trust_remote_code=True)
print("success")
'''
# baseline - just load from_pretrained with normal network
lowercase :Union[str, Any] = [sys.executable, '''-c''', '''\n'''.join([load, run] )]
# should succeed
lowercase :List[str] = self.get_env()
lowercase :Optional[int] = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
lowercase :List[Any] = '''1'''
lowercase :Tuple = subprocess.run(snake_case__ , env=snake_case__ , check=snake_case__ , capture_output=snake_case__ )
self.assertEqual(result.returncode , 0 , result.stderr )
self.assertIn('''success''' , result.stdout.decode() )
| 677 | 1 |
"""simple docstring"""
import os
import unittest
from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import (
VOCAB_FILES_NAMES,
BasicTokenizer,
BertTokenizer,
WordpieceTokenizer,
_is_control,
_is_punctuation,
_is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow
from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english
@require_tokenizers
class __magic_name__ ( __UpperCAmelCase , unittest.TestCase ):
__A : Dict = BertTokenizer
__A : Tuple = BertTokenizerFast
__A : Dict = True
__A : Optional[Any] = True
__A : Optional[Any] = filter_non_english
def __snake_case ( self : Tuple ):
'''simple docstring'''
super().setUp()
lowercase :int = [
'''[UNK]''',
'''[CLS]''',
'''[SEP]''',
'''[PAD]''',
'''[MASK]''',
'''want''',
'''##want''',
'''##ed''',
'''wa''',
'''un''',
'''runn''',
'''##ing''',
''',''',
'''low''',
'''lowest''',
]
lowercase :Union[str, Any] = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['''vocab_file'''] )
with open(self.vocab_file , '''w''' , encoding='''utf-8''' ) as vocab_writer:
vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens] ) )
def __snake_case ( self : List[Any] , snake_case__ : List[Any] ):
'''simple docstring'''
lowercase :int = '''UNwant\u00E9d,running'''
lowercase :Optional[Any] = '''unwanted, running'''
return input_text, output_text
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :List[Any] = self.tokenizer_class(self.vocab_file )
lowercase :int = tokenizer.tokenize('''UNwant\u00E9d,running''' )
self.assertListEqual(snake_case__ , ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing'''] )
self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case__ ) , [9, 6, 7, 1_2, 1_0, 1_1] )
def __snake_case ( self : List[str] ):
'''simple docstring'''
if not self.test_rust_tokenizer:
return
lowercase :int = self.get_tokenizer()
lowercase :Optional[Any] = self.get_rust_tokenizer()
lowercase :List[str] = '''UNwant\u00E9d,running'''
lowercase :Dict = tokenizer.tokenize(snake_case__ )
lowercase :List[Any] = rust_tokenizer.tokenize(snake_case__ )
self.assertListEqual(snake_case__ , snake_case__ )
lowercase :List[Any] = tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ )
lowercase :List[str] = rust_tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ )
self.assertListEqual(snake_case__ , snake_case__ )
lowercase :Any = self.get_rust_tokenizer()
lowercase :List[str] = tokenizer.encode(snake_case__ )
lowercase :List[Any] = rust_tokenizer.encode(snake_case__ )
self.assertListEqual(snake_case__ , snake_case__ )
# With lower casing
lowercase :Any = self.get_tokenizer(do_lower_case=snake_case__ )
lowercase :List[str] = self.get_rust_tokenizer(do_lower_case=snake_case__ )
lowercase :Dict = '''UNwant\u00E9d,running'''
lowercase :List[str] = tokenizer.tokenize(snake_case__ )
lowercase :Optional[int] = rust_tokenizer.tokenize(snake_case__ )
self.assertListEqual(snake_case__ , snake_case__ )
lowercase :Optional[int] = tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ )
lowercase :Any = rust_tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ )
self.assertListEqual(snake_case__ , snake_case__ )
lowercase :Tuple = self.get_rust_tokenizer()
lowercase :int = tokenizer.encode(snake_case__ )
lowercase :str = rust_tokenizer.encode(snake_case__ )
self.assertListEqual(snake_case__ , snake_case__ )
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :List[Any] = BasicTokenizer()
self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz''' ) , ['''ah''', '''\u535A''', '''\u63A8''', '''zz'''] )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :Union[str, Any] = BasicTokenizer(do_lower_case=snake_case__ )
self.assertListEqual(
tokenizer.tokenize(''' \tHeLLo!how \n Are yoU? ''' ) , ['''hello''', '''!''', '''how''', '''are''', '''you''', '''?'''] )
self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''' ) , ['''hello'''] )
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :List[str] = BasicTokenizer(do_lower_case=snake_case__ , strip_accents=snake_case__ )
self.assertListEqual(
tokenizer.tokenize(''' \tHäLLo!how \n Are yoU? ''' ) , ['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?'''] )
self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''' ) , ['''h\u00E9llo'''] )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :Any = BasicTokenizer(do_lower_case=snake_case__ , strip_accents=snake_case__ )
self.assertListEqual(
tokenizer.tokenize(''' \tHäLLo!how \n Are yoU? ''' ) , ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?'''] )
self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''' ) , ['''hello'''] )
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :int = BasicTokenizer(do_lower_case=snake_case__ )
self.assertListEqual(
tokenizer.tokenize(''' \tHäLLo!how \n Are yoU? ''' ) , ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?'''] )
self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''' ) , ['''hello'''] )
def __snake_case ( self : int ):
'''simple docstring'''
lowercase :Tuple = BasicTokenizer(do_lower_case=snake_case__ )
self.assertListEqual(
tokenizer.tokenize(''' \tHeLLo!how \n Are yoU? ''' ) , ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''] )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :List[str] = BasicTokenizer(do_lower_case=snake_case__ , strip_accents=snake_case__ )
self.assertListEqual(
tokenizer.tokenize(''' \tHäLLo!how \n Are yoU? ''' ) , ['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''] )
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :int = BasicTokenizer(do_lower_case=snake_case__ , strip_accents=snake_case__ )
self.assertListEqual(
tokenizer.tokenize(''' \tHäLLo!how \n Are yoU? ''' ) , ['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''] )
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :int = BasicTokenizer(do_lower_case=snake_case__ , never_split=['''[UNK]'''] )
self.assertListEqual(
tokenizer.tokenize(''' \tHeLLo!how \n Are yoU? [UNK]''' ) , ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]'''] )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :List[Any] = BasicTokenizer()
lowercase :Any = '''a\n\'ll !!to?\'d of, can\'t.'''
lowercase :Dict = ['''a''', '''\'''', '''ll''', '''!''', '''!''', '''to''', '''?''', '''\'''', '''d''', '''of''', ''',''', '''can''', '''\'''', '''t''', '''.''']
self.assertListEqual(tokenizer.tokenize(snake_case__ ) , snake_case__ )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :Optional[Any] = ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']
lowercase :List[Any] = {}
for i, token in enumerate(snake_case__ ):
lowercase :int = i
lowercase :str = WordpieceTokenizer(vocab=snake_case__ , unk_token='''[UNK]''' )
self.assertListEqual(tokenizer.tokenize('''''' ) , [] )
self.assertListEqual(tokenizer.tokenize('''unwanted running''' ) , ['''un''', '''##want''', '''##ed''', '''runn''', '''##ing'''] )
self.assertListEqual(tokenizer.tokenize('''unwantedX running''' ) , ['''[UNK]''', '''runn''', '''##ing'''] )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
self.assertTrue(_is_whitespace(''' ''' ) )
self.assertTrue(_is_whitespace('''\t''' ) )
self.assertTrue(_is_whitespace('''\r''' ) )
self.assertTrue(_is_whitespace('''\n''' ) )
self.assertTrue(_is_whitespace('''\u00A0''' ) )
self.assertFalse(_is_whitespace('''A''' ) )
self.assertFalse(_is_whitespace('''-''' ) )
def __snake_case ( self : Tuple ):
'''simple docstring'''
self.assertTrue(_is_control('''\u0005''' ) )
self.assertFalse(_is_control('''A''' ) )
self.assertFalse(_is_control(''' ''' ) )
self.assertFalse(_is_control('''\t''' ) )
self.assertFalse(_is_control('''\r''' ) )
def __snake_case ( self : List[str] ):
'''simple docstring'''
self.assertTrue(_is_punctuation('''-''' ) )
self.assertTrue(_is_punctuation('''$''' ) )
self.assertTrue(_is_punctuation('''`''' ) )
self.assertTrue(_is_punctuation('''.''' ) )
self.assertFalse(_is_punctuation('''A''' ) )
self.assertFalse(_is_punctuation(''' ''' ) )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :Union[str, Any] = self.get_tokenizer()
lowercase :Any = self.get_rust_tokenizer()
# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
self.assertListEqual([tokenizer.tokenize(snake_case__ ) for t in ['''Test''', '''\xad''', '''test''']] , [['''[UNK]'''], [], ['''[UNK]''']] )
self.assertListEqual(
[rust_tokenizer.tokenize(snake_case__ ) for t in ['''Test''', '''\xad''', '''test''']] , [['''[UNK]'''], [], ['''[UNK]''']] )
@slow
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :Union[str, Any] = self.tokenizer_class.from_pretrained('''bert-base-uncased''' )
lowercase :Dict = tokenizer.encode('''sequence builders''' , add_special_tokens=snake_case__ )
lowercase :Optional[int] = tokenizer.encode('''multi-sequence build''' , add_special_tokens=snake_case__ )
lowercase :Any = tokenizer.build_inputs_with_special_tokens(snake_case__ )
lowercase :Tuple = tokenizer.build_inputs_with_special_tokens(snake_case__ , snake_case__ )
assert encoded_sentence == [1_0_1] + text + [1_0_2]
assert encoded_pair == [1_0_1] + text + [1_0_2] + text_a + [1_0_2]
def __snake_case ( self : int ):
'''simple docstring'''
for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})""" ):
lowercase :Dict = self.rust_tokenizer_class.from_pretrained(snake_case__ , **snake_case__ )
lowercase :Any = f"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
lowercase :str = tokenizer_r.encode_plus(
snake_case__ , return_attention_mask=snake_case__ , return_token_type_ids=snake_case__ , return_offsets_mapping=snake_case__ , add_special_tokens=snake_case__ , )
lowercase :List[str] = tokenizer_r.do_lower_case if hasattr(snake_case__ , '''do_lower_case''' ) else False
lowercase :Any = (
[
((0, 0), tokenizer_r.cls_token),
((0, 1), '''A'''),
((1, 2), ''','''),
((3, 5), '''na'''),
((5, 6), '''##ï'''),
((6, 8), '''##ve'''),
((9, 1_5), tokenizer_r.mask_token),
((1_6, 2_1), '''Allen'''),
((2_1, 2_3), '''##NL'''),
((2_3, 2_4), '''##P'''),
((2_5, 3_3), '''sentence'''),
((3_3, 3_4), '''.'''),
((0, 0), tokenizer_r.sep_token),
]
if not do_lower_case
else [
((0, 0), tokenizer_r.cls_token),
((0, 1), '''a'''),
((1, 2), ''','''),
((3, 8), '''naive'''),
((9, 1_5), tokenizer_r.mask_token),
((1_6, 2_1), '''allen'''),
((2_1, 2_3), '''##nl'''),
((2_3, 2_4), '''##p'''),
((2_5, 3_3), '''sentence'''),
((3_3, 3_4), '''.'''),
((0, 0), tokenizer_r.sep_token),
]
)
self.assertEqual(
[e[1] for e in expected_results] , tokenizer_r.convert_ids_to_tokens(tokens['''input_ids'''] ) )
self.assertEqual([e[0] for e in expected_results] , tokens['''offset_mapping'''] )
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :Dict = ['''的''', '''人''', '''有''']
lowercase :Optional[int] = ''''''.join(snake_case__ )
for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})""" ):
lowercase :Optional[Any] = True
lowercase :int = self.tokenizer_class.from_pretrained(snake_case__ , **snake_case__ )
lowercase :str = self.rust_tokenizer_class.from_pretrained(snake_case__ , **snake_case__ )
lowercase :str = tokenizer_p.encode(snake_case__ , add_special_tokens=snake_case__ )
lowercase :List[str] = tokenizer_r.encode(snake_case__ , add_special_tokens=snake_case__ )
lowercase :Dict = tokenizer_r.convert_ids_to_tokens(snake_case__ )
lowercase :Union[str, Any] = tokenizer_p.convert_ids_to_tokens(snake_case__ )
# it is expected that each Chinese character is not preceded by "##"
self.assertListEqual(snake_case__ , snake_case__ )
self.assertListEqual(snake_case__ , snake_case__ )
lowercase :Optional[int] = False
lowercase :Optional[Any] = self.rust_tokenizer_class.from_pretrained(snake_case__ , **snake_case__ )
lowercase :Union[str, Any] = self.tokenizer_class.from_pretrained(snake_case__ , **snake_case__ )
lowercase :Optional[int] = tokenizer_r.encode(snake_case__ , add_special_tokens=snake_case__ )
lowercase :List[Any] = tokenizer_p.encode(snake_case__ , add_special_tokens=snake_case__ )
lowercase :Optional[int] = tokenizer_r.convert_ids_to_tokens(snake_case__ )
lowercase :Optional[int] = tokenizer_p.convert_ids_to_tokens(snake_case__ )
# it is expected that only the first Chinese character is not preceded by "##".
lowercase :Optional[Any] = [
f"""##{token}""" if idx != 0 else token for idx, token in enumerate(snake_case__ )
]
self.assertListEqual(snake_case__ , snake_case__ )
self.assertListEqual(snake_case__ , snake_case__ )
| 677 |
"""simple docstring"""
import argparse
import json
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from typing import List
import timm
import torch
import torch.nn as nn
from huggingface_hub import hf_hub_download
from torch import Tensor
from transformers import AutoImageProcessor, ResNetConfig, ResNetForImageClassification
from transformers.utils import logging
logging.set_verbosity_info()
UpperCAmelCase = logging.get_logger()
@dataclass
class __magic_name__ :
__A : nn.Module
__A : List[nn.Module] = field(default_factory=__UpperCAmelCase )
__A : list = field(default_factory=__UpperCAmelCase )
def __snake_case ( self : List[str] , snake_case__ : List[str] , snake_case__ : Tensor , snake_case__ : Tensor ):
'''simple docstring'''
lowercase :List[str] = len(list(m.modules() ) ) == 1 or isinstance(snake_case__ , nn.Convad ) or isinstance(snake_case__ , nn.BatchNormad )
if has_not_submodules:
self.traced.append(snake_case__ )
def __call__( self : int , snake_case__ : Tensor ):
'''simple docstring'''
for m in self.module.modules():
self.handles.append(m.register_forward_hook(self._forward_hook ) )
self.module(snake_case__ )
[x.remove() for x in self.handles]
return self
@property
def __snake_case ( self : int ):
'''simple docstring'''
return list(filter(lambda snake_case__ : len(list(x.state_dict().keys() ) ) > 0 , self.traced ) )
@dataclass
class __magic_name__ :
__A : nn.Module
__A : nn.Module
__A : int = 0
__A : List = field(default_factory=__UpperCAmelCase )
__A : List = field(default_factory=__UpperCAmelCase )
def __call__( self : Dict , snake_case__ : Tensor ):
'''simple docstring'''
lowercase :Dict = Tracker(self.dest )(snake_case__ ).parametrized
lowercase :Optional[Any] = Tracker(self.src )(snake_case__ ).parametrized
lowercase :List[str] = list(filter(lambda snake_case__ : type(snake_case__ ) not in self.src_skip , snake_case__ ) )
lowercase :Tuple = list(filter(lambda snake_case__ : type(snake_case__ ) not in self.dest_skip , snake_case__ ) )
if len(snake_case__ ) != len(snake_case__ ):
raise Exception(
f"""Numbers of operations are different. Source module has {len(snake_case__ )} operations while"""
f""" destination module has {len(snake_case__ )}.""" )
for dest_m, src_m in zip(snake_case__ , snake_case__ ):
dest_m.load_state_dict(src_m.state_dict() )
if self.verbose == 1:
print(f"""Transfered from={src_m} to={dest_m}""" )
def lowerCamelCase (a_ :str , a_ :ResNetConfig , a_ :Path , a_ :bool = True) -> Optional[Any]:
print(F"""Converting {name}...""")
with torch.no_grad():
lowercase :Union[str, Any] = timm.create_model(a_ , pretrained=a_).eval()
lowercase :Tuple = ResNetForImageClassification(a_).eval()
lowercase :int = ModuleTransfer(src=a_ , dest=a_)
lowercase :List[Any] = torch.randn((1, 3, 224, 224))
module_transfer(a_)
assert torch.allclose(from_model(a_) , our_model(a_).logits), "The model logits don't match the original one."
lowercase :List[Any] = F"""resnet{'-'.join(name.split('resnet'))}"""
print(a_)
if push_to_hub:
our_model.push_to_hub(
repo_path_or_name=save_directory / checkpoint_name , commit_message='''Add model''' , use_temp_dir=a_ , )
# we can use the convnext one
lowercase :Any = AutoImageProcessor.from_pretrained('''facebook/convnext-base-224-22k-1k''')
image_processor.push_to_hub(
repo_path_or_name=save_directory / checkpoint_name , commit_message='''Add image processor''' , use_temp_dir=a_ , )
print(F"""Pushed {checkpoint_name}""")
def lowerCamelCase (a_ :Path , a_ :str = None , a_ :bool = True) -> int:
lowercase :Optional[Any] = '''imagenet-1k-id2label.json'''
lowercase :Union[str, Any] = 1000
lowercase :Any = (1, num_labels)
lowercase :Tuple = '''huggingface/label-files'''
lowercase :List[str] = num_labels
lowercase :Union[str, Any] = json.load(open(hf_hub_download(a_ , a_ , repo_type='''dataset''') , '''r'''))
lowercase :Any = {int(a_): v for k, v in idalabel.items()}
lowercase :str = idalabel
lowercase :Any = {v: k for k, v in idalabel.items()}
lowercase :Union[str, Any] = partial(a_ , num_labels=a_ , idalabel=a_ , labelaid=a_)
lowercase :Optional[int] = {
'''resnet18''': ImageNetPreTrainedConfig(
depths=[2, 2, 2, 2] , hidden_sizes=[64, 128, 256, 512] , layer_type='''basic'''),
'''resnet26''': ImageNetPreTrainedConfig(
depths=[2, 2, 2, 2] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet34''': ImageNetPreTrainedConfig(
depths=[3, 4, 6, 3] , hidden_sizes=[64, 128, 256, 512] , layer_type='''basic'''),
'''resnet50''': ImageNetPreTrainedConfig(
depths=[3, 4, 6, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet101''': ImageNetPreTrainedConfig(
depths=[3, 4, 23, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
'''resnet152''': ImageNetPreTrainedConfig(
depths=[3, 8, 36, 3] , hidden_sizes=[256, 512, 1024, 2048] , layer_type='''bottleneck'''),
}
if model_name:
convert_weight_and_push(a_ , names_to_config[model_name] , a_ , a_)
else:
for model_name, config in names_to_config.items():
convert_weight_and_push(a_ , a_ , a_ , a_)
return config, expected_shape
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'''--model_name''',
default=None,
type=str,
help=(
'''The name of the model you wish to convert, it must be one of the supported resnet* architecture,'''
''' currently: resnet18,26,34,50,101,152. If `None`, all of them will the converted.'''
),
)
parser.add_argument(
'''--pytorch_dump_folder_path''',
default=None,
type=Path,
required=True,
help='''Path to the output PyTorch model directory.''',
)
parser.add_argument(
'''--push_to_hub''',
default=True,
type=bool,
required=False,
help='''If True, push model and image processor to the hub.''',
)
UpperCAmelCase = parser.parse_args()
UpperCAmelCase = args.pytorch_dump_folder_path
pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
| 677 | 1 |
"""simple docstring"""
import os
from huggingface_hub.constants import HUGGINGFACE_HUB_CACHE, hf_cache_home
UpperCAmelCase = HUGGINGFACE_HUB_CACHE
UpperCAmelCase = '''config.json'''
UpperCAmelCase = '''diffusion_pytorch_model.bin'''
UpperCAmelCase = '''diffusion_flax_model.msgpack'''
UpperCAmelCase = '''model.onnx'''
UpperCAmelCase = '''diffusion_pytorch_model.safetensors'''
UpperCAmelCase = '''weights.pb'''
UpperCAmelCase = '''https://huggingface.co'''
UpperCAmelCase = default_cache_path
UpperCAmelCase = '''diffusers_modules'''
UpperCAmelCase = os.getenv('''HF_MODULES_CACHE''', os.path.join(hf_cache_home, '''modules'''))
UpperCAmelCase = ['''fp16''', '''non-ema''']
UpperCAmelCase = '''.self_attn'''
| 677 |
"""simple docstring"""
from __future__ import annotations
import unittest
from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin
if is_tf_available():
import tensorflow as tf
from transformers import (
TF_MODEL_FOR_PRETRAINING_MAPPING,
TFMobileBertForMaskedLM,
TFMobileBertForMultipleChoice,
TFMobileBertForNextSentencePrediction,
TFMobileBertForPreTraining,
TFMobileBertForQuestionAnswering,
TFMobileBertForSequenceClassification,
TFMobileBertForTokenClassification,
TFMobileBertModel,
)
@require_tf
class __magic_name__ ( __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
__A : Any = (
(
TFMobileBertModel,
TFMobileBertForMaskedLM,
TFMobileBertForNextSentencePrediction,
TFMobileBertForPreTraining,
TFMobileBertForQuestionAnswering,
TFMobileBertForSequenceClassification,
TFMobileBertForTokenClassification,
TFMobileBertForMultipleChoice,
)
if is_tf_available()
else ()
)
__A : List[Any] = (
{
"feature-extraction": TFMobileBertModel,
"fill-mask": TFMobileBertForMaskedLM,
"question-answering": TFMobileBertForQuestionAnswering,
"text-classification": TFMobileBertForSequenceClassification,
"token-classification": TFMobileBertForTokenClassification,
"zero-shot": TFMobileBertForSequenceClassification,
}
if is_tf_available()
else {}
)
__A : List[str] = False
__A : int = False
def __snake_case ( self : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Any , snake_case__ : int=False ):
'''simple docstring'''
lowercase :Union[str, Any] = super()._prepare_for_class(snake_case__ , snake_case__ , return_labels=snake_case__ )
if return_labels:
if model_class in get_values(snake_case__ ):
lowercase :Tuple = tf.zeros(self.model_tester.batch_size , dtype=tf.intaa )
return inputs_dict
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Any , snake_case__ : Dict , snake_case__ : Dict=1_3 , snake_case__ : Tuple=7 , snake_case__ : Optional[Any]=True , snake_case__ : Union[str, Any]=True , snake_case__ : str=True , snake_case__ : Optional[Any]=True , snake_case__ : Any=9_9 , snake_case__ : Optional[Any]=3_2 , snake_case__ : Optional[Any]=3_2 , snake_case__ : Any=2 , snake_case__ : Optional[int]=4 , snake_case__ : List[Any]=3_7 , snake_case__ : Optional[int]="gelu" , snake_case__ : List[Any]=0.1 , snake_case__ : str=0.1 , snake_case__ : List[Any]=5_1_2 , snake_case__ : List[str]=1_6 , snake_case__ : Union[str, Any]=2 , snake_case__ : Optional[Any]=0.02 , snake_case__ : Optional[Any]=3 , snake_case__ : Dict=4 , snake_case__ : int=None , ):
'''simple docstring'''
lowercase :Tuple = parent
lowercase :Tuple = batch_size
lowercase :Optional[Any] = seq_length
lowercase :Optional[Any] = is_training
lowercase :Optional[Any] = use_input_mask
lowercase :List[Any] = use_token_type_ids
lowercase :str = use_labels
lowercase :List[str] = vocab_size
lowercase :str = hidden_size
lowercase :Optional[int] = num_hidden_layers
lowercase :Dict = num_attention_heads
lowercase :Any = intermediate_size
lowercase :List[str] = hidden_act
lowercase :Optional[Any] = hidden_dropout_prob
lowercase :List[Any] = attention_probs_dropout_prob
lowercase :List[Any] = max_position_embeddings
lowercase :List[Any] = type_vocab_size
lowercase :Union[str, Any] = type_sequence_label_size
lowercase :Union[str, Any] = initializer_range
lowercase :Any = num_labels
lowercase :int = num_choices
lowercase :Dict = scope
lowercase :Dict = embedding_size
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :Optional[int] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size )
lowercase :int = None
if self.use_input_mask:
lowercase :int = random_attention_mask([self.batch_size, self.seq_length] )
lowercase :Tuple = None
if self.use_token_type_ids:
lowercase :int = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size )
lowercase :Union[str, Any] = None
lowercase :int = None
lowercase :str = None
if self.use_labels:
lowercase :int = ids_tensor([self.batch_size] , self.type_sequence_label_size )
lowercase :str = ids_tensor([self.batch_size, self.seq_length] , self.num_labels )
lowercase :Dict = ids_tensor([self.batch_size] , self.num_choices )
lowercase :Optional[int] = MobileBertConfig(
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 , embedding_size=self.embedding_size , )
return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
def __snake_case ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Any , snake_case__ : Tuple , snake_case__ : Tuple ):
'''simple docstring'''
lowercase :Dict = TFMobileBertModel(config=snake_case__ )
lowercase :Union[str, Any] = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
lowercase :Optional[int] = [input_ids, input_mask]
lowercase :Optional[int] = model(snake_case__ )
lowercase :Union[str, Any] = model(snake_case__ )
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 : List[Any] , snake_case__ : Dict , snake_case__ : Optional[int] , snake_case__ : int , snake_case__ : str , snake_case__ : Dict , snake_case__ : Tuple , snake_case__ : Optional[int] ):
'''simple docstring'''
lowercase :Any = TFMobileBertForMaskedLM(config=snake_case__ )
lowercase :Any = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :int = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) )
def __snake_case ( self : Tuple , snake_case__ : Any , snake_case__ : Optional[Any] , snake_case__ : List[Any] , snake_case__ : Dict , snake_case__ : str , snake_case__ : List[Any] , snake_case__ : Tuple ):
'''simple docstring'''
lowercase :Optional[Any] = TFMobileBertForNextSentencePrediction(config=snake_case__ )
lowercase :Tuple = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :Optional[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, 2) )
def __snake_case ( self : Dict , snake_case__ : Optional[Any] , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : Optional[int] , snake_case__ : int , snake_case__ : Union[str, Any] , snake_case__ : Dict ):
'''simple docstring'''
lowercase :int = TFMobileBertForPreTraining(config=snake_case__ )
lowercase :Any = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
self.parent.assertEqual(
result.prediction_logits.shape , (self.batch_size, self.seq_length, self.vocab_size) )
self.parent.assertEqual(result.seq_relationship_logits.shape , (self.batch_size, 2) )
def __snake_case ( self : Optional[Any] , snake_case__ : Tuple , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Optional[Any] , snake_case__ : List[str] , snake_case__ : Dict , snake_case__ : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = self.num_labels
lowercase :List[Any] = TFMobileBertForSequenceClassification(config=snake_case__ )
lowercase :Dict = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :List[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def __snake_case ( self : Any , snake_case__ : Optional[int] , snake_case__ : Tuple , snake_case__ : Union[str, Any] , snake_case__ : List[Any] , snake_case__ : List[Any] , snake_case__ : List[Any] , snake_case__ : Optional[Any] ):
'''simple docstring'''
lowercase :Tuple = self.num_choices
lowercase :Any = TFMobileBertForMultipleChoice(config=snake_case__ )
lowercase :Any = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :Union[str, Any] = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :List[Any] = tf.tile(tf.expand_dims(snake_case__ , 1 ) , (1, self.num_choices, 1) )
lowercase :Dict = {
'''input_ids''': multiple_choice_inputs_ids,
'''attention_mask''': multiple_choice_input_mask,
'''token_type_ids''': multiple_choice_token_type_ids,
}
lowercase :Optional[Any] = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) )
def __snake_case ( self : Any , snake_case__ : str , snake_case__ : Tuple , snake_case__ : int , snake_case__ : Tuple , snake_case__ : Dict , snake_case__ : Optional[Any] , snake_case__ : Dict ):
'''simple docstring'''
lowercase :List[Any] = self.num_labels
lowercase :List[str] = TFMobileBertForTokenClassification(config=snake_case__ )
lowercase :int = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :int = model(snake_case__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) )
def __snake_case ( self : List[str] , snake_case__ : List[Any] , snake_case__ : Optional[int] , snake_case__ : Optional[int] , snake_case__ : List[Any] , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : str ):
'''simple docstring'''
lowercase :Union[str, Any] = TFMobileBertForQuestionAnswering(config=snake_case__ )
lowercase :List[Any] = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
lowercase :str = model(snake_case__ )
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 : List[Any] ):
'''simple docstring'''
lowercase :Dict = self.prepare_config_and_inputs()
(
(
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) , (
lowercase
) ,
) :Dict = config_and_inputs
lowercase :Optional[Any] = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
return config, inputs_dict
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :List[Any] = TFMobileBertModelTest.TFMobileBertModelTester(self )
lowercase :List[str] = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 )
def __snake_case ( self : List[Any] ):
'''simple docstring'''
self.config_tester.run_common_tests()
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :List[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_model(*snake_case__ )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :List[str] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_masked_lm(*snake_case__ )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :str = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_multiple_choice(*snake_case__ )
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :Tuple = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*snake_case__ )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :int = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_pretraining(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Tuple = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_question_answering(*snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Optional[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_sequence_classification(*snake_case__ )
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_mobilebert_for_token_classification(*snake_case__ )
@slow
def __snake_case ( self : int ):
'''simple docstring'''
for model_name in ["google/mobilebert-uncased"]:
lowercase :List[str] = TFMobileBertModel.from_pretrained(snake_case__ )
self.assertIsNotNone(snake_case__ )
@require_tf
class __magic_name__ ( unittest.TestCase ):
@slow
def __snake_case ( self : Tuple ):
'''simple docstring'''
lowercase :int = TFMobileBertForPreTraining.from_pretrained('''google/mobilebert-uncased''' )
lowercase :Optional[Any] = tf.constant([[0, 1, 2, 3, 4, 5]] )
lowercase :List[Any] = model(snake_case__ )[0]
lowercase :Union[str, Any] = [1, 6, 3_0_5_2_2]
self.assertEqual(output.shape , snake_case__ )
lowercase :Optional[int] = tf.constant(
[
[
[-4.5_91_95_47, -9.24_82_95, -9.64_52_56],
[-6.7_30_61_75, -6.44_02_84, -6.6_05_28_37],
[-7.2_74_35_06, -6.7_84_79_15, -6.02_46_73],
]
] )
tf.debugging.assert_near(output[:, :3, :3] , snake_case__ , atol=1e-4 )
| 677 | 1 |
"""simple docstring"""
def lowerCamelCase (a_ :int) -> int:
lowercase :Dict = 1
for i in range(1 , num + 1):
fact *= i
return fact
def lowerCamelCase (a_ :int) -> int:
lowercase :Any = 0
while number > 0:
lowercase :str = number % 10
sum_of_digits += last_digit
lowercase :List[Any] = number // 10 # Removing the last_digit from the given number
return sum_of_digits
def lowerCamelCase (a_ :int = 100) -> int:
lowercase :int = factorial(a_)
lowercase :Dict = split_and_add(a_)
return result
if __name__ == "__main__":
print(solution(int(input('''Enter the Number: ''').strip())))
| 677 |
"""simple docstring"""
import contextlib
import copy
import random
from typing import Any, Dict, Iterable, Optional, Union
import numpy as np
import torch
from .utils import deprecate, is_transformers_available
if is_transformers_available():
import transformers
def lowerCamelCase (a_ :int) -> List[str]:
random.seed(a_)
np.random.seed(a_)
torch.manual_seed(a_)
torch.cuda.manual_seed_all(a_)
# ^^ safe to call this function even if cuda is not available
class __magic_name__ :
def __init__( self : Optional[Any] , snake_case__ : Iterable[torch.nn.Parameter] , snake_case__ : float = 0.99_99 , snake_case__ : float = 0.0 , snake_case__ : int = 0 , snake_case__ : bool = False , snake_case__ : Union[float, int] = 1.0 , snake_case__ : Union[float, int] = 2 / 3 , snake_case__ : Optional[Any] = None , snake_case__ : Dict[str, Any] = None , **snake_case__ : Tuple , ):
'''simple docstring'''
if isinstance(snake_case__ , torch.nn.Module ):
lowercase :int = (
'''Passing a `torch.nn.Module` to `ExponentialMovingAverage` is deprecated. '''
'''Please pass the parameters of the module instead.'''
)
deprecate(
'''passing a `torch.nn.Module` to `ExponentialMovingAverage`''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ , )
lowercase :Dict = parameters.parameters()
# set use_ema_warmup to True if a torch.nn.Module is passed for backwards compatibility
lowercase :Optional[Any] = True
if kwargs.get('''max_value''' , snake_case__ ) is not None:
lowercase :Optional[Any] = '''The `max_value` argument is deprecated. Please use `decay` instead.'''
deprecate('''max_value''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
lowercase :Optional[int] = kwargs['''max_value''']
if kwargs.get('''min_value''' , snake_case__ ) is not None:
lowercase :List[Any] = '''The `min_value` argument is deprecated. Please use `min_decay` instead.'''
deprecate('''min_value''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
lowercase :str = kwargs['''min_value''']
lowercase :Any = list(snake_case__ )
lowercase :Optional[Any] = [p.clone().detach() for p in parameters]
if kwargs.get('''device''' , snake_case__ ) is not None:
lowercase :str = '''The `device` argument is deprecated. Please use `to` instead.'''
deprecate('''device''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ )
self.to(device=kwargs['''device'''] )
lowercase :int = None
lowercase :int = decay
lowercase :Union[str, Any] = min_decay
lowercase :List[Any] = update_after_step
lowercase :Union[str, Any] = use_ema_warmup
lowercase :Any = inv_gamma
lowercase :Any = power
lowercase :str = 0
lowercase :int = None # set in `step()`
lowercase :List[str] = model_cls
lowercase :Any = model_config
@classmethod
def __snake_case ( cls : int , snake_case__ : Tuple , snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase , lowercase :int = model_cls.load_config(snake_case__ , return_unused_kwargs=snake_case__ )
lowercase :List[Any] = model_cls.from_pretrained(snake_case__ )
lowercase :Optional[int] = cls(model.parameters() , model_cls=snake_case__ , model_config=model.config )
ema_model.load_state_dict(snake_case__ )
return ema_model
def __snake_case ( self : int , snake_case__ : Union[str, Any] ):
'''simple docstring'''
if self.model_cls is None:
raise ValueError('''`save_pretrained` can only be used if `model_cls` was defined at __init__.''' )
if self.model_config is None:
raise ValueError('''`save_pretrained` can only be used if `model_config` was defined at __init__.''' )
lowercase :Dict = self.model_cls.from_config(self.model_config )
lowercase :Tuple = self.state_dict()
state_dict.pop('''shadow_params''' , snake_case__ )
model.register_to_config(**snake_case__ )
self.copy_to(model.parameters() )
model.save_pretrained(snake_case__ )
def __snake_case ( self : int , snake_case__ : int ):
'''simple docstring'''
lowercase :Union[str, Any] = max(0 , optimization_step - self.update_after_step - 1 )
if step <= 0:
return 0.0
if self.use_ema_warmup:
lowercase :int = 1 - (1 + step / self.inv_gamma) ** -self.power
else:
lowercase :Dict = (1 + step) / (1_0 + step)
lowercase :Optional[int] = min(snake_case__ , self.decay )
# make sure decay is not smaller than min_decay
lowercase :Optional[int] = max(snake_case__ , self.min_decay )
return cur_decay_value
@torch.no_grad()
def __snake_case ( self : Any , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
if isinstance(snake_case__ , torch.nn.Module ):
lowercase :Tuple = (
'''Passing a `torch.nn.Module` to `ExponentialMovingAverage.step` is deprecated. '''
'''Please pass the parameters of the module instead.'''
)
deprecate(
'''passing a `torch.nn.Module` to `ExponentialMovingAverage.step`''' , '''1.0.0''' , snake_case__ , standard_warn=snake_case__ , )
lowercase :Union[str, Any] = parameters.parameters()
lowercase :Optional[Any] = list(snake_case__ )
self.optimization_step += 1
# Compute the decay factor for the exponential moving average.
lowercase :List[Any] = self.get_decay(self.optimization_step )
lowercase :Optional[Any] = decay
lowercase :List[Any] = 1 - decay
lowercase :List[str] = contextlib.nullcontext
if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
import deepspeed
for s_param, param in zip(self.shadow_params , snake_case__ ):
if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
lowercase :Union[str, Any] = deepspeed.zero.GatheredParameters(snake_case__ , modifier_rank=snake_case__ )
with context_manager():
if param.requires_grad:
s_param.sub_(one_minus_decay * (s_param - param) )
else:
s_param.copy_(snake_case__ )
def __snake_case ( self : str , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
lowercase :Optional[Any] = list(snake_case__ )
for s_param, param in zip(self.shadow_params , snake_case__ ):
param.data.copy_(s_param.to(param.device ).data )
def __snake_case ( self : Optional[int] , snake_case__ : Dict=None , snake_case__ : Dict=None ):
'''simple docstring'''
lowercase :str = [
p.to(device=snake_case__ , dtype=snake_case__ ) if p.is_floating_point() else p.to(device=snake_case__ )
for p in self.shadow_params
]
def __snake_case ( self : Dict ):
'''simple docstring'''
return {
"decay": self.decay,
"min_decay": self.min_decay,
"optimization_step": self.optimization_step,
"update_after_step": self.update_after_step,
"use_ema_warmup": self.use_ema_warmup,
"inv_gamma": self.inv_gamma,
"power": self.power,
"shadow_params": self.shadow_params,
}
def __snake_case ( self : Optional[int] , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
lowercase :str = [param.detach().cpu().clone() for param in parameters]
def __snake_case ( self : List[Any] , snake_case__ : Iterable[torch.nn.Parameter] ):
'''simple docstring'''
if self.temp_stored_params is None:
raise RuntimeError('''This ExponentialMovingAverage has no `store()`ed weights ''' '''to `restore()`''' )
for c_param, param in zip(self.temp_stored_params , snake_case__ ):
param.data.copy_(c_param.data )
# Better memory-wise.
lowercase :Dict = None
def __snake_case ( self : Union[str, Any] , snake_case__ : dict ):
'''simple docstring'''
lowercase :List[str] = copy.deepcopy(snake_case__ )
lowercase :Any = state_dict.get('''decay''' , self.decay )
if self.decay < 0.0 or self.decay > 1.0:
raise ValueError('''Decay must be between 0 and 1''' )
lowercase :int = state_dict.get('''min_decay''' , self.min_decay )
if not isinstance(self.min_decay , snake_case__ ):
raise ValueError('''Invalid min_decay''' )
lowercase :List[Any] = state_dict.get('''optimization_step''' , self.optimization_step )
if not isinstance(self.optimization_step , snake_case__ ):
raise ValueError('''Invalid optimization_step''' )
lowercase :int = state_dict.get('''update_after_step''' , self.update_after_step )
if not isinstance(self.update_after_step , snake_case__ ):
raise ValueError('''Invalid update_after_step''' )
lowercase :Optional[int] = state_dict.get('''use_ema_warmup''' , self.use_ema_warmup )
if not isinstance(self.use_ema_warmup , snake_case__ ):
raise ValueError('''Invalid use_ema_warmup''' )
lowercase :Any = state_dict.get('''inv_gamma''' , self.inv_gamma )
if not isinstance(self.inv_gamma , (float, int) ):
raise ValueError('''Invalid inv_gamma''' )
lowercase :Dict = state_dict.get('''power''' , self.power )
if not isinstance(self.power , (float, int) ):
raise ValueError('''Invalid power''' )
lowercase :Optional[int] = state_dict.get('''shadow_params''' , snake_case__ )
if shadow_params is not None:
lowercase :List[Any] = shadow_params
if not isinstance(self.shadow_params , snake_case__ ):
raise ValueError('''shadow_params must be a list''' )
if not all(isinstance(snake_case__ , torch.Tensor ) for p in self.shadow_params ):
raise ValueError('''shadow_params must all be Tensors''' )
| 677 | 1 |
"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''transfo-xl-wt103''': '''https://huggingface.co/transfo-xl-wt103/resolve/main/config.json''',
}
class __magic_name__ ( __UpperCAmelCase ):
__A : List[Any] = "transfo-xl"
__A : str = ["mems"]
__A : int = {
"n_token": "vocab_size",
"hidden_size": "d_model",
"num_attention_heads": "n_head",
"num_hidden_layers": "n_layer",
}
def __init__( self : int , snake_case__ : Optional[int]=2_6_7_7_3_5 , snake_case__ : str=[2_0_0_0_0, 4_0_0_0_0, 2_0_0_0_0_0] , snake_case__ : Optional[int]=1_0_2_4 , snake_case__ : Union[str, Any]=1_0_2_4 , snake_case__ : List[str]=1_6 , snake_case__ : Optional[Any]=6_4 , snake_case__ : Union[str, Any]=4_0_9_6 , snake_case__ : List[Any]=4 , snake_case__ : int=False , snake_case__ : Dict=1_8 , snake_case__ : str=1_6_0_0 , snake_case__ : Tuple=1_0_0_0 , snake_case__ : Optional[int]=True , snake_case__ : Optional[Any]=True , snake_case__ : Tuple=0 , snake_case__ : Union[str, Any]=-1 , snake_case__ : Union[str, Any]=True , snake_case__ : Optional[int]=0.1 , snake_case__ : List[str]=0.0 , snake_case__ : int=True , snake_case__ : int="normal" , snake_case__ : str=0.01 , snake_case__ : List[str]=0.01 , snake_case__ : str=0.02 , snake_case__ : List[str]=1e-5 , snake_case__ : List[Any]=0 , **snake_case__ : Any , ):
'''simple docstring'''
lowercase :Optional[Any] = vocab_size
lowercase :Optional[Any] = []
self.cutoffs.extend(snake_case__ )
if proj_share_all_but_first:
lowercase :Union[str, Any] = [False] + [True] * len(self.cutoffs )
else:
lowercase :Optional[Any] = [False] + [False] * len(self.cutoffs )
lowercase :str = d_model
lowercase :str = d_embed
lowercase :Dict = d_head
lowercase :str = d_inner
lowercase :Optional[Any] = div_val
lowercase :str = pre_lnorm
lowercase :Optional[int] = n_layer
lowercase :Dict = n_head
lowercase :int = mem_len
lowercase :Dict = same_length
lowercase :str = attn_type
lowercase :List[Any] = clamp_len
lowercase :List[Any] = sample_softmax
lowercase :List[str] = adaptive
lowercase :Union[str, Any] = dropout
lowercase :Optional[int] = dropatt
lowercase :Union[str, Any] = untie_r
lowercase :List[str] = init
lowercase :Optional[Any] = init_range
lowercase :str = proj_init_std
lowercase :List[Any] = init_std
lowercase :Optional[Any] = layer_norm_epsilon
super().__init__(eos_token_id=snake_case__ , **snake_case__ )
@property
def __snake_case ( self : List[Any] ):
'''simple docstring'''
logger.info(f"""The model {self.model_type} is one of the few models that has no sequence length limit.""" )
return -1
@max_position_embeddings.setter
def __snake_case ( self : Optional[int] , snake_case__ : Dict ):
'''simple docstring'''
raise NotImplementedError(
f"""The model {self.model_type} is one of the few models that has no sequence length limit.""" )
| 677 |
"""simple docstring"""
import argparse
import collections
import numpy as np
import torch
from flax import traverse_util
from tax import checkpoints
from transformers import MTaConfig, UMTaEncoderModel, UMTaForConditionalGeneration
from transformers.utils import logging
logging.set_verbosity_info()
def lowerCamelCase (a_ :int , a_ :Union[str, Any] , a_ :List[Any]) -> List[str]:
return params[F"""{prefix}/{prefix}/relpos_bias/rel_embedding"""][:, i, :]
def lowerCamelCase (a_ :Optional[Any] , a_ :Optional[int] , a_ :str , a_ :Any="attention") -> Optional[int]:
lowercase :Tuple = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/key/kernel"""][:, i, :, :])
lowercase :int = k_tmp.reshape(k_tmp.shape[0] , k_tmp.shape[1] * k_tmp.shape[2])
lowercase :str = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/out/kernel"""][:, i, :, :])
lowercase :Any = o_tmp.reshape(o_tmp.shape[0] * o_tmp.shape[1] , o_tmp.shape[2])
lowercase :int = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/query/kernel"""][:, i, :, :])
lowercase :List[str] = q_tmp.reshape(q_tmp.shape[0] , q_tmp.shape[1] * q_tmp.shape[2])
lowercase :List[Any] = np.ascontiguousarray(params[F"""{prefix}/{prefix}/{layer_name}/value/kernel"""][:, i, :, :])
lowercase :Optional[int] = v_tmp.reshape(v_tmp.shape[0] , v_tmp.shape[1] * v_tmp.shape[2])
return k, o, q, v
def lowerCamelCase (a_ :Any , a_ :Union[str, Any] , a_ :Union[str, Any] , a_ :Union[str, Any]=False) -> List[Any]:
if split_mlp_wi:
lowercase :List[Any] = params[F"""{prefix}/{prefix}/mlp/wi_0/kernel"""][:, i, :]
lowercase :Optional[int] = params[F"""{prefix}/{prefix}/mlp/wi_1/kernel"""][:, i, :]
lowercase :Dict = (wi_a, wi_a)
else:
lowercase :Optional[Any] = params[F"""{prefix}/{prefix}/mlp/wi/kernel"""][:, i, :]
lowercase :Union[str, Any] = params[F"""{prefix}/{prefix}/mlp/wo/kernel"""][:, i, :]
return wi, wo
def lowerCamelCase (a_ :Any , a_ :Optional[Any] , a_ :Optional[Any] , a_ :Union[str, Any]) -> Optional[Any]:
return params[F"""{prefix}/{prefix}/{layer_name}/scale"""][:, i]
def lowerCamelCase (a_ :dict , *, a_ :int , a_ :bool , a_ :bool = False) -> int:
lowercase :Dict = traverse_util.flatten_dict(variables['''target'''])
lowercase :Optional[Any] = {'''/'''.join(a_): v for k, v in old.items()}
# v1.1 models have a gated GeLU with wi_0 and wi_1 instead of wi
lowercase :str = '''encoder/encoder/mlp/wi_0/kernel''' in old
print('''Split MLP:''' , a_)
lowercase :str = collections.OrderedDict()
# Shared embeddings.
lowercase :int = old['''token_embedder/embedding''']
# Encoder.
for i in range(a_):
# Block i, layer 0 (Self Attention).
lowercase :Union[str, Any] = tax_layer_norm_lookup(a_ , a_ , '''encoder''' , '''pre_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :Tuple = tax_attention_lookup(a_ , a_ , '''encoder''' , '''attention''')
lowercase :Dict = layer_norm
lowercase :Dict = k.T
lowercase :Union[str, Any] = o.T
lowercase :List[Any] = q.T
lowercase :int = v.T
# Block i, layer 1 (MLP).
lowercase :Optional[int] = tax_layer_norm_lookup(a_ , a_ , '''encoder''' , '''pre_mlp_layer_norm''')
lowercase , lowercase :str = tax_mlp_lookup(a_ , a_ , '''encoder''' , a_)
lowercase :int = layer_norm
if split_mlp_wi:
lowercase :Tuple = wi[0].T
lowercase :Tuple = wi[1].T
else:
lowercase :int = wi.T
lowercase :Tuple = wo.T
if scalable_attention:
# convert the rel_embedding of each layer
lowercase :Dict = tax_relpos_bias_lookup(
a_ , a_ , '''encoder''').T
lowercase :str = old['''encoder/encoder_norm/scale''']
if not scalable_attention:
lowercase :str = tax_relpos_bias_lookup(
a_ , 0 , '''encoder''').T
lowercase :List[Any] = tax_relpos_bias_lookup(
a_ , 0 , '''decoder''').T
if not is_encoder_only:
# Decoder.
for i in range(a_):
# Block i, layer 0 (Self Attention).
lowercase :Any = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_self_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :str = tax_attention_lookup(a_ , a_ , '''decoder''' , '''self_attention''')
lowercase :List[str] = layer_norm
lowercase :Dict = k.T
lowercase :List[Any] = o.T
lowercase :List[Any] = q.T
lowercase :Any = v.T
# Block i, layer 1 (Cross Attention).
lowercase :Tuple = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_cross_attention_layer_norm''')
lowercase , lowercase , lowercase , lowercase :int = tax_attention_lookup(a_ , a_ , '''decoder''' , '''encoder_decoder_attention''')
lowercase :int = layer_norm
lowercase :Dict = k.T
lowercase :int = o.T
lowercase :List[Any] = q.T
lowercase :Tuple = v.T
# Block i, layer 2 (MLP).
lowercase :Any = tax_layer_norm_lookup(a_ , a_ , '''decoder''' , '''pre_mlp_layer_norm''')
lowercase , lowercase :Tuple = tax_mlp_lookup(a_ , a_ , '''decoder''' , a_)
lowercase :Any = layer_norm
if split_mlp_wi:
lowercase :int = wi[0].T
lowercase :Union[str, Any] = wi[1].T
else:
lowercase :int = wi.T
lowercase :List[Any] = wo.T
if scalable_attention:
# convert the rel_embedding of each layer
lowercase :Union[str, Any] = tax_relpos_bias_lookup(a_ , a_ , '''decoder''').T
lowercase :Union[str, Any] = old['''decoder/decoder_norm/scale''']
# LM Head (only in v1.1 checkpoints, in v1.0 embeddings are used instead)
if "decoder/logits_dense/kernel" in old:
lowercase :int = old['''decoder/logits_dense/kernel'''].T
return new
def lowerCamelCase (a_ :Dict , a_ :bool) -> Tuple:
lowercase :str = collections.OrderedDict([(k, torch.from_numpy(v.copy())) for (k, v) in converted_params.items()])
# Add what is missing.
if "encoder.embed_tokens.weight" not in state_dict:
lowercase :Any = state_dict['''shared.weight''']
if not is_encoder_only:
if "decoder.embed_tokens.weight" not in state_dict:
lowercase :Optional[Any] = state_dict['''shared.weight''']
if "lm_head.weight" not in state_dict: # For old 1.0 models.
print('''Using shared word embeddings as lm_head.''')
lowercase :Optional[int] = state_dict['''shared.weight''']
return state_dict
def lowerCamelCase (a_ :List[str] , a_ :List[str] , a_ :Tuple , a_ :Optional[int] , a_ :List[str]) -> List[str]:
lowercase :Optional[Any] = checkpoints.load_tax_checkpoint(a_)
lowercase :Optional[int] = convert_tax_to_pytorch(
a_ , num_layers=config.num_layers , is_encoder_only=a_ , scalable_attention=a_)
lowercase :Union[str, Any] = make_state_dict(a_ , a_)
model.load_state_dict(a_ , strict=a_)
def lowerCamelCase (a_ :str , a_ :Optional[int] , a_ :Any , a_ :bool = False , a_ :bool = False , ) -> Tuple:
lowercase :Optional[int] = MTaConfig.from_json_file(a_)
print(F"""Building PyTorch model from configuration: {config}""")
# Non-v1.1 checkpoints could also use T5Model, but this works for all.
# The v1.0 checkpoints will simply have an LM head that is the word embeddings.
if is_encoder_only:
lowercase :Union[str, Any] = UMTaEncoderModel(a_)
else:
lowercase :int = UMTaForConditionalGeneration(a_)
# Load weights from tf checkpoint
load_tax_weights_in_ta(a_ , a_ , a_ , a_ , a_)
# Save pytorch-model
print(F"""Save PyTorch model to {pytorch_dump_path}""")
model.save_pretrained(a_)
# Verify that we can load the checkpoint.
model.from_pretrained(a_)
print('''Done''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser(description='''Converts a native T5X checkpoint into a PyTorch checkpoint.''')
# Required parameters
parser.add_argument(
'''--t5x_checkpoint_path''', default=None, type=str, required=True, help='''Path to the T5X checkpoint.'''
)
parser.add_argument(
'''--config_file''',
default=None,
type=str,
required=True,
help='''The config json file corresponding to the pre-trained T5 model.\nThis specifies the model architecture.''',
)
parser.add_argument(
'''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
)
parser.add_argument(
'''--is_encoder_only''', action='''store_true''', help='''Check if the model is encoder-decoder model''', default=False
)
parser.add_argument(
'''--scalable_attention''',
action='''store_true''',
help='''Whether the model uses scaled attention (umt5 model)''',
default=False,
)
UpperCAmelCase = parser.parse_args()
convert_tax_checkpoint_to_pytorch(
args.tax_checkpoint_path,
args.config_file,
args.pytorch_dump_path,
args.is_encoder_only,
args.scalable_attention,
)
| 677 | 1 |
"""simple docstring"""
import requests
def lowerCamelCase (a_ :str , a_ :str) -> None:
lowercase :Dict = {'''Content-Type''': '''application/json'''}
lowercase :Optional[Any] = requests.post(a_ , json={'''text''': message_body} , headers=a_)
if response.status_code != 200:
lowercase :Union[str, Any] = (
'''Request to slack returned an error '''
F"""{response.status_code}, the response is:\n{response.text}"""
)
raise ValueError(a_)
if __name__ == "__main__":
# Set the slack url to the one provided by Slack when you create the webhook at
# https://my.slack.com/services/new/incoming-webhook/
send_slack_message('''<YOUR MESSAGE BODY>''', '''<SLACK CHANNEL URL>''')
| 677 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tf_available,
is_tokenizers_available,
is_torch_available,
)
UpperCAmelCase = {
'''configuration_blenderbot''': [
'''BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''BlenderbotConfig''',
'''BlenderbotOnnxConfig''',
],
'''tokenization_blenderbot''': ['''BlenderbotTokenizer'''],
}
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = ['''BlenderbotTokenizerFast''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''BlenderbotForCausalLM''',
'''BlenderbotForConditionalGeneration''',
'''BlenderbotModel''',
'''BlenderbotPreTrainedModel''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''TFBlenderbotForConditionalGeneration''',
'''TFBlenderbotModel''',
'''TFBlenderbotPreTrainedModel''',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
UpperCAmelCase = [
'''FlaxBlenderbotForConditionalGeneration''',
'''FlaxBlenderbotModel''',
'''FlaxBlenderbotPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_blenderbot import (
BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP,
BlenderbotConfig,
BlenderbotOnnxConfig,
)
from .tokenization_blenderbot import BlenderbotTokenizer
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_blenderbot_fast import BlenderbotTokenizerFast
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_blenderbot import (
BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST,
BlenderbotForCausalLM,
BlenderbotForConditionalGeneration,
BlenderbotModel,
BlenderbotPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_blenderbot import (
TFBlenderbotForConditionalGeneration,
TFBlenderbotModel,
TFBlenderbotPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_blenderbot import (
FlaxBlenderbotForConditionalGeneration,
FlaxBlenderbotModel,
FlaxBlenderbotPreTrainedModel,
)
else:
import sys
UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 677 | 1 |
"""simple docstring"""
import logging
from transformers import PretrainedConfig
UpperCAmelCase = logging.getLogger(__name__)
UpperCAmelCase = {
'''bertabs-finetuned-cnndm''': '''https://huggingface.co/remi/bertabs-finetuned-cnndm-extractive-abstractive-summarization/resolve/main/config.json''',
}
class __magic_name__ ( __UpperCAmelCase ):
__A : Any = "bertabs"
def __init__( self : Dict , snake_case__ : Optional[int]=3_0_5_2_2 , snake_case__ : Union[str, Any]=5_1_2 , snake_case__ : Optional[Any]=6 , snake_case__ : str=5_1_2 , snake_case__ : Optional[Any]=8 , snake_case__ : Dict=5_1_2 , snake_case__ : Dict=0.2 , snake_case__ : Optional[int]=6 , snake_case__ : Optional[Any]=7_6_8 , snake_case__ : List[str]=8 , snake_case__ : Optional[int]=2_0_4_8 , snake_case__ : str=0.2 , **snake_case__ : Union[str, Any] , ):
'''simple docstring'''
super().__init__(**snake_case__ )
lowercase :int = vocab_size
lowercase :Tuple = max_pos
lowercase :Any = enc_layers
lowercase :Optional[int] = enc_hidden_size
lowercase :Optional[int] = enc_heads
lowercase :str = enc_ff_size
lowercase :str = enc_dropout
lowercase :Any = dec_layers
lowercase :Dict = dec_hidden_size
lowercase :Any = dec_heads
lowercase :List[Any] = dec_ff_size
lowercase :List[str] = dec_dropout
| 677 |
"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
UpperCAmelCase = logging.get_logger(__name__)
UpperCAmelCase = {
'''naver-clova-ix/donut-base''': '''https://huggingface.co/naver-clova-ix/donut-base/resolve/main/config.json''',
# See all Donut models at https://huggingface.co/models?filter=donut-swin
}
class __magic_name__ ( __UpperCAmelCase ):
__A : Tuple = "donut-swin"
__A : Optional[Any] = {
"num_attention_heads": "num_heads",
"num_hidden_layers": "num_layers",
}
def __init__( self : List[str] , snake_case__ : Any=2_2_4 , snake_case__ : Tuple=4 , snake_case__ : str=3 , snake_case__ : Dict=9_6 , snake_case__ : Optional[Any]=[2, 2, 6, 2] , snake_case__ : Any=[3, 6, 1_2, 2_4] , snake_case__ : List[str]=7 , snake_case__ : Dict=4.0 , snake_case__ : str=True , snake_case__ : Optional[int]=0.0 , snake_case__ : Tuple=0.0 , snake_case__ : Any=0.1 , snake_case__ : List[str]="gelu" , snake_case__ : Tuple=False , snake_case__ : int=0.02 , snake_case__ : Optional[Any]=1e-5 , **snake_case__ : Any , ):
'''simple docstring'''
super().__init__(**snake_case__ )
lowercase :Union[str, Any] = image_size
lowercase :Optional[Any] = patch_size
lowercase :List[str] = num_channels
lowercase :Optional[int] = embed_dim
lowercase :Optional[Any] = depths
lowercase :List[Any] = len(snake_case__ )
lowercase :Optional[Any] = num_heads
lowercase :int = window_size
lowercase :str = mlp_ratio
lowercase :Optional[int] = qkv_bias
lowercase :Dict = hidden_dropout_prob
lowercase :Any = attention_probs_dropout_prob
lowercase :Any = drop_path_rate
lowercase :int = hidden_act
lowercase :int = use_absolute_embeddings
lowercase :List[str] = layer_norm_eps
lowercase :Union[str, Any] = initializer_range
# we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
# this indicates the channel dimension after the last stage of the model
lowercase :str = int(embed_dim * 2 ** (len(snake_case__ ) - 1) )
| 677 | 1 |
"""simple docstring"""
import argparse
import datetime
import json
import time
import warnings
from logging import getLogger
from pathlib import Path
from typing import Dict, List
import torch
from tqdm import tqdm
from transformers import AutoModelForSeqaSeqLM, AutoTokenizer
from utils import calculate_bleu, calculate_rouge, chunks, parse_numeric_n_bool_cl_kwargs, use_task_specific_params
UpperCAmelCase = getLogger(__name__)
UpperCAmelCase = '''cuda''' if torch.cuda.is_available() else '''cpu'''
def lowerCamelCase (a_ :List[str] , a_ :str , a_ :str , a_ :int = 8 , a_ :str = DEFAULT_DEVICE , a_ :Optional[int]=False , a_ :Any="summarization" , a_ :List[Any]=None , **a_ :Optional[int] , ) -> Dict:
lowercase :Dict = Path(a_).open('''w''' , encoding='''utf-8''')
lowercase :Dict = str(a_)
lowercase :Union[str, Any] = AutoModelForSeqaSeqLM.from_pretrained(a_).to(a_)
if fpaa:
lowercase :Tuple = model.half()
lowercase :Optional[Any] = AutoTokenizer.from_pretrained(a_)
logger.info(F"""Inferred tokenizer type: {tokenizer.__class__}""") # if this is wrong, check config.model_type.
lowercase :Any = time.time()
# update config with task specific params
use_task_specific_params(a_ , a_)
if prefix is None:
lowercase :List[str] = prefix or getattr(model.config , '''prefix''' , '''''') or ''''''
for examples_chunk in tqdm(list(chunks(a_ , a_))):
lowercase :int = [prefix + text for text in examples_chunk]
lowercase :Optional[int] = tokenizer(a_ , return_tensors='''pt''' , truncation=a_ , padding='''longest''').to(a_)
lowercase :List[str] = model.generate(
input_ids=batch.input_ids , attention_mask=batch.attention_mask , **a_ , )
lowercase :List[Any] = tokenizer.batch_decode(a_ , skip_special_tokens=a_ , clean_up_tokenization_spaces=a_)
for hypothesis in dec:
fout.write(hypothesis + '''\n''')
fout.flush()
fout.close()
lowercase :Tuple = int(time.time() - start_time) # seconds
lowercase :List[str] = len(a_)
return {"n_obs": n_obs, "runtime": runtime, "seconds_per_sample": round(runtime / n_obs , 4)}
def lowerCamelCase () -> Optional[Any]:
return datetime.datetime.now().strftime('''%Y-%m-%d %H:%M:%S''')
def lowerCamelCase (a_ :Optional[Any]=True) -> Dict:
lowercase :int = argparse.ArgumentParser()
parser.add_argument('''model_name''' , type=a_ , help='''like facebook/bart-large-cnn,t5-base, etc.''')
parser.add_argument('''input_path''' , type=a_ , help='''like cnn_dm/test.source''')
parser.add_argument('''save_path''' , type=a_ , help='''where to save summaries''')
parser.add_argument('''--reference_path''' , type=a_ , required=a_ , help='''like cnn_dm/test.target''')
parser.add_argument('''--score_path''' , type=a_ , required=a_ , default='''metrics.json''' , help='''where to save metrics''')
parser.add_argument('''--device''' , type=a_ , required=a_ , default=a_ , help='''cuda, cuda:1, cpu etc.''')
parser.add_argument(
'''--prefix''' , type=a_ , required=a_ , default=a_ , help='''will be added to the begininng of src examples''')
parser.add_argument('''--task''' , type=a_ , default='''summarization''' , help='''used for task_specific_params + metrics''')
parser.add_argument('''--bs''' , type=a_ , default=8 , required=a_ , help='''batch size''')
parser.add_argument(
'''--n_obs''' , type=a_ , default=-1 , required=a_ , help='''How many observations. Defaults to all.''')
parser.add_argument('''--fp16''' , action='''store_true''')
parser.add_argument('''--dump-args''' , action='''store_true''' , help='''print the custom hparams with the results''')
parser.add_argument(
'''--info''' , nargs='''?''' , type=a_ , const=datetime_now() , help=(
'''use in conjunction w/ --dump-args to print with the results whatever other info you\'d like, e.g.'''
''' lang=en-ru. If no value is passed, the current datetime string will be used.'''
) , )
# Unspecified args like --num_beams=2 --decoder_start_token_id=4 are passed to model.generate
lowercase , lowercase :List[Any] = parser.parse_known_args()
lowercase :Any = parse_numeric_n_bool_cl_kwargs(a_)
if parsed_args and verbose:
print(F"""parsed the following generate kwargs: {parsed_args}""")
lowercase :Any = [''' ''' + x.rstrip() if '''t5''' in args.model_name else x.rstrip() for x in open(args.input_path).readlines()]
if args.n_obs > 0:
lowercase :List[Any] = examples[: args.n_obs]
Path(args.save_path).parent.mkdir(exist_ok=a_)
if args.reference_path is None and Path(args.score_path).exists():
warnings.warn(F"""score_path {args.score_path} will be overwritten unless you type ctrl-c.""")
if args.device == "cpu" and args.fpaa:
# this mix leads to RuntimeError: "threshold_cpu" not implemented for 'Half'
raise ValueError('''Can\'t mix --fp16 and --device cpu''')
lowercase :Optional[Any] = generate_summaries_or_translations(
a_ , args.save_path , args.model_name , batch_size=args.bs , device=args.device , fpaa=args.fpaa , task=args.task , prefix=args.prefix , **a_ , )
if args.reference_path is None:
return {}
# Compute scores
lowercase :Optional[Any] = calculate_bleu if '''translation''' in args.task else calculate_rouge
lowercase :List[str] = [x.rstrip() for x in open(args.save_path).readlines()]
lowercase :Dict = [x.rstrip() for x in open(args.reference_path).readlines()][: len(a_)]
lowercase :dict = score_fn(a_ , a_)
scores.update(a_)
if args.dump_args:
scores.update(a_)
if args.info:
lowercase :int = args.info
if verbose:
print(a_)
if args.score_path is not None:
json.dump(a_ , open(args.score_path , '''w'''))
return scores
if __name__ == "__main__":
# Usage for MT:
# python run_eval.py MODEL_NAME $DATA_DIR/test.source $save_dir/test_translations.txt --reference_path $DATA_DIR/test.target --score_path $save_dir/test_bleu.json --task translation $@
run_generate(verbose=True)
| 677 |
"""simple docstring"""
import argparse
import os
import shutil
from pathlib import Path
import onnx
import torch
from packaging import version
from torch.onnx import export
from diffusers import OnnxRuntimeModel, OnnxStableDiffusionPipeline, StableDiffusionPipeline
UpperCAmelCase = version.parse(version.parse(torch.__version__).base_version) < version.parse('''1.11''')
def lowerCamelCase (a_ :Optional[int] , a_ :tuple , a_ :Path , a_ :str , a_ :int , a_ :List[Any] , a_ :Any , a_ :Union[str, Any]=False , ) -> Dict:
output_path.parent.mkdir(parents=a_ , exist_ok=a_)
# PyTorch deprecated the `enable_onnx_checker` and `use_external_data_format` arguments in v1.11,
# so we check the torch version for backwards compatibility
if is_torch_less_than_1_11:
export(
a_ , a_ , f=output_path.as_posix() , input_names=a_ , output_names=a_ , dynamic_axes=a_ , do_constant_folding=a_ , use_external_data_format=a_ , enable_onnx_checker=a_ , opset_version=a_ , )
else:
export(
a_ , a_ , f=output_path.as_posix() , input_names=a_ , output_names=a_ , dynamic_axes=a_ , do_constant_folding=a_ , opset_version=a_ , )
@torch.no_grad()
def lowerCamelCase (a_ :str , a_ :str , a_ :int , a_ :bool = False) -> Union[str, Any]:
lowercase :Any = torch.floataa if fpaa else torch.floataa
if fpaa and torch.cuda.is_available():
lowercase :Union[str, Any] = '''cuda'''
elif fpaa and not torch.cuda.is_available():
raise ValueError('''`float16` model export is only supported on GPUs with CUDA''')
else:
lowercase :List[str] = '''cpu'''
lowercase :List[str] = StableDiffusionPipeline.from_pretrained(a_ , torch_dtype=a_).to(a_)
lowercase :List[Any] = Path(a_)
# TEXT ENCODER
lowercase :List[Any] = pipeline.text_encoder.config.max_position_embeddings
lowercase :Dict = pipeline.text_encoder.config.hidden_size
lowercase :Union[str, Any] = pipeline.tokenizer(
'''A sample prompt''' , padding='''max_length''' , max_length=pipeline.tokenizer.model_max_length , truncation=a_ , return_tensors='''pt''' , )
onnx_export(
pipeline.text_encoder , model_args=(text_input.input_ids.to(device=a_ , dtype=torch.intaa)) , output_path=output_path / '''text_encoder''' / '''model.onnx''' , ordered_input_names=['''input_ids'''] , output_names=['''last_hidden_state''', '''pooler_output'''] , dynamic_axes={
'''input_ids''': {0: '''batch''', 1: '''sequence'''},
} , opset=a_ , )
del pipeline.text_encoder
# UNET
lowercase :Any = pipeline.unet.config.in_channels
lowercase :List[Any] = pipeline.unet.config.sample_size
lowercase :Optional[int] = output_path / '''unet''' / '''model.onnx'''
onnx_export(
pipeline.unet , model_args=(
torch.randn(2 , a_ , a_ , a_).to(device=a_ , dtype=a_),
torch.randn(2).to(device=a_ , dtype=a_),
torch.randn(2 , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=a_ , ordered_input_names=['''sample''', '''timestep''', '''encoder_hidden_states''', '''return_dict'''] , output_names=['''out_sample'''] , dynamic_axes={
'''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
'''timestep''': {0: '''batch'''},
'''encoder_hidden_states''': {0: '''batch''', 1: '''sequence'''},
} , opset=a_ , use_external_data_format=a_ , )
lowercase :List[Any] = str(unet_path.absolute().as_posix())
lowercase :str = os.path.dirname(a_)
lowercase :Optional[Any] = onnx.load(a_)
# clean up existing tensor files
shutil.rmtree(a_)
os.mkdir(a_)
# collate external tensor files into one
onnx.save_model(
a_ , a_ , save_as_external_data=a_ , all_tensors_to_one_file=a_ , location='''weights.pb''' , convert_attribute=a_ , )
del pipeline.unet
# VAE ENCODER
lowercase :Tuple = pipeline.vae
lowercase :Optional[Any] = vae_encoder.config.in_channels
lowercase :Any = vae_encoder.config.sample_size
# need to get the raw tensor output (sample) from the encoder
lowercase :Any = lambda a_ , a_: vae_encoder.encode(a_ , a_)[0].sample()
onnx_export(
a_ , model_args=(
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=output_path / '''vae_encoder''' / '''model.onnx''' , ordered_input_names=['''sample''', '''return_dict'''] , output_names=['''latent_sample'''] , dynamic_axes={
'''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
} , opset=a_ , )
# VAE DECODER
lowercase :Any = pipeline.vae
lowercase :Dict = vae_decoder.config.latent_channels
lowercase :Union[str, Any] = vae_decoder.config.out_channels
# forward only through the decoder part
lowercase :List[Any] = vae_encoder.decode
onnx_export(
a_ , model_args=(
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
False,
) , output_path=output_path / '''vae_decoder''' / '''model.onnx''' , ordered_input_names=['''latent_sample''', '''return_dict'''] , output_names=['''sample'''] , dynamic_axes={
'''latent_sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
} , opset=a_ , )
del pipeline.vae
# SAFETY CHECKER
if pipeline.safety_checker is not None:
lowercase :Dict = pipeline.safety_checker
lowercase :str = safety_checker.config.vision_config.num_channels
lowercase :str = safety_checker.config.vision_config.image_size
lowercase :List[str] = safety_checker.forward_onnx
onnx_export(
pipeline.safety_checker , model_args=(
torch.randn(
1 , a_ , a_ , a_ , ).to(device=a_ , dtype=a_),
torch.randn(1 , a_ , a_ , a_).to(device=a_ , dtype=a_),
) , output_path=output_path / '''safety_checker''' / '''model.onnx''' , ordered_input_names=['''clip_input''', '''images'''] , output_names=['''out_images''', '''has_nsfw_concepts'''] , dynamic_axes={
'''clip_input''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
'''images''': {0: '''batch''', 1: '''height''', 2: '''width''', 3: '''channels'''},
} , opset=a_ , )
del pipeline.safety_checker
lowercase :Tuple = OnnxRuntimeModel.from_pretrained(output_path / '''safety_checker''')
lowercase :Optional[Any] = pipeline.feature_extractor
else:
lowercase :int = None
lowercase :Union[str, Any] = None
lowercase :Optional[int] = OnnxStableDiffusionPipeline(
vae_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_encoder''') , vae_decoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_decoder''') , text_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''text_encoder''') , tokenizer=pipeline.tokenizer , unet=OnnxRuntimeModel.from_pretrained(output_path / '''unet''') , scheduler=pipeline.scheduler , safety_checker=a_ , feature_extractor=a_ , requires_safety_checker=safety_checker is not None , )
onnx_pipeline.save_pretrained(a_)
print('''ONNX pipeline saved to''' , a_)
del pipeline
del onnx_pipeline
lowercase :Tuple = OnnxStableDiffusionPipeline.from_pretrained(a_ , provider='''CPUExecutionProvider''')
print('''ONNX pipeline is loadable''')
if __name__ == "__main__":
UpperCAmelCase = argparse.ArgumentParser()
parser.add_argument(
'''--model_path''',
type=str,
required=True,
help='''Path to the `diffusers` checkpoint to convert (either a local directory or on the Hub).''',
)
parser.add_argument('''--output_path''', type=str, required=True, help='''Path to the output model.''')
parser.add_argument(
'''--opset''',
default=14,
type=int,
help='''The version of the ONNX operator set to use.''',
)
parser.add_argument('''--fp16''', action='''store_true''', default=False, help='''Export the models in `float16` mode''')
UpperCAmelCase = parser.parse_args()
convert_models(args.model_path, args.output_path, args.opset, args.fpaa)
| 677 | 1 |
"""simple docstring"""
import unittest
from pathlib import Path
from tempfile import NamedTemporaryFile, TemporaryDirectory
from transformers import BertConfig, BertTokenizerFast, FeatureExtractionPipeline
from transformers.convert_graph_to_onnx import (
convert,
ensure_valid_input,
generate_identified_filename,
infer_shapes,
quantize,
)
from transformers.testing_utils import require_tf, require_tokenizers, require_torch, slow
class __magic_name__ :
def __snake_case ( self : List[str] , snake_case__ : List[str] , snake_case__ : Union[str, Any] , snake_case__ : List[Any] ):
'''simple docstring'''
return None
class __magic_name__ :
def __snake_case ( self : List[Any] , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : List[Any] ):
'''simple docstring'''
return None
class __magic_name__ ( unittest.TestCase ):
__A : int = [
# (model_name, model_kwargs)
("bert-base-cased", {}),
("gpt2", {"use_cache": False}), # We don't support exporting GPT2 past keys anymore
]
@require_tf
@slow
def __snake_case ( self : Dict ):
'''simple docstring'''
for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
self._test_export(snake_case__ , '''tf''' , 1_2 , **snake_case__ )
@require_torch
@slow
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
self._test_export(snake_case__ , '''pt''' , 1_2 , **snake_case__ )
@require_torch
@slow
def __snake_case ( self : List[str] ):
'''simple docstring'''
from transformers import BertModel
lowercase :Dict = ['''[UNK]''', '''[SEP]''', '''[CLS]''', '''[PAD]''', '''[MASK]''', '''some''', '''other''', '''words''']
with NamedTemporaryFile(mode='''w+t''' ) as vocab_file:
vocab_file.write('''\n'''.join(snake_case__ ) )
vocab_file.flush()
lowercase :int = BertTokenizerFast(vocab_file.name )
with TemporaryDirectory() as bert_save_dir:
lowercase :Optional[int] = BertModel(BertConfig(vocab_size=len(snake_case__ ) ) )
model.save_pretrained(snake_case__ )
self._test_export(snake_case__ , '''pt''' , 1_2 , snake_case__ )
@require_tf
@slow
def __snake_case ( self : List[Any] ):
'''simple docstring'''
for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
lowercase :Any = self._test_export(snake_case__ , '''tf''' , 1_2 , **snake_case__ )
lowercase :Optional[Any] = quantize(Path(snake_case__ ) )
# Ensure the actual quantized model is not bigger than the original one
if quantized_path.stat().st_size >= Path(snake_case__ ).stat().st_size:
self.fail('''Quantized model is bigger than initial ONNX model''' )
@require_torch
@slow
def __snake_case ( self : int ):
'''simple docstring'''
for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
lowercase :int = self._test_export(snake_case__ , '''pt''' , 1_2 , **snake_case__ )
lowercase :List[str] = quantize(snake_case__ )
# Ensure the actual quantized model is not bigger than the original one
if quantized_path.stat().st_size >= Path(snake_case__ ).stat().st_size:
self.fail('''Quantized model is bigger than initial ONNX model''' )
def __snake_case ( self : Tuple , snake_case__ : List[Any] , snake_case__ : Dict , snake_case__ : str , snake_case__ : Dict=None , **snake_case__ : Dict ):
'''simple docstring'''
try:
# Compute path
with TemporaryDirectory() as tempdir:
lowercase :List[str] = Path(snake_case__ ).joinpath('''model.onnx''' )
# Remove folder if exists
if path.parent.exists():
path.parent.rmdir()
# Export
convert(snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , **snake_case__ )
return path
except Exception as e:
self.fail(snake_case__ )
@require_torch
@require_tokenizers
@slow
def __snake_case ( self : str ):
'''simple docstring'''
from transformers import BertModel
lowercase :Dict = BertModel(BertConfig.from_pretrained('''lysandre/tiny-bert-random''' ) )
lowercase :Optional[int] = BertTokenizerFast.from_pretrained('''lysandre/tiny-bert-random''' )
self._test_infer_dynamic_axis(snake_case__ , snake_case__ , '''pt''' )
@require_tf
@require_tokenizers
@slow
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
from transformers import TFBertModel
lowercase :List[str] = TFBertModel(BertConfig.from_pretrained('''lysandre/tiny-bert-random''' ) )
lowercase :Optional[int] = BertTokenizerFast.from_pretrained('''lysandre/tiny-bert-random''' )
self._test_infer_dynamic_axis(snake_case__ , snake_case__ , '''tf''' )
def __snake_case ( self : Dict , snake_case__ : Tuple , snake_case__ : Any , snake_case__ : Tuple ):
'''simple docstring'''
lowercase :Tuple = FeatureExtractionPipeline(snake_case__ , snake_case__ )
lowercase :Optional[Any] = ['''input_ids''', '''token_type_ids''', '''attention_mask''', '''output_0''', '''output_1''']
lowercase , lowercase , lowercase , lowercase :Optional[int] = infer_shapes(snake_case__ , snake_case__ )
# Assert all variables are present
self.assertEqual(len(snake_case__ ) , len(snake_case__ ) )
self.assertTrue(all(var_name in shapes for var_name in variable_names ) )
self.assertSequenceEqual(variable_names[:3] , snake_case__ )
self.assertSequenceEqual(variable_names[3:] , snake_case__ )
# Assert inputs are {0: batch, 1: sequence}
for var_name in ["input_ids", "token_type_ids", "attention_mask"]:
self.assertDictEqual(shapes[var_name] , {0: '''batch''', 1: '''sequence'''} )
# Assert outputs are {0: batch, 1: sequence} and {0: batch}
self.assertDictEqual(shapes['''output_0'''] , {0: '''batch''', 1: '''sequence'''} )
self.assertDictEqual(shapes['''output_1'''] , {0: '''batch'''} )
def __snake_case ( self : Any ):
'''simple docstring'''
lowercase :Optional[int] = ['''input_ids''', '''attention_mask''', '''token_type_ids''']
lowercase :List[str] = {'''input_ids''': [1, 2, 3, 4], '''attention_mask''': [0, 0, 0, 0], '''token_type_ids''': [1, 1, 1, 1]}
lowercase , lowercase :List[Any] = ensure_valid_input(FuncContiguousArgs() , snake_case__ , snake_case__ )
# Should have exactly the same number of args (all are valid)
self.assertEqual(len(snake_case__ ) , 3 )
# Should have exactly the same input names
self.assertEqual(set(snake_case__ ) , set(snake_case__ ) )
# Parameter should be reordered according to their respective place in the function:
# (input_ids, token_type_ids, attention_mask)
self.assertEqual(snake_case__ , (tokens['''input_ids'''], tokens['''token_type_ids'''], tokens['''attention_mask''']) )
# Generated args are interleaved with another args (for instance parameter "past" in GPT2)
lowercase , lowercase :List[Any] = ensure_valid_input(FuncNonContiguousArgs() , snake_case__ , snake_case__ )
# Should have exactly the one arg (all before the one not provided "some_other_args")
self.assertEqual(len(snake_case__ ) , 1 )
self.assertEqual(len(snake_case__ ) , 1 )
# Should have only "input_ids"
self.assertEqual(inputs_args[0] , tokens['''input_ids'''] )
self.assertEqual(ordered_input_names[0] , '''input_ids''' )
def __snake_case ( self : Optional[int] ):
'''simple docstring'''
lowercase :Optional[Any] = generate_identified_filename(Path('''/home/something/my_fake_model.onnx''' ) , '''-test''' )
self.assertEqual('''/home/something/my_fake_model-test.onnx''' , generated.as_posix() )
| 677 |
"""simple docstring"""
import itertools
import json
import linecache
import os
import pickle
import re
import socket
import string
from collections import Counter
from logging import getLogger
from pathlib import Path
from typing import Callable, Dict, Iterable, List
import git
import torch
from torch.utils.data import Dataset
from transformers import BartTokenizer, RagTokenizer, TaTokenizer
def lowerCamelCase (a_ :List[Any] , a_ :Union[str, Any] , a_ :Tuple , a_ :List[str] , a_ :str=True , a_ :str="pt") -> List[str]:
lowercase :Optional[int] = {'''add_prefix_space''': True} if isinstance(a_ , a_) and not line.startswith(''' ''') else {}
lowercase :Optional[int] = padding_side
return tokenizer(
[line] , max_length=a_ , padding='''max_length''' if pad_to_max_length else None , truncation=a_ , return_tensors=a_ , add_special_tokens=a_ , **a_ , )
def lowerCamelCase (a_ :str , a_ :Tuple , a_ :Optional[Any]=None , ) -> Tuple:
lowercase :Optional[Any] = input_ids.ne(a_).any(dim=0)
if attention_mask is None:
return input_ids[:, keep_column_mask]
else:
return (input_ids[:, keep_column_mask], attention_mask[:, keep_column_mask])
class __magic_name__ ( __UpperCAmelCase ):
def __init__( self : Union[str, Any] , snake_case__ : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : str="train" , snake_case__ : Optional[Any]=None , snake_case__ : Tuple=None , snake_case__ : Any=None , snake_case__ : Dict="" , ):
'''simple docstring'''
super().__init__()
lowercase :Tuple = Path(snake_case__ ).joinpath(type_path + '''.source''' )
lowercase :Union[str, Any] = Path(snake_case__ ).joinpath(type_path + '''.target''' )
lowercase :List[Any] = self.get_char_lens(self.src_file )
lowercase :Tuple = max_source_length
lowercase :Optional[int] = max_target_length
assert min(self.src_lens ) > 0, f"""found empty line in {self.src_file}"""
lowercase :Any = tokenizer
lowercase :Tuple = prefix
if n_obs is not None:
lowercase :List[str] = self.src_lens[:n_obs]
lowercase :List[Any] = src_lang
lowercase :str = tgt_lang
def __len__( self : Any ):
'''simple docstring'''
return len(self.src_lens )
def __getitem__( self : str , snake_case__ : Any ):
'''simple docstring'''
lowercase :Optional[int] = index + 1 # linecache starts at 1
lowercase :Optional[Any] = self.prefix + linecache.getline(str(self.src_file ) , snake_case__ ).rstrip('''\n''' )
lowercase :Dict = linecache.getline(str(self.tgt_file ) , snake_case__ ).rstrip('''\n''' )
assert source_line, f"""empty source line for index {index}"""
assert tgt_line, f"""empty tgt line for index {index}"""
# Need to add eos token manually for T5
if isinstance(self.tokenizer , snake_case__ ):
source_line += self.tokenizer.eos_token
tgt_line += self.tokenizer.eos_token
# Pad source and target to the right
lowercase :Dict = (
self.tokenizer.question_encoder if isinstance(self.tokenizer , snake_case__ ) else self.tokenizer
)
lowercase :Optional[int] = self.tokenizer.generator if isinstance(self.tokenizer , snake_case__ ) else self.tokenizer
lowercase :Optional[int] = encode_line(snake_case__ , snake_case__ , self.max_source_length , '''right''' )
lowercase :Tuple = encode_line(snake_case__ , snake_case__ , self.max_target_length , '''right''' )
lowercase :List[str] = source_inputs['''input_ids'''].squeeze()
lowercase :Optional[Any] = target_inputs['''input_ids'''].squeeze()
lowercase :List[str] = source_inputs['''attention_mask'''].squeeze()
return {
"input_ids": source_ids,
"attention_mask": src_mask,
"decoder_input_ids": target_ids,
}
@staticmethod
def __snake_case ( snake_case__ : Optional[int] ):
'''simple docstring'''
return [len(snake_case__ ) for x in Path(snake_case__ ).open().readlines()]
def __snake_case ( self : Tuple , snake_case__ : Union[str, Any] ):
'''simple docstring'''
lowercase :Optional[Any] = torch.stack([x['''input_ids'''] for x in batch] )
lowercase :Tuple = torch.stack([x['''attention_mask'''] for x in batch] )
lowercase :Tuple = torch.stack([x['''decoder_input_ids'''] for x in batch] )
lowercase :str = (
self.tokenizer.generator.pad_token_id
if isinstance(self.tokenizer , snake_case__ )
else self.tokenizer.pad_token_id
)
lowercase :Optional[int] = (
self.tokenizer.question_encoder.pad_token_id
if isinstance(self.tokenizer , snake_case__ )
else self.tokenizer.pad_token_id
)
lowercase :List[Any] = trim_batch(snake_case__ , snake_case__ )
lowercase , lowercase :List[str] = trim_batch(snake_case__ , snake_case__ , attention_mask=snake_case__ )
lowercase :Optional[int] = {
'''input_ids''': source_ids,
'''attention_mask''': source_mask,
'''decoder_input_ids''': y,
}
return batch
UpperCAmelCase = getLogger(__name__)
def lowerCamelCase (a_ :List[List]) -> Tuple:
return list(itertools.chain.from_iterable(a_))
def lowerCamelCase (a_ :str) -> None:
lowercase :List[str] = get_git_info()
save_json(a_ , os.path.join(a_ , '''git_log.json'''))
def lowerCamelCase (a_ :Optional[int] , a_ :Optional[int] , a_ :Optional[Any]=4 , **a_ :Optional[Any]) -> str:
with open(a_ , '''w''') as f:
json.dump(a_ , a_ , indent=a_ , **a_)
def lowerCamelCase (a_ :Dict) -> Union[str, Any]:
with open(a_) as f:
return json.load(a_)
def lowerCamelCase () -> List[str]:
lowercase :Dict = git.Repo(search_parent_directories=a_)
lowercase :int = {
'''repo_id''': str(a_),
'''repo_sha''': str(repo.head.object.hexsha),
'''repo_branch''': str(repo.active_branch),
'''hostname''': str(socket.gethostname()),
}
return repo_infos
def lowerCamelCase (a_ :Callable , a_ :Iterable) -> List:
return list(map(a_ , a_))
def lowerCamelCase (a_ :Optional[Any] , a_ :str) -> Any:
with open(a_ , '''wb''') as f:
return pickle.dump(a_ , a_)
def lowerCamelCase (a_ :List[str]) -> List[str]:
def remove_articles(a_ :Union[str, Any]):
return re.sub(R'''\b(a|an|the)\b''' , ''' ''' , a_)
def white_space_fix(a_ :Tuple):
return " ".join(text.split())
def remove_punc(a_ :int):
lowercase :List[Any] = set(string.punctuation)
return "".join(ch for ch in text if ch not in exclude)
def lower(a_ :int):
return text.lower()
return white_space_fix(remove_articles(remove_punc(lower(a_))))
def lowerCamelCase (a_ :List[str] , a_ :Any) -> List[str]:
lowercase :Dict = normalize_answer(a_).split()
lowercase :int = normalize_answer(a_).split()
lowercase :List[Any] = Counter(a_) & Counter(a_)
lowercase :Optional[int] = sum(common.values())
if num_same == 0:
return 0
lowercase :str = 1.0 * num_same / len(a_)
lowercase :Tuple = 1.0 * num_same / len(a_)
lowercase :Tuple = (2 * precision * recall) / (precision + recall)
return fa
def lowerCamelCase (a_ :Tuple , a_ :Optional[Any]) -> List[Any]:
return normalize_answer(a_) == normalize_answer(a_)
def lowerCamelCase (a_ :List[str] , a_ :List[str]) -> Dict:
assert len(a_) == len(a_)
lowercase :Any = 0
for hypo, pred in zip(a_ , a_):
em += exact_match_score(a_ , a_)
if len(a_) > 0:
em /= len(a_)
return {"em": em}
def lowerCamelCase (a_ :Union[str, Any]) -> Optional[Any]:
return model_prefix.startswith('''rag''')
def lowerCamelCase (a_ :List[str] , a_ :Tuple , a_ :List[str]) -> Any:
lowercase :List[str] = {p: p for p in extra_params}
# T5 models don't have `dropout` param, they have `dropout_rate` instead
lowercase :str = '''dropout_rate'''
for p in extra_params:
if getattr(a_ , a_ , a_):
if not hasattr(a_ , a_) and not hasattr(a_ , equivalent_param[p]):
logger.info('''config doesn\'t have a `{}` attribute'''.format(a_))
delattr(a_ , a_)
continue
lowercase :List[str] = p if hasattr(a_ , a_) else equivalent_param[p]
setattr(a_ , a_ , getattr(a_ , a_))
delattr(a_ , a_)
return hparams, config
| 677 | 1 |
"""simple docstring"""
import numpy as np
from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch
from .test_feature_extraction_common import FeatureExtractionSavingTestMixin
class __magic_name__ ( __UpperCAmelCase ):
# to overwrite at feature extractactor specific tests
__A : Optional[int] = None
__A : List[str] = None
@property
def __snake_case ( self : Tuple ):
'''simple docstring'''
return self.feat_extract_tester.prepare_feat_extract_dict()
def __snake_case ( self : Dict ):
'''simple docstring'''
lowercase :Tuple = self.feature_extraction_class(**self.feat_extract_dict )
self.assertTrue(hasattr(snake_case__ , '''feature_size''' ) )
self.assertTrue(hasattr(snake_case__ , '''sampling_rate''' ) )
self.assertTrue(hasattr(snake_case__ , '''padding_value''' ) )
def __snake_case ( self : int ):
'''simple docstring'''
lowercase :Any = self.feat_extract_tester.prepare_inputs_for_common()
lowercase :Tuple = self.feature_extraction_class(**self.feat_extract_dict )
lowercase :str = feat_extract.model_input_names[0]
lowercase :Optional[Any] = BatchFeature({input_name: speech_inputs} )
self.assertTrue(all(len(snake_case__ ) == len(snake_case__ ) for x, y in zip(snake_case__ , processed_features[input_name] ) ) )
lowercase :List[Any] = self.feat_extract_tester.prepare_inputs_for_common(equal_length=snake_case__ )
lowercase :str = BatchFeature({input_name: speech_inputs} , tensor_type='''np''' )
lowercase :Tuple = processed_features[input_name]
if len(batch_features_input.shape ) < 3:
lowercase :Optional[Any] = batch_features_input[:, :, None]
self.assertTrue(
batch_features_input.shape
== (self.feat_extract_tester.batch_size, len(speech_inputs[0] ), self.feat_extract_tester.feature_size) )
@require_torch
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :Optional[int] = self.feat_extract_tester.prepare_inputs_for_common(equal_length=snake_case__ )
lowercase :Union[str, Any] = self.feature_extraction_class(**self.feat_extract_dict )
lowercase :Tuple = feat_extract.model_input_names[0]
lowercase :List[Any] = BatchFeature({input_name: speech_inputs} , tensor_type='''pt''' )
lowercase :str = processed_features[input_name]
if len(batch_features_input.shape ) < 3:
lowercase :Tuple = batch_features_input[:, :, None]
self.assertTrue(
batch_features_input.shape
== (self.feat_extract_tester.batch_size, len(speech_inputs[0] ), self.feat_extract_tester.feature_size) )
@require_tf
def __snake_case ( self : Union[str, Any] ):
'''simple docstring'''
lowercase :Any = self.feat_extract_tester.prepare_inputs_for_common(equal_length=snake_case__ )
lowercase :str = self.feature_extraction_class(**self.feat_extract_dict )
lowercase :Tuple = feat_extract.model_input_names[0]
lowercase :Tuple = BatchFeature({input_name: speech_inputs} , tensor_type='''tf''' )
lowercase :Any = processed_features[input_name]
if len(batch_features_input.shape ) < 3:
lowercase :Any = batch_features_input[:, :, None]
self.assertTrue(
batch_features_input.shape
== (self.feat_extract_tester.batch_size, len(speech_inputs[0] ), self.feat_extract_tester.feature_size) )
def __snake_case ( self : str , snake_case__ : Tuple=False ):
'''simple docstring'''
def _inputs_have_equal_length(snake_case__ : Optional[Any] ):
lowercase :List[Any] = len(input[0] )
for input_slice in input[1:]:
if len(snake_case__ ) != length:
return False
return True
def _inputs_are_equal(snake_case__ : Optional[Any] , snake_case__ : str ):
if len(snake_case__ ) != len(snake_case__ ):
return False
for input_slice_a, input_slice_a in zip(snake_case__ , snake_case__ ):
if not np.allclose(np.asarray(snake_case__ ) , np.asarray(snake_case__ ) , atol=1e-3 ):
return False
return True
lowercase :List[str] = self.feature_extraction_class(**self.feat_extract_dict )
lowercase :int = self.feat_extract_tester.prepare_inputs_for_common(numpify=snake_case__ )
lowercase :Union[str, Any] = feat_extract.model_input_names[0]
lowercase :str = BatchFeature({input_name: speech_inputs} )
lowercase :Tuple = self.feat_extract_tester.seq_length_diff
lowercase :int = self.feat_extract_tester.max_seq_length + pad_diff
lowercase :List[Any] = self.feat_extract_tester.min_seq_length
lowercase :str = self.feat_extract_tester.batch_size
lowercase :Tuple = self.feat_extract_tester.feature_size
# test padding for List[int] + numpy
lowercase :Union[str, Any] = feat_extract.pad(snake_case__ , padding=snake_case__ )
lowercase :Dict = input_a[input_name]
lowercase :str = feat_extract.pad(snake_case__ , padding='''longest''' )
lowercase :Tuple = input_a[input_name]
lowercase :List[str] = feat_extract.pad(snake_case__ , padding='''max_length''' , max_length=len(speech_inputs[-1] ) )
lowercase :str = input_a[input_name]
lowercase :Any = feat_extract.pad(snake_case__ , padding='''longest''' , return_tensors='''np''' )
lowercase :Tuple = input_a[input_name]
# max_length parameter has to be provided when setting `padding="max_length"`
with self.assertRaises(snake_case__ ):
feat_extract.pad(snake_case__ , padding='''max_length''' )[input_name]
lowercase :Optional[Any] = feat_extract.pad(
snake_case__ , padding='''max_length''' , max_length=snake_case__ , return_tensors='''np''' )
lowercase :Dict = input_a[input_name]
self.assertFalse(_inputs_have_equal_length(snake_case__ ) )
self.assertTrue(_inputs_have_equal_length(snake_case__ ) )
self.assertTrue(_inputs_have_equal_length(snake_case__ ) )
self.assertTrue(_inputs_are_equal(snake_case__ , snake_case__ ) )
self.assertTrue(len(input_a[0] ) == pad_min_length )
self.assertTrue(len(input_a[1] ) == pad_min_length + pad_diff )
self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0] )) )
self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length) )
if feature_size > 1:
self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size )
# test padding for `pad_to_multiple_of` for List[int] + numpy
lowercase :str = feat_extract.pad(snake_case__ , pad_to_multiple_of=1_0 )
lowercase :List[Any] = input_a[input_name]
lowercase :int = feat_extract.pad(snake_case__ , padding='''longest''' , pad_to_multiple_of=1_0 )
lowercase :str = input_a[input_name]
lowercase :Tuple = feat_extract.pad(
snake_case__ , padding='''max_length''' , pad_to_multiple_of=1_0 , max_length=snake_case__ )
lowercase :Union[str, Any] = input_a[input_name]
lowercase :Dict = feat_extract.pad(
snake_case__ , padding='''max_length''' , pad_to_multiple_of=1_0 , max_length=snake_case__ , return_tensors='''np''' , )
lowercase :Union[str, Any] = input_a[input_name]
self.assertTrue(all(len(snake_case__ ) % 1_0 == 0 for x in input_a ) )
self.assertTrue(_inputs_are_equal(snake_case__ , snake_case__ ) )
lowercase :List[str] = pad_max_length if pad_max_length % 1_0 == 0 else (pad_max_length // 1_0 + 1) * 1_0
self.assertTrue(all(len(snake_case__ ) == expected_mult_pad_length for x in input_a ) )
self.assertEqual(input_a.shape[:2] , (batch_size, expected_mult_pad_length) )
if feature_size > 1:
self.assertTrue(input_a.shape[2] == feature_size )
# Check padding value is correct
lowercase :Optional[Any] = (np.ones(self.feat_extract_tester.feature_size ) * feat_extract.padding_value).sum()
self.assertTrue(
abs(np.asarray(input_a[0] )[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length) )
< 1e-3 )
self.assertTrue(
abs(
np.asarray(input_a[1] )[pad_min_length + pad_diff :].sum()
- padding_vector_sum * (pad_max_length - pad_min_length - pad_diff) )
< 1e-3 )
self.assertTrue(
abs(
np.asarray(input_a[2] )[pad_min_length + 2 * pad_diff :].sum()
- padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff) )
< 1e-3 )
self.assertTrue(
abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length) ) < 1e-3 )
self.assertTrue(
abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length) )
< 1e-3 )
def __snake_case ( self : Union[str, Any] , snake_case__ : Tuple=False ):
'''simple docstring'''
def _inputs_have_equal_length(snake_case__ : List[str] ):
lowercase :Union[str, Any] = len(input[0] )
for input_slice in input[1:]:
if len(snake_case__ ) != length:
return False
return True
def _inputs_are_equal(snake_case__ : List[Any] , snake_case__ : Dict ):
if len(snake_case__ ) != len(snake_case__ ):
return False
for input_slice_a, input_slice_a in zip(snake_case__ , snake_case__ ):
if not np.allclose(np.asarray(snake_case__ ) , np.asarray(snake_case__ ) , atol=1e-3 ):
return False
return True
lowercase :Optional[int] = self.feature_extraction_class(**self.feat_extract_dict )
lowercase :Dict = self.feat_extract_tester.prepare_inputs_for_common(numpify=snake_case__ )
lowercase :Any = feat_extract.model_input_names[0]
lowercase :Optional[Any] = BatchFeature({input_name: speech_inputs} )
# truncate to smallest
lowercase :str = feat_extract.pad(
snake_case__ , padding='''max_length''' , max_length=len(speech_inputs[0] ) , truncation=snake_case__ )
lowercase :Any = input_a[input_name]
lowercase :List[str] = feat_extract.pad(snake_case__ , padding='''max_length''' , max_length=len(speech_inputs[0] ) )
lowercase :Tuple = input_a[input_name]
self.assertTrue(_inputs_have_equal_length(snake_case__ ) )
self.assertFalse(_inputs_have_equal_length(snake_case__ ) )
# truncate to smallest with np
lowercase :Dict = feat_extract.pad(
snake_case__ , padding='''max_length''' , max_length=len(speech_inputs[0] ) , return_tensors='''np''' , truncation=snake_case__ , )
lowercase :Any = input_a[input_name]
lowercase :Dict = feat_extract.pad(
snake_case__ , padding='''max_length''' , max_length=len(speech_inputs[0] ) , return_tensors='''np''' )
lowercase :Union[str, Any] = input_a[input_name]
self.assertTrue(_inputs_have_equal_length(snake_case__ ) )
self.assertTrue(input_a.shape[1] == len(speech_inputs[0] ) )
# since truncation forces padding to be smaller than longest input
# function can't return `np.ndarray`, but has to return list
self.assertFalse(_inputs_have_equal_length(snake_case__ ) )
# truncate to middle
lowercase :Optional[int] = feat_extract.pad(
snake_case__ , padding='''max_length''' , max_length=len(speech_inputs[1] ) , truncation=snake_case__ , return_tensors='''np''' , )
lowercase :List[str] = input_a[input_name]
lowercase :Union[str, Any] = feat_extract.pad(
snake_case__ , padding='''max_length''' , max_length=len(speech_inputs[1] ) , truncation=snake_case__ )
lowercase :str = input_a[input_name]
lowercase :Union[str, Any] = feat_extract.pad(
snake_case__ , padding='''max_length''' , max_length=len(speech_inputs[1] ) , return_tensors='''np''' )
lowercase :Optional[Any] = input_a[input_name]
self.assertTrue(input_a.shape[1] == len(speech_inputs[1] ) )
self.assertTrue(_inputs_have_equal_length(snake_case__ ) )
self.assertTrue(_inputs_have_equal_length(snake_case__ ) )
self.assertTrue(_inputs_are_equal(snake_case__ , snake_case__ ) )
# since truncation forces padding to be smaller than longest input
# function can't return `np.ndarray`, but has to return list
self.assertFalse(_inputs_have_equal_length(snake_case__ ) )
self.assertTrue(len(input_a[-1] ) == len(speech_inputs[-1] ) )
# padding has to be max_length when setting `truncation=True`
with self.assertRaises(snake_case__ ):
feat_extract.pad(snake_case__ , truncation=snake_case__ )[input_name]
# padding has to be max_length when setting `truncation=True`
with self.assertRaises(snake_case__ ):
feat_extract.pad(snake_case__ , padding='''longest''' , truncation=snake_case__ )[input_name]
# padding has to be max_length when setting `truncation=True`
with self.assertRaises(snake_case__ ):
feat_extract.pad(snake_case__ , padding='''longest''' , truncation=snake_case__ )[input_name]
# max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
with self.assertRaises(snake_case__ ):
feat_extract.pad(snake_case__ , padding='''max_length''' , truncation=snake_case__ )[input_name]
# test truncation for `pad_to_multiple_of` for List[int] + numpy
lowercase :Dict = 1_2
lowercase :Optional[int] = feat_extract.pad(
snake_case__ , padding='''max_length''' , max_length=len(speech_inputs[0] ) , pad_to_multiple_of=snake_case__ , truncation=snake_case__ , )
lowercase :Union[str, Any] = input_a[input_name]
lowercase :Any = feat_extract.pad(
snake_case__ , padding='''max_length''' , max_length=len(speech_inputs[0] ) , pad_to_multiple_of=snake_case__ , )
lowercase :Tuple = input_a[input_name]
# retrieve expected_length as multiple of pad_to_multiple_of
lowercase :Any = len(speech_inputs[0] )
if expected_length % pad_to_multiple_of != 0:
lowercase :int = ((len(speech_inputs[0] ) // pad_to_multiple_of) + 1) * pad_to_multiple_of
self.assertTrue(len(input_a[0] ) == expected_length )
self.assertTrue(_inputs_have_equal_length(snake_case__ ) )
self.assertFalse(_inputs_have_equal_length(snake_case__ ) )
def __snake_case ( self : Tuple ):
'''simple docstring'''
self._check_padding(numpify=snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
self._check_padding(numpify=snake_case__ )
def __snake_case ( self : List[str] ):
'''simple docstring'''
self._check_truncation(numpify=snake_case__ )
def __snake_case ( self : Any ):
'''simple docstring'''
self._check_truncation(numpify=snake_case__ )
@require_torch
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
lowercase :Optional[int] = self.feature_extraction_class(**self.feat_extract_dict )
lowercase :Any = self.feat_extract_tester.prepare_inputs_for_common()
lowercase :List[str] = feat_extract.model_input_names[0]
lowercase :List[Any] = BatchFeature({input_name: speech_inputs} )
lowercase :Tuple = feat_extract.pad(snake_case__ , padding='''longest''' , return_tensors='''np''' )[input_name]
lowercase :Any = feat_extract.pad(snake_case__ , padding='''longest''' , return_tensors='''pt''' )[input_name]
self.assertTrue(abs(input_np.astype(np.floataa ).sum() - input_pt.numpy().astype(np.floataa ).sum() ) < 1e-2 )
@require_tf
def __snake_case ( self : List[str] ):
'''simple docstring'''
lowercase :Optional[int] = self.feature_extraction_class(**self.feat_extract_dict )
lowercase :Optional[int] = self.feat_extract_tester.prepare_inputs_for_common()
lowercase :Any = feat_extract.model_input_names[0]
lowercase :Optional[Any] = BatchFeature({input_name: speech_inputs} )
lowercase :Optional[Any] = feat_extract.pad(snake_case__ , padding='''longest''' , return_tensors='''np''' )[input_name]
lowercase :Tuple = feat_extract.pad(snake_case__ , padding='''longest''' , return_tensors='''tf''' )[input_name]
self.assertTrue(abs(input_np.astype(np.floataa ).sum() - input_tf.numpy().astype(np.floataa ).sum() ) < 1e-2 )
def __snake_case ( self : int ):
'''simple docstring'''
lowercase :str = self.feat_extract_dict
lowercase :Dict = True
lowercase :Tuple = self.feature_extraction_class(**snake_case__ )
lowercase :Tuple = self.feat_extract_tester.prepare_inputs_for_common()
lowercase :List[Any] = [len(snake_case__ ) for x in speech_inputs]
lowercase :Optional[int] = feat_extract.model_input_names[0]
lowercase :List[str] = BatchFeature({input_name: speech_inputs} )
lowercase :Optional[Any] = feat_extract.pad(snake_case__ , padding='''longest''' , return_tensors='''np''' )
self.assertIn('''attention_mask''' , snake_case__ )
self.assertListEqual(list(processed.attention_mask.shape ) , list(processed[input_name].shape[:2] ) )
self.assertListEqual(processed.attention_mask.sum(-1 ).tolist() , snake_case__ )
def __snake_case ( self : str ):
'''simple docstring'''
lowercase :List[str] = self.feat_extract_dict
lowercase :Any = True
lowercase :Dict = self.feature_extraction_class(**snake_case__ )
lowercase :Any = self.feat_extract_tester.prepare_inputs_for_common()
lowercase :Any = [len(snake_case__ ) for x in speech_inputs]
lowercase :Tuple = feat_extract.model_input_names[0]
lowercase :Dict = BatchFeature({input_name: speech_inputs} )
lowercase :Tuple = min(snake_case__ )
lowercase :Dict = feat_extract.pad(
snake_case__ , padding='''max_length''' , max_length=snake_case__ , truncation=snake_case__ , return_tensors='''np''' )
self.assertIn('''attention_mask''' , snake_case__ )
self.assertListEqual(
list(processed_pad.attention_mask.shape ) , [processed_pad[input_name].shape[0], max_length] )
self.assertListEqual(
processed_pad.attention_mask[:, :max_length].sum(-1 ).tolist() , [max_length for x in speech_inputs] )
| 677 |
"""simple docstring"""
def lowerCamelCase (a_ :Tuple , a_ :int , a_ :Tuple , a_ :List[Any]) -> str:
if height >= 1:
move_tower(height - 1 , a_ , a_ , a_)
move_disk(a_ , a_)
move_tower(height - 1 , a_ , a_ , a_)
def lowerCamelCase (a_ :int , a_ :Union[str, Any]) -> str:
print('''moving disk from''' , a_ , '''to''' , a_)
def lowerCamelCase () -> Tuple:
lowercase :int = int(input('''Height of hanoi: ''').strip())
move_tower(a_ , '''A''' , '''B''' , '''C''')
if __name__ == "__main__":
main()
| 677 | 1 |
"""simple docstring"""
from sklearn.metrics import mean_squared_error
import datasets
UpperCAmelCase = '''\
@article{scikit-learn,
title={Scikit-learn: Machine Learning in {P}ython},
author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
journal={Journal of Machine Learning Research},
volume={12},
pages={2825--2830},
year={2011}
}
'''
UpperCAmelCase = '''\
Mean Squared Error(MSE) is the average of the square of difference between the predicted
and actual values.
'''
UpperCAmelCase = '''
Args:
predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)
Estimated target values.
references: array-like of shape (n_samples,) or (n_samples, n_outputs)
Ground truth (correct) target values.
sample_weight: array-like of shape (n_samples,), default=None
Sample weights.
multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"
Defines aggregating of multiple output values. Array-like value defines weights used to average errors.
"raw_values" : Returns a full set of errors in case of multioutput input.
"uniform_average" : Errors of all outputs are averaged with uniform weight.
squared : bool, default=True
If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.
Returns:
mse : mean squared error.
Examples:
>>> mse_metric = datasets.load_metric("mse")
>>> predictions = [2.5, 0.0, 2, 8]
>>> references = [3, -0.5, 2, 7]
>>> results = mse_metric.compute(predictions=predictions, references=references)
>>> print(results)
{\'mse\': 0.375}
>>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)
>>> print(rmse_result)
{\'mse\': 0.6123724356957945}
If you\'re using multi-dimensional lists, then set the config as follows :
>>> mse_metric = datasets.load_metric("mse", "multilist")
>>> predictions = [[0.5, 1], [-1, 1], [7, -6]]
>>> references = [[0, 2], [-1, 2], [8, -5]]
>>> results = mse_metric.compute(predictions=predictions, references=references)
>>> print(results)
{\'mse\': 0.7083333333333334}
>>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')
>>> print(results) # doctest: +NORMALIZE_WHITESPACE
{\'mse\': array([0.41666667, 1. ])}
'''
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class __magic_name__ ( datasets.Metric ):
def __snake_case ( self : int ):
'''simple docstring'''
return datasets.MetricInfo(
description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(self._get_feature_types() ) , reference_urls=[
'''https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html'''
] , )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
if self.config_name == "multilist":
return {
"predictions": datasets.Sequence(datasets.Value('''float''' ) ),
"references": datasets.Sequence(datasets.Value('''float''' ) ),
}
else:
return {
"predictions": datasets.Value('''float''' ),
"references": datasets.Value('''float''' ),
}
def __snake_case ( self : List[Any] , snake_case__ : str , snake_case__ : int , snake_case__ : str=None , snake_case__ : List[Any]="uniform_average" , snake_case__ : Dict=True ):
'''simple docstring'''
lowercase :Dict = mean_squared_error(
snake_case__ , snake_case__ , sample_weight=snake_case__ , multioutput=snake_case__ , squared=snake_case__ )
return {"mse": mse}
| 677 |
"""simple docstring"""
from sklearn.metrics import mean_squared_error
import datasets
UpperCAmelCase = '''\
@article{scikit-learn,
title={Scikit-learn: Machine Learning in {P}ython},
author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
journal={Journal of Machine Learning Research},
volume={12},
pages={2825--2830},
year={2011}
}
'''
UpperCAmelCase = '''\
Mean Squared Error(MSE) is the average of the square of difference between the predicted
and actual values.
'''
UpperCAmelCase = '''
Args:
predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)
Estimated target values.
references: array-like of shape (n_samples,) or (n_samples, n_outputs)
Ground truth (correct) target values.
sample_weight: array-like of shape (n_samples,), default=None
Sample weights.
multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"
Defines aggregating of multiple output values. Array-like value defines weights used to average errors.
"raw_values" : Returns a full set of errors in case of multioutput input.
"uniform_average" : Errors of all outputs are averaged with uniform weight.
squared : bool, default=True
If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.
Returns:
mse : mean squared error.
Examples:
>>> mse_metric = datasets.load_metric("mse")
>>> predictions = [2.5, 0.0, 2, 8]
>>> references = [3, -0.5, 2, 7]
>>> results = mse_metric.compute(predictions=predictions, references=references)
>>> print(results)
{\'mse\': 0.375}
>>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)
>>> print(rmse_result)
{\'mse\': 0.6123724356957945}
If you\'re using multi-dimensional lists, then set the config as follows :
>>> mse_metric = datasets.load_metric("mse", "multilist")
>>> predictions = [[0.5, 1], [-1, 1], [7, -6]]
>>> references = [[0, 2], [-1, 2], [8, -5]]
>>> results = mse_metric.compute(predictions=predictions, references=references)
>>> print(results)
{\'mse\': 0.7083333333333334}
>>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')
>>> print(results) # doctest: +NORMALIZE_WHITESPACE
{\'mse\': array([0.41666667, 1. ])}
'''
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class __magic_name__ ( datasets.Metric ):
def __snake_case ( self : int ):
'''simple docstring'''
return datasets.MetricInfo(
description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(self._get_feature_types() ) , reference_urls=[
'''https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html'''
] , )
def __snake_case ( self : Optional[Any] ):
'''simple docstring'''
if self.config_name == "multilist":
return {
"predictions": datasets.Sequence(datasets.Value('''float''' ) ),
"references": datasets.Sequence(datasets.Value('''float''' ) ),
}
else:
return {
"predictions": datasets.Value('''float''' ),
"references": datasets.Value('''float''' ),
}
def __snake_case ( self : List[Any] , snake_case__ : str , snake_case__ : int , snake_case__ : str=None , snake_case__ : List[Any]="uniform_average" , snake_case__ : Dict=True ):
'''simple docstring'''
lowercase :Dict = mean_squared_error(
snake_case__ , snake_case__ , sample_weight=snake_case__ , multioutput=snake_case__ , squared=snake_case__ )
return {"mse": mse}
| 677 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.