B #=6\Y@sddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z ddlmZddlmZejddkrddlZnddlZddlZdZedjZedjZed jZd Zd Zd ZGd dde Z!e ddZ"gZ#ddZ$ddZ%ddZ&ddZ'ddZ(ddZ)e$de%e'e$de&e)dd Z*d!d"Z+d#d$Z,d%d&Z-d'd(Z.d)d*Z/d+d,Z0d-d.Z1eefd/d0Z2d1d2Z3defd3d4Z4d5d6Z5dS)7N)closingcontextmanager)_import_dotted_name)string_classesz=lz=iz=hll|9 QC i,c@s eZdZdS)SourceChangeWarningN)__name__ __module__ __qualname__r r 6/tmp/pip-install-l3r2oljg/torch/torch/serialization.pyr sr ccst}|Vt|dS)N)tempfilemkdtempshutilrmtree)pathr r rr$srcCs |||f}t|tdS)N)_package_registryappendsort)prioritytaggerZ deserializerZ queue_elemr r rregister_package.s  rcCst|jdkrdSdS)Ntorchcpu)typer )objr r r_cpu_tag4srcCs"t|jdkrdt|SdS)Nz torch.cudazcuda:)rr strZ get_device)rr r r _cuda_tag9sr cCs|dkr |SdS)Nrr )rlocationr r r_cpu_deserialize>sr"cCst|tjrt|}t|ts&td|dddkr.raise_err_msgTseektell)rZr[rRrSrO)rIrYrVr r r_check_seekables  r\cst|dfddS)aSaves an object to a disk file. See also: :ref:`recommend-saving-models` Args: obj: saved object f: a file-like object (has to implement write and flush) or a string containing a file name pickle_module: module used for pickling metadata and objects pickle_protocol: can be specified to override the default protocol .. warning:: If you are using Python 2, torch.save does NOT support StringIO.StringIO as a valid file-like object. This is because the write method should return the number of bytes written; StringIO.write() does not do this. Please use something like io.BytesIO instead. 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) wbcst|S)N)_save)rI)r pickle_modulepickle_protocolr rszsave..)rM)rrIr_r`r )rr_r`rsavesrbc stjddkr.ddl}t||jr.d}t|ddlmiifdd}tttj dktt t t dd}|j t||d |j t||d |j |||d |j||d }||_| |t} |j | ||d |x | D]} | |t|qWdS) Nrrztorch.save received unsupported StringIO.StringIO file object, whose write method does not return the number of bytes written. Please use something like io.BytesIO for torch.save instead.c st|trt|jr|kr"dSd|<d}}yt|}t|}Wn(tk rrt d|j dYnXd|||fSt |rt t|}d}t|j}t|}||<|j|jk}|rt|j||f}nd}d|||||fSdS)NTz4Couldn't retrieve source code for container of type z3. It won't be checked for correctness upon loading.r?rr4)r%r issubclassModuleinspect getsourcefile getsource Exceptionwarningswarnr rZ is_storager=rZ_cdatar6size) r source_filesourcer<offsetZobj_keyr!Zis_view view_metadata)nnserialized_container_typesserialized_storagesr r persistent_ids:      z_save..persistent_idlittle)shortr*long)protocol_versionZ little_endianZ type_sizes)protocol)rBrCStringIOr%r,Ztorch.nnrpdictPROTOCOL_VERSION byteorder SHORT_SIZEINT_SIZE LONG_SIZEdump MAGIC_NUMBERPicklerrssortedkeysflushZ _write_filerT) rrIr_r`ryrXrsZsys_infoZpicklerZserialized_storage_keyskeyr )rprqrrrr^s6  *    r^cKsrd}t|ts@tjddkr&t|ts@tjddkrNt|tjrNd}t|d}zt|||f|S|rl| XdS)a9Loads an object saved with :func:`torch.save` from a file. :meth:`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 `map_location` argument. If `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 map_location. The builtin location tags are `'cpu'` for CPU tensors and `'cuda:device_id'` (e.g. `'cuda:2'`) for CUDA tensors. `map_location` should return either None or a storage. If `map_location` returns a storage, it will be used as the final deserialized object, already moved to the right device. Otherwise, :math:`torch.load` will fall back to the default behavior, as if `map_location` wasn't specified. If `map_location` is a string, it should be a device tag, where all tensors should be loaded. Otherwise, if `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 `register_package`. Args: f: a file-like object (has to implement read, readline, tell, and seek), or a string containing a file name map_location: a function, 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 pickle_module used to serialize file) pickle_load_args: optional keyword arguments passed over to ``pickle_module.load`` and ``pickle_module.Unpickler``, e.g., ``encoding=...``. .. note:: When you call :meth:`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:: In Python 3, when loading files saved by Python 2, you may encounter ``UnicodeDecodeError: 'ascii' codec can't decode byte 0x...``. This is caused by the difference of handling in byte strings in Python2 and Python 3. You may use extra ``encoding`` keyword argument to specify how these objects should be loaded, e.g., ``encoding='latin1'`` decodes them to strings using ``latin1`` encoding, and ``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') as f: buffer = io.BytesIO(f.read()) >>> torch.load(buffer) FrrrATrbN) r%rrBrCrDrErFrG_loadrH)rI map_locationr_pickle_load_argsrLr r rload,sH  rc sidkrtnVttr*fddn>ttrBfddn&ttjr\fddn fddddfdd }id d fd d }t|t|}|r|dkry||St j k r| dYnXj |f}|t kr tdj |f}|tkr.td|j |f} j|f} || _| } j |f} |rt|nd} x2| D]*}|kst||| |d} q~W| S)Ncs||}t||S)N)getr:)r4r!)rr rrestore_locations z_load..restore_locationcs t|S)N)r:)r4r!)rr rrscst|tS)N)r:r)r4r!)rr rrscs ||}|dkrt||}|S)N)r:)r4r!r9)rr rrs  c Ss>yt|}Wn(tk r6td|jddSX||kr:|jr|jd}tj| d| d||dd}d |}ytt |dL}| dd }| d|dkr| |n|t|ks||krtWdQRXd |d |d } Wn"tk rd |d} YnXnd} dt|| } t| tdS)Nz4Couldn't retrieve source code for container of type z3. It won't be checked for correctness upon loading.z.patch r$)Zlinetermza+rrzSaved 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.z)source code of class '{}' has changed. {})rergrhrirjr Z dump_patchesdifflibZ unified_diffsplitjoinrGrZwritelenreadIOErrorr-rr3r ) Zcontainer_typerlZoriginal_sourceZcurrent_source file_nameZdifflinesrI file_sizerXr r r_check_container_sources:         z&_load.._check_container_sourcec s6ifdd}ttj|dtjd}t}|jd|dttj|ddd}j |f}xDt |D]8}j |f}|\}}} | |} | |} | |<qtWj |f} x0| D](\} } }}| }||||| <qWWdQRX|jd |dttj|d dd}j |f}xt |D]}j |f}|\}}}|}t |}t d |d \}|d t d ||d |}t d ||d |}t d|d \}|||||}||<q8WWdQRX|d}j|f}||_| }|SQRXWdQRXdS)Ncs6t|tr*t|ddr"||dSt|S)Nrr)r%tupleallr*)saved_id)rdeserialized_objectsr rpersistent_loads  z3_load..legacy_load..persistent_loadzr:)fileobjrJr-Zstorages)rrrZtensorsz.legacy_loadcSst|tr|dS|S)Nascii)r%bytesdecode)Z bytes_strr r rmaybe_decode_asciis  z!_load..maybe_decode_asciic st|tst|d}|dd}|dkrNt|ddrF||dS|dkr|\}}}}}|}|kr||||<|}|dk r|\} } } | kr|| | | | <| S|Sntd|ddS)Nrrr?r4zUnknown saved id type: %s)r%rAssertionErrorrr,) rr3dataZ data_typeZroot_keyr!rkror4Zview_keyrnZ view_size)rrrrr rrs*   z_load..persistent_loadrz#Invalid magic number; corrupt file?zInvalid protocol version: %s)r:r%rzr'rr&r\rTr[rTarErrorrZrrr,r{rrrZ_set_from_file)rIrr_rrrZf_should_read_directlyZ magic_numberrwZ _sys_inforr9Zdeserialized_storage_keysrnrr )rrrrrr_rrrsN    )4      r)6rrerrRrrrBrrrri contextlibrr_utilsrZ_sixrr'rCcPicklerrEDEFAULT_PROTOCOLStructrkrr~r}rr{ZSTORAGE_KEY_SEPARATORWarningr rrrrr r"r.r0r6r:r=r@rMrPrTr\rbr^rrr r r rs^           OU