/usr/local/lib64/python3.6/site-packages/torch/__pycache__
Edit: /usr/local/lib64/python3.6/site-packages/torch/__pycache__/serialization.cpython-36.pyc (28582B)
3
Eg @ s d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl
m Z m Z ddl
mZ ddlmZ d dlmZ d dlmZ d dlmZmZmZmZmZm Z m Z m Z m Z d dl Z d dl!Z!d dl"Z"d Z#ej$d
j%Z&ej$d j%Z'ej$d j%Z(d
Z)dZ*dZ+G dd de,Z-e dd Z.g Z/e0dddZ1dd Z2dfddZ3d d Z4d d Z5d d! Z6d"d# Z7d$d% Z8e2d&e4e6 e2d'e5e8 ed(d)d*Z9d+d, Z:d-d. Z;d/d0 Z
Z?G d5d6 d6e?Z@G d7d8 d8e?ZAG d9d: d:e?ZBd;d< ZCG d=d> d>e?ZDG d?d@ d@e?ZEG dAdB dBe?ZFdCdD ZGe0ddEdFZHdGdH ZIe0ddIdJZJdddKdLZKe!e#dfe eLejMee eN f ddMdNdOZOdddPdQZPdRdS ZQde!fdTdUZRdVdW ZSi eS_Te j!ejUdXdY dZd[ ZVe eNeLf eLd\d]d^ZWd_d` ZXdgdbdcZYddde ZZdS )h N)closingcontextmanager )_import_dotted_name)string_classes)get_source_lines_and_file)Storage) AnyBinaryIOcastDictOptionalTypeTupleUnionIO z=lz=iz=hl l|9
QC
i ,c @ s e Zd ZdS )SourceChangeWarningN)__name__
__module__ __qualname__ r r ?/usr/local/lib64/python3.6/site-packages/torch/serialization.pyr s r c c s t j } | V tj| d S )N)tempfilemkdtempshutilrmtree)pathr r r r # s r )returnc C sd g }| j }| jd}x.|dkrD|j| t|dkr8P | jd}qW | j| ddddg}||kS )Nr P K )tellreadappendlenseek)f
read_bytesstartbyteZlocal_header_magic_numberr r r _is_zipfile- s
r/ c C s | ||f}t j| t j d S )N)_package_registryr( sort)prioritytaggerZ deserializerZ
queue_elemr r r register_packageE s
r4 Tc s y2| j jd t fddt|D }||k}W nZ tk
r } z>d| j| j t|f }|rjt||ntj |d d}W Y dd}~X nX |S )a
Check if a module's version satisfies requirements
Usually, a module's version string will be like 'x.y.z', which would be represented
as a tuple (x, y, z), but sometimes it could be an unexpected format. If the version
string does not match the given tuple's format up to the length of the tuple, then
error and exit or emit a warning.
Args:
module: the module to check the version of
req_version_tuple: tuple (usually of ints) representing the required version
error_if_malformed: whether we should exit if module version string is malformed
Returns:
requirement_is_met: bool
.c 3 s" | ]\}}t | | V qd S )N)type).0idxZ req_field) version_strsr r ` s z8check_module_version_greater_or_equal..zQ'%s' module version string is malformed '%s' and cannot be compared with tuple %sz1, but continuing assuming that requirement is metTN)
__version__splittuple enumerate Exceptionr str RuntimeErrorwarningswarn)moduleZreq_version_tupleZerror_if_malformedZmodule_versionZrequirement_is_metemessager )r9 r %check_module_version_greater_or_equalK s rG c C s t | jdkrdS d S )Ntorchcpu)r6 r )objr r r _cpu_tagt s rK c C s" t | jdkr dt| j S d S )Nz
torch.cudazcuda:)r6 r r@ Z
get_device)rJ r r r _cuda_tagy s rL c C s |dkr | S d S )NrI r )rJ locationr r r _cpu_deserialize~ s rN c C sN t jjj| d}t jj s"tdt jj }||krJtd| d| d|S )NTzAttempting to deserialize object on a CUDA device but torch.cuda.is_available() is False. If you are running on a CPU-only machine, please use torch.load with map_location=torch.device('cpu') to map your storages to the CPU.z0Attempting to deserialize object on CUDA device z" but torch.cuda.device_count() is zU. Please use torch.load with map_location to map your storages to an existing device.)rH cuda_utilsZ_get_device_indexZ is_availablerA device_count)rM devicerQ r r r validate_cuda_device s
rS c C s` |j dr\t|}t| ddrRttjt| j}tjj| || j S Q R X n
| j|S d S )NrO _torch_load_uninitializedF)
startswithrS getattrrH rO r6 r rR size)rJ rM rR storage_typer r r _cuda_deserialize s
rY
)storagec C s: x"t D ]\}}}|| }|r|S qW tdtj| d S )Nz-don't know how to determine data location of )r0 rA rH typename)r\ _r3 rM r r r location_tag s r_ c C sL x(t D ] \}}}|| |}|d k r|S qW tdtj| d | d d S )Nz+don't know how to restore data location of z (tagged with ))r0 rA rH r] )r\ rM r^ fnresultr r r default_restore_location s
rc c C s t t| jS )N)rV rH r )rX r r r normalize_storage_type s rd c C s& t | }t|j}t||jjddS )Nr ZTensor)r6 r r rV r replace)r\ rX rD r r r storage_to_tensor_type s
rf c C s t | tpt | tjS )N)
isinstancer@ pathlibPath)name_or_bufferr r r _is_path s
rk c @ s$ e Zd Zdd Zdd Zdd ZdS )_openerc C s
|| _ d S )N) file_like)selfrm r r r __init__ s z_opener.__init__c C s | j S )N)rm )rn r r r __enter__ s z_opener.__enter__c G s d S )Nr )rn argsr r r __exit__ s z_opener.__exit__N)r r r ro rp rr r r r r rl s rl c s$ e Zd Z fddZdd Z ZS )
_open_filec s t t| jt|| d S )N)superrs ro open)rn namemode) __class__r r ro s z_open_file.__init__c G s | j j d S )N)rm close)rn rq r r r rr s z_open_file.__exit__)r r r ro rr
__classcell__r r )rx r rs s rs c s e Zd Z fddZ ZS )_open_buffer_readerc s t t| j| t| d S )N)rt r{ ro _check_seekable)rn buffer)rx r r ro s z _open_buffer_reader.__init__)r r r ro rz r r )rx r r{ s r{ c @ s e Zd Zdd ZdS )_open_buffer_writerc G s | j j d S )N)rm flush)rn rq r r r rr s z _open_buffer_writer.__exit__N)r r r rr r r r r r~ s r~ c C sD t | rt| |S d|kr"t| S d|kr2t| S td| d S )Nwrz$Expected 'r' or 'w' in mode but got )rk rs r~ r{ rA )rj rw r r r _open_file_like s
r c s" e Zd Zdd fdd Z ZS )_open_zipfile_readerN)r c s t t| jtjj| d S )N)rt r ro rH _CZPyTorchFileReader)rn rj )rx r r ro s z _open_zipfile_reader.__init__)r r r ro rz r r )rx r r s r c s0 e Zd Zdd fdd ZddddZ ZS )_open_zipfile_writer_fileN)r c s t t| jtjjt| d S )N)rt r ro rH r PyTorchFileWriterr@ )rn rv )rx r r ro s z"_open_zipfile_writer_file.__init__c G s | j j d S )N)rm write_end_of_file)rn rq r r r rr s z"_open_zipfile_writer_file.__exit__)r r r ro rr rz r r )rx r r s r c s0 e Zd Zdd fdd ZddddZ ZS )_open_zipfile_writer_bufferN)r c s" || _ tt| jtjj| d S )N)r} rt r ro rH r r )rn r} )rx r r ro s z$_open_zipfile_writer_buffer.__init__c G s | j j | jj d S )N)rm r r} r )rn rq r r r rr s
z$_open_zipfile_writer_buffer.__exit__)r r r ro rr rz r r )rx r r s r c C s t | rt}nt}|| S )N)rk r r )rj containerr r r _open_zipfile_writer s r c C s* dg}y
| j |kS tk
r$ dS X d S )NgzipF)r AttributeError)r+ Zcompress_modulesr r r _is_compressed_file s
r c C sF t | r dS y | j dkS tjk
r. dS tk
r@ dS X dS )z
Checks if f is a file that should be read directly. It should be read
directly if it is backed by a real file (has a fileno) and is not a
a compressed file (e.g. gzip)
Fr N)r filenoioUnsupportedOperationr )r+ r r r _should_read_directly s r c C sV dd }y| j | j dS tjtfk
rP } z|ddg| W Y d d }~X nX dS )Nc S sB x8| D ]0}|t |krt |d d d }t||qW |d S )Nz7. You can only torch.load from a file that is seekable.z; Please pre-load the data into a buffer like io.BytesIO andz try to load from it instead.)r@ r6 )patternsrE pmsgr r r
raise_err_msg* s
z&_check_seekable..raise_err_msgTr* r& F)r* r& r r r )r+ r rE r r r r| ( s r| c C s@ | j dkr= %s, but you have dill %s. Please upgrade dill or switch to 'pickle'r5 c S s g | ] }t |qS r )r@ )r7 numr r r
I s z'_check_dill_version..N)r r r )r rG
ValueErrorjoinr; )
pickle_moduleZrequired_dill_versionr r r _check_dill_version: s
r )r+ r c C sV t | t|d:}|r:t|}t| ||| dS Q R X t| ||| W dQ R X dS )a save(obj, f, pickle_module=pickle, pickle_protocol=DEFAULT_PROTOCOL, _use_new_zipfile_serialization=True)
Saves an object to a disk file.
See also: :ref:`saving-loading-tensors`
Args:
obj: saved object
f: a file-like object (has to implement write and flush) or a string or
os.PathLike object containing a file name
pickle_module: module used for pickling metadata and objects
pickle_protocol: can be specified to override the default protocol
.. note::
A common PyTorch convention is to save tensors using .pt file extension.
.. note::
PyTorch preserves storage sharing across serialization. See
:ref:`preserve-storage-sharing` for more details.
.. note::
The 1.6 release of PyTorch switched ``torch.save`` to use a new
zipfile-based file format. ``torch.load`` still retains the ability to
load files in the old format. If for any reason you want ``torch.save``
to use the old format, pass the kwarg ``_use_new_zipfile_serialization=False``.
Example:
>>> # Save to file
>>> x = torch.tensor([0, 1, 2, 3, 4])
>>> torch.save(x, 'tensor.pt')
>>> # Save to io.BytesIO buffer
>>> buffer = io.BytesIO()
>>> torch.save(x, buffer)
wbN)r r r _save _legacy_save)rJ r+ r pickle_protocolZ _use_new_zipfile_serialization opened_fileopened_zipfiler r r saveM s )
r c s dd l j i i ttt d fdd }tttjdktt t
t dd}|j t
||d |j t||d |j |||d |j||d}||_|j | tj }|j |||d |j x"|D ]}| j|t|d qW d S )
Nr )rJ r c s t | trt| jr| kr"d S d| < d }}y t| \}}}dj|}W n( tk
rv tjd| j d Y nX d| ||fS t
j | rt t
| } tt| }d}t| j}t| }| |< | j| jk} | rt| j|| j f}
nd }
d|||| j |
fS d S )NTr z4Couldn't retrieve source code for container of type z3. It won't be checked for correctness upon loading.rD r r\ )rg r6
issubclassModuler r r? rB rC r rH
is_storager r rd r@ _cdatar_ rW ) rJ source_filesourceZ source_linesr^ rX offsetobj_keyrM Zis_view
view_metadata)nnserialized_container_typesserialized_storagesr r
persistent_id s<
z#_legacy_save..persistent_idlittle)shortintlong)protocol_versionZ
little_endianZ
type_sizes)protocolT)Ztorch.nnr r r
r dictPROTOCOL_VERSIONsys byteorder
SHORT_SIZEINT_SIZE LONG_SIZEdump MAGIC_NUMBERPicklerr sortedkeysr Z _write_filer ) rJ r+ r r r Zsys_infopicklerZserialized_storage_keyskeyr )r r r r r s,
,
r c s i i fdd}t j }|j||d}||_|j| |j }|jd|t| x\tj D ]L}d| } | }
|
j
j dkr|
j }
|
j
|
j } |j| |
j | qdW d S )Nc sR t j| rNtt| } j| jtt }t| }| |< d|||| j fS d S )Nr\ )
rH r rd r6
setdefaultr r@ r) r_ rW )rJ rX r rM )id_mapr r r r s
z _save..persistent_id)r zdata.pklzdata/rI )r BytesIOr r r getvalueZ write_recordr) r r rR r6 rI rW Z element_sizeZdata_ptr) rJ zip_filer r r Zdata_bufr Z
data_valuer rv r\ num_bytesr )r r r r s
r c K s t | d|j kr d|d< t| dl}t|r|j }t|<}t|rltjdt |j
| t j j
|S t|||f|S Q R X t|||f|S Q R X dS )a} load(f, map_location=None, pickle_module=pickle, **pickle_load_args)
Loads an object saved with :func:`torch.save` from a file.
:func:`torch.load` uses Python's unpickling facilities but treats storages,
which underlie tensors, specially. They are first deserialized on the
CPU and are then moved to the device they were saved from. If this fails
(e.g. because the run time system doesn't have certain devices), an exception
is raised. However, storages can be dynamically remapped to an alternative
set of devices using the :attr:`map_location` argument.
If :attr:`map_location` is a callable, it will be called once for each serialized
storage with two arguments: storage and location. The storage argument
will be the initial deserialization of the storage, residing on the CPU.
Each serialized storage has a location tag associated with it which
identifies the device it was saved from, and this tag is the second
argument passed to :attr:`map_location`. The builtin location tags are ``'cpu'``
for CPU tensors and ``'cuda:device_id'`` (e.g. ``'cuda:2'``) for CUDA tensors.
:attr:`map_location` should return either ``None`` or a storage. If
:attr:`map_location` returns a storage, it will be used as the final deserialized
object, already moved to the right device. Otherwise, :func:`torch.load` will
fall back to the default behavior, as if :attr:`map_location` wasn't specified.
If :attr:`map_location` is a :class:`torch.device` object or a string containing
a device tag, it indicates the location where all tensors should be loaded.
Otherwise, if :attr:`map_location` is a dict, it will be used to remap location tags
appearing in the file (keys), to ones that specify where to put the
storages (values).
User extensions can register their own location tags and tagging and
deserialization methods using :func:`torch.serialization.register_package`.
Args:
f: a file-like object (has to implement :meth:`read`, :meth:`readline`, :meth:`tell`, and :meth:`seek`),
or a string or os.PathLike object containing a file name
map_location: a function, :class:`torch.device`, string or a dict specifying how to remap storage
locations
pickle_module: module used for unpickling metadata and objects (has to
match the :attr:`pickle_module` used to serialize file)
pickle_load_args: (Python 3 only) optional keyword arguments passed over to
:func:`pickle_module.load` and :func:`pickle_module.Unpickler`, e.g.,
:attr:`errors=...`.
.. warning::
:func:`torch.load()` uses ``pickle`` module implicitly, which is known to be insecure.
It is possible to construct malicious pickle data which will execute arbitrary code
during unpickling. Never load data that could have come from an untrusted
source, or that could have been tampered with. **Only load data you trust**.
.. note::
When you call :func:`torch.load()` on a file which contains GPU tensors, those tensors
will be loaded to GPU by default. You can call ``torch.load(.., map_location='cpu')``
and then :meth:`load_state_dict` to avoid GPU RAM surge when loading a model checkpoint.
.. note::
By default, we decode byte strings as ``utf-8``. This is to avoid a common error
case ``UnicodeDecodeError: 'ascii' codec can't decode byte 0x...``
when loading files saved by Python 2 in Python 3. If this default
is incorrect, you may use an extra :attr:`encoding` keyword argument to specify how
these objects should be loaded, e.g., :attr:`encoding='latin1'` decodes them
to strings using ``latin1`` encoding, and :attr:`encoding='bytes'` keeps them
as byte arrays which can be decoded later with ``byte_array.decode(...)``.
Example:
>>> torch.load('tensors.pt')
# Load all tensors onto the CPU
>>> torch.load('tensors.pt', map_location=torch.device('cpu'))
# Load all tensors onto the CPU, using a function
>>> torch.load('tensors.pt', map_location=lambda storage, loc: storage)
# Load all tensors onto GPU 1
>>> torch.load('tensors.pt', map_location=lambda storage, loc: storage.cuda(1))
# Map tensors from GPU 1 to GPU 0
>>> torch.load('tensors.pt', map_location={'cuda:1':'cuda:0'})
# Load tensor from io.BytesIO object
>>> with open('tensor.pt', 'rb') as f:
... buffer = io.BytesIO(f.read())
>>> torch.load(buffer)
# Load a module with 'ascii' encoding for unpickling
>>> torch.load('module.pt', encoding='ascii')
encodingzutf-8rbz'torch.load' received a zip file that looks like a TorchScript archive dispatching to 'torch.jit.load' (call 'torch.jit.load' directly to silence this warning)N)r r r r/ r& r _is_torchscript_ziprB rC UserWarningr* rH Zjitload_load _legacy_load)r+ map_locationr pickle_load_argsr Z
orig_positionr r r r r s W
r c C s> t j}|s6x*tjj D ] }t|tjr||t|< qW || S )z@Get layout extension object from its string representation.
) _get_layoutcacherH __dict__valuesrg layoutr@ )rv r vr r r r e s r c C s t t| ffS )N)r r@ )rJ r r r q s r c
s i t |dd fdd}i fdd}t| t| }|r| j dkry|| S tjk
r t| rt| j dd | j d Y nX t
| d rdt j kodk n rtd
t
| dj| f}|tk rtdj| f}|tkr td| j| f} j| f}
||
_|
j } j| f} |rb| j nd }
x@| D ]8}|ks~t| j| |
| |
d k rl| j }
qlW tjj | S )Nc
S sJ ydj t| d }W n( tk
r> tjd| j d d S X ||krF| jr | jd }tj|j d|j d||dd}dj |}ytt
|dL}|j dd }|j d |dkr|j | n |t
|ks|j |krtW d Q R X d
| d | d } W n" tk
r d
| d } Y nX nd} dtj| d| } tj| t d S )Nr r z4Couldn't retrieve source code for container of type z3. It won't be checked for correctness upon loading.z.patch
)Zlinetermza+r zSaved a reverse patch to z. Run `patch -p0 < z` to revert your changes.z;Tried to save a patch, but couldn't create a writable file zD. Make sure it doesn't exist and your working directory is writable.zyou can retrieve the original source code by accessing the object's source attribute or set `torch.nn.Module.dump_patches = True` and use the patch tool to revert the changes.zsource code of class 'z' has changed. )r r r? rB rC r Z dump_patchesdifflibZ unified_diffr< ru r* writer) r' IOErrorrH r] r )
Zcontainer_typer Zoriginal_sourceZcurrent_source file_nameZdifflinesr+ file_sizer r r r _check_container_sourcey s8
z-_legacy_load.._check_container_sourcec " s: i fdd}t tj| dtjd}t }|jd|d ttjj|ddd} j | f}xDt
|D ]8}j | f}|\}}} | j | }
|
|}
|
|< qtW j | f} x0| D ](\} }
}} |
}|||| | < qW W d Q R X |jd |d ttjj|d dd} j | f}xt
|D ]}j | f}|\}}} | }t |}t
jd
| jd \}| jd t
jd | d
| jd| }t
jd | d
| jd| }t
jd| jd\}| j||||}| |< q8W W d Q R X |jd}j|f} || _| j } | S Q R X W d Q R X d S )Nc s6 t | tr*t| dd r" | | d S t| S )Nr r )rg r= allr )saved_id)r deserialized_objectsr r persistent_load s
z:_legacy_load..legacy_load..persistent_loadzr:)fileobjrw formatZstorages)r r r Ztensorsz.legacy_loadc
s t | tstt| d }| dd }|dkrNt|dd rF | |d S |dkr|\}}}}}t|}|kr||}d|_|||< | } |d k r|\}
} } |
kr| | | | |
< |
S | S ntd| d d S )Nr r rD r\ TzUnknown saved id type: %s)rg r= AssertionError_maybe_decode_asciir rT rA )
r r] data data_typeZroot_keyrM rW r rJ r\ Zview_keyr Z view_size)r r r r r r s,
z%_legacy_load..persistent_loadr z9 is a zip archive (did you mean to use torch.jit.load()?)readintor r r ztorch.load does not work with file-like objects that do not implement readinto on Python 3.8.0 and 3.8.1. Received object of type "zH". Please update to Python 3.8.2 or newer to restore this functionality.z#Invalid magic number; corrupt file?z Invalid protocol version: %s)r r r )r r r )_get_restore_locationr| r r& r TarErrorr/ rA rv r* hasattrr version_infor6 r r r r r r Z_set_from_filerH rP _validate_loaded_sparse_tensors)r+ r r r r r Zf_should_read_directlyZ magic_numberr Z _sys_infor rb Zdeserialized_storage_keysr r r )r r r r r r r t sL (4 &
r ) bytes_strr c C s t | tr| jdS | S )Nascii)rg bytesdecode)r r r r r # s
r c sh d krt }nVt tr& fdd}n>t tr> fdd}n&t tjrX fdd}n fdd}|S )Nc s j ||}t| |S )N)getrc )r\ rM )r r r r 3 s z/_get_restore_location..restore_locationc s
t | S )N)rc )r\ rM )r r r r 7 s c s t | t S )N)rc r@ )r\ rM )r r r r : s c s | |}|d kr t | |}|S )N)rc )r\ rM rb )r r r r = s
)rc rg r _string_classesrH rR )r r r )r r r / s
r data.pklc
s t |i fddfdd}ddi G fddd|j}tjj|}||f|}||_|j } tjj | S ) Nc s8 d| }| dj }j|||j }|| |< d S )Nzdata/r )dtypeZget_storage_from_recordr\ )r rW r rM rv r r\ )loaded_storagesr r r r load_tensorI s
z_load..load_tensorc sp t | tstt| d }| dd }|dks>td| d|\}}}}|krd |||t| | }|S )Nr r r\ zBUnknown typename for persistent_load, expected 'storage' but got '')rg r= r r )r r] r r r rM rW r\ )r r r r r P s
z _load..persistent_loadz torch.tensorz
torch._tensorc s e Zd Z fddZ ZS )z _load..UnpicklerWrapperc s j ||}t j||S )N)r
rt
find_class)rn mod_namerv )rx load_module_mappingr r r i s z*_load..UnpicklerWrapper.find_class)r r r r rz r )r )rx r UnpicklerWrappere s r )
r r r r Z
get_recordr r rH rP r )
r r r r r r r Z data_filer rb r )r r r r r r r D s
r c C s d| j kS )Nz
constants.pkl)Zget_all_records)r r r r r y s r )T)r )[r r r r r r rH r r rB
contextlibr r rP r Z_sixr r Ztorch._sourcesr Z torch.typesr typingr r
r r r
r r r r copyregr rh DEFAULT_PROTOCOLStructrW r r r r r ZSTORAGE_KEY_SEPARATORWarningr r r0 boolr/ r4 rG rK rL rN rS rY r_ rc rd rf rk objectrl rs r{ r~ r r r r r r r r| r r@ PathLiker r r r r r r r r r r r r r r r r s ,
)
*2I-o 0
5