o
i*X @ s d dl Z d dlZd dlZd dlmZmZ d dlZd dlm Z m
Z
ddl m Z ddl
mZ ddlmZmZ ddlmZmZmZmZmZmZ dd lmZ ed
d d Z e e Z G d
d deZG dd d eZ ee j!e _!e j!j"dure j!j"j#dddde j!_"dS dS ) N)AnyTypeVar) create_repois_offline_mode )custom_object_save) BatchFeature)is_valid_image
load_image)IMAGE_PROCESSOR_NAMEPROCESSOR_NAMEPushToHubMixin copy_funcloggingsafe_load_json_file) cached_fileImageProcessorTypeImageProcessingMixin)boundc @ s e Zd ZdZdS )r a
Holds the output of the image processor specific `__call__` methods.
This class is derived from a python dictionary and can be used as a dictionary.
Args:
data (`dict`):
Dictionary of lists/arrays/tensors returned by the __call__ method ('pixel_values', etc.).
tensor_type (`Union[None, str, TensorType]`, *optional*):
You can give a tensor_type here to convert the lists of integers in PyTorch/Numpy Tensors at
initialization.
N)__name__
__module__ __qualname____doc__ r r d/sda-disk/www/egybert/egybert_env/lib/python3.10/site-packages/transformers/image_processing_base.pyr - s r c @ sb e Zd ZdZdZdd Ze d,dee de e
j B d e e
j B dB d
e d e d e e B dB d
e defddZ
d-de e
j B de fddZede e
j B deee ef ee ef f fddZedee ef fddZdee ef fddZed e e
j B fd d Zde fd d Zd!e e
j B fd"d#Zd$d% Zed.d'd(Zd)e ee B eee B fd*d+ZdS )/r z
This is an image processor mixin used to provide saving/loading functionality for sequential and image feature
extractors.
Nc K sv | dd | dd | D ](\}}zt| || W q ty8 } ztd| d| d| |d}~ww dS )z'Set elements of `kwargs` as attributes.feature_extractor_typeNprocessor_classz
Can't set z with value z for )popitemssetattrAttributeErrorloggererror)selfkwargskeyvalueerrr r r __init__E s z ImageProcessingMixin.__init__Fmaincls pretrained_model_name_or_path cache_dirforce_downloadlocal_files_onlytokenrevisionreturnc K sX ||d< ||d< ||d< ||d< |dur||d< | j |fi |\}}| j|fi |S )a
Instantiate a type of [`~image_processing_utils.ImageProcessingMixin`] from an image processor.
Args:
pretrained_model_name_or_path (`str` or `os.PathLike`):
This can be either:
- a string, the *model id* of a pretrained image_processor hosted inside a model repo on
huggingface.co.
- a path to a *directory* containing a image processor file saved using the
[`~image_processing_utils.ImageProcessingMixin.save_pretrained`] method, e.g.,
`./my_model_directory/`.
- a path or url to a saved image processor JSON *file*, e.g.,
`./my_model_directory/preprocessor_config.json`.
cache_dir (`str` or `os.PathLike`, *optional*):
Path to a directory in which a downloaded pretrained model image processor should be cached if the
standard cache should not be used.
force_download (`bool`, *optional*, defaults to `False`):
Whether or not to force to (re-)download the image processor files and override the cached versions if
they exist.
proxies (`dict[str, str]`, *optional*):
A dictionary of proxy servers to use by protocol or endpoint, e.g., `{'http': 'foo.bar:3128',
'http://hostname': 'foo.bar:4012'}.` The proxies are used on each request.
token (`str` or `bool`, *optional*):
The token to use as HTTP bearer authorization for remote files. If `True`, or not specified, will use
the token generated when running `hf auth login` (stored in `~/.huggingface`).
revision (`str`, *optional*, defaults to `"main"`):
The specific model version to use. It can be a branch name, a tag name, or a commit id, since we use a
git-based system for storing models and other artifacts on huggingface.co, so `revision` can be any
identifier allowed by git.
To test a pull request you made on the Hub, you can pass `revision="refs/pr/"`.
return_unused_kwargs (`bool`, *optional*, defaults to `False`):
If `False`, then this function returns just the final image processor object. If `True`, then this
functions returns a `Tuple(image_processor, unused_kwargs)` where *unused_kwargs* is a dictionary
consisting of the key/value pairs whose keys are not image processor attributes: i.e., the part of
`kwargs` which has not been used to update `image_processor` and is otherwise ignored.
subfolder (`str`, *optional*, defaults to `""`):
In case the relevant files are located inside a subfolder of the model repo on huggingface.co, you can
specify the folder name here.
kwargs (`dict[str, Any]`, *optional*):
The values in kwargs of any keys which are image processor attributes will be used to override the
loaded values. Behavior concerning key/value pairs whose keys are *not* image processor attributes is
controlled by the `return_unused_kwargs` keyword parameter.
Returns:
A image processor of type [`~image_processing_utils.ImageProcessingMixin`].
Examples:
```python
# We can't instantiate directly the base class *ImageProcessingMixin* so let's show the examples on a
# derived class: *CLIPImageProcessor*
image_processor = CLIPImageProcessor.from_pretrained(
"openai/clip-vit-base-patch32"
) # Download image_processing_config from huggingface.co and cache.
image_processor = CLIPImageProcessor.from_pretrained(
"./test/saved_model/"
) # E.g. image processor (or model) was saved using *save_pretrained('./test/saved_model/')*
image_processor = CLIPImageProcessor.from_pretrained("./test/saved_model/preprocessor_config.json")
image_processor = CLIPImageProcessor.from_pretrained(
"openai/clip-vit-base-patch32", do_normalize=False, foo=False
)
assert image_processor.do_normalize is False
image_processor, unused_kwargs = CLIPImageProcessor.from_pretrained(
"openai/clip-vit-base-patch32", do_normalize=False, foo=False, return_unused_kwargs=True
)
assert image_processor.do_normalize is False
assert unused_kwargs == {"foo": False}
```r, r- r. r0 Nr/ )get_image_processor_dict from_dict) r* r+ r, r- r. r/ r0 r$ image_processor_dictr r r from_pretrainedT s Wz$ImageProcessingMixin.from_pretrainedsave_directory push_to_hubc K s t j|rtd| dt j|dd |r:|dd}|d|t jjd }t|fd di|j }|
|}| j durFt | || d
t j
|t}| | td | |ri| j|||||d d
|gS )as
Save an image processor object to the directory `save_directory`, so that it can be re-loaded using the
[`~image_processing_utils.ImageProcessingMixin.from_pretrained`] class method.
Args:
save_directory (`str` or `os.PathLike`):
Directory where the image processor JSON file will be saved (will be created if it does not exist).
push_to_hub (`bool`, *optional*, defaults to `False`):
Whether or not to push your model to the Hugging Face model hub after saving it. You can specify the
repository you want to push to with `repo_id` (will default to the name of `save_directory` in your
namespace).
kwargs (`dict[str, Any]`, *optional*):
Additional key word arguments passed along to the [`~utils.PushToHubMixin.push_to_hub`] method.
zProvided path (z#) should be a directory, not a fileT)exist_okcommit_messageNrepo_idr8 )configzImage processor saved in r/ )r9 r/ )ospathisfileAssertionErrormakedirsr splitsepr r: _get_files_timestamps _auto_classr joinr to_json_filer! info_upload_modified_filesget)r# r6 r7 r$ r9 r: files_timestampsoutput_image_processor_filer r r save_pretrained s,
z$ImageProcessingMixin.save_pretrainedc
K s
| dd}| dd}| dd}| dd}| dd}| dd}| d d
} | d t}
| d d} | d
d} d| d}
| durI| |
d< t rU|sUtd d}t|}tj|}tj|rltj ||
}tj
|ry|}d}d}n?|
}z t |t ||||||
|| dd }t ||||||||
|| dd }W n t
y ty t
d| d| d|
dw d}|durt|}d|v r|d }|dur|du rt|}|du rt
d| d| d|
d|rtd| ||fS td| d| ||fS )a
From a `pretrained_model_name_or_path`, resolve to a dictionary of parameters, to be used for instantiating a
image processor of type [`~image_processor_utils.ImageProcessingMixin`] using `from_dict`.
Parameters:
pretrained_model_name_or_path (`str` or `os.PathLike`):
The identifier of the pre-trained checkpoint from which we want the dictionary of parameters.
subfolder (`str`, *optional*, defaults to `""`):
In case the relevant files are located inside a subfolder of the model repo on huggingface.co, you can
specify the folder name here.
image_processor_filename (`str`, *optional*, defaults to `"config.json"`):
The name of the file in the model directory to use for the image processor config.
Returns:
`tuple[Dict, Dict]`: The dictionary(ies) that will be used to instantiate the image processor object.
r, Nr- Fproxiesr/ r. r0 subfolder image_processor_filename_from_pipeline
_from_autoimage processor) file_typefrom_auto_classusing_pipelinez+Offline mode: forcing local_files_only=TrueT)
filenamer, r- rN r. r/
user_agentr0 rO %_raise_exceptions_for_missing_entriesz Can't load image processor for 'z'. If you were trying to load it from 'https://huggingface.co/models', make sure you don't have a local directory with the same name. Otherwise, make sure 'z2' is the correct path to a directory containing a z fileimage_processorzloading configuration file z from cache at )r r r r! rH strr= r> isdirrF r? r r OSError Exceptionr )r* r+ r$ r, r- rN r/ r. r0 rO rQ
from_pipelinerV rY is_localimage_processor_file resolved_image_processor_fileresolved_processor_filer4 processor_dictr r r r2 s
z-ImageProcessingMixin.get_image_processor_dictr4 c s | }|dd}| fdd| D di |}t|D ] }t||r/|| q#td| |r>||fS |S )a
Instantiates a type of [`~image_processing_utils.ImageProcessingMixin`] from a Python dictionary of parameters.
Args:
image_processor_dict (`dict[str, Any]`):
Dictionary that will be used to instantiate the image processor object. Such a dictionary can be
retrieved from a pretrained checkpoint by leveraging the
[`~image_processing_utils.ImageProcessingMixin.to_dict`] method.
kwargs (`dict[str, Any]`):
Additional parameters from which to initialize the image processor object.
Returns:
[`~image_processing_utils.ImageProcessingMixin`]: The image processor object instantiated from those
parameters.
return_unused_kwargsFc s" i | ]
\}}| j jv r||qS r ) valid_kwargs__annotations__).0kvr* r r
q s " z2ImageProcessingMixin.from_dict..zImage processor Nr )copyr updater listhasattrr! rH )r* r4 r$ rf r[ r% r rl r r3 ^ s
z ImageProcessingMixin.from_dictc C s t | j}| jj|d< |S )z
Serializes this instance to a Python dictionary.
Returns:
`dict[str, Any]`: Dictionary of all the attributes that make up this image processor instance.
image_processor_type)rn deepcopy__dict__ __class__r )r# outputr r r to_dict s z ImageProcessingMixin.to_dict json_filec C sL t |dd }| }W d n1 sw Y t|}| di |S )a
Instantiates a image processor of type [`~image_processing_utils.ImageProcessingMixin`] from the path to a JSON
file of parameters.
Args:
json_file (`str` or `os.PathLike`):
Path to the JSON file containing the parameters.
Returns:
A image processor of type [`~image_processing_utils.ImageProcessingMixin`]: The image_processor object
instantiated from that JSON file.
utf-8encodingNr )openreadjsonloads)r* rx readertextr4 r r r from_json_file s
z#ImageProcessingMixin.from_json_filec C sF | }| D ]\}}t|tjr| ||< qtj|dddd S )z
Serializes this instance to a JSON string.
Returns:
`str`: String containing all the attributes that make up this feature_extractor instance in JSON format.
T)indent sort_keys
)rw r
isinstancenpndarraytolistr~ dumps)r#
dictionaryr% r& r r r to_json_string s z#ImageProcessingMixin.to_json_stringjson_file_pathc C sB t |ddd}|| W d dS 1 sw Y dS )z
Save this instance to a JSON file.
Args:
json_file_path (`str` or `os.PathLike`):
Path to the JSON file in which this image_processor instance's parameters will be saved.
wry rz N)r| writer )r# r writerr r r rG s "z!ImageProcessingMixin.to_json_filec C s | j j d| S )N )ru r r r# r r r __repr__ s z ImageProcessingMixin.__repr__AutoImageProcessorc C sD t |ts|j}ddlm m} t||s t| d|| _dS )a{
Register this class with a given auto class. This should only be used for custom image processors as the ones
in the library are already mapped with `AutoImageProcessor `.
Args:
auto_class (`str` or `type`, *optional*, defaults to `"AutoImageProcessor "`):
The auto class to register this new image processor with.
r Nz is not a valid auto class.) r r\ r transformers.models.automodelsautorq
ValueErrorrE )r*
auto_class auto_moduler r r register_for_auto_class s
z,ImageProcessingMixin.register_for_auto_classimage_url_or_urlsc sL t |tr fdd|D S t |trt|S t|r |S tdt| )z
Convert a single or a list of urls into the corresponding `PIL.Image` objects.
If a single url is passed, the return value will be a single object. If a list is passed a list of objects is
returned.
c s g | ]} |qS r ) fetch_images)ri xr r r
s z5ImageProcessingMixin.fetch_images..z=only a single or a list of entries is supported but got type=)r rp r\ r
r TypeErrortype)r# r r r r r s
z!ImageProcessingMixin.fetch_images)NFFNr) )F)r ) r r r r rE r( classmethodr r r\ r= PathLikeboolr5 rM tupledictr r2 r3 rw r r rG r r rp r r r r r r = sZ
b0 v &rT r zimage processor file)object object_class object_files)$rn r~ r= typingr r numpyr huggingface_hubr r dynamic_module_utilsr feature_extraction_utilsr BaseBatchFeature image_utilsr r
utilsr r r
r r r utils.hubr r
get_loggerr r! r r7 r formatr r r r s0
(