o
    hdf                  	   @   s`  U d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dlm	Z	m
Z
mZmZ d dlZd dlmZ d dlmZ d dlmZmZ d dlmZ d d	lmZ d d
lmZmZmZmZmZmZm Z m!Z! d dl"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z) d dl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 d dl2m3Z3 d dl4m5Z5 ddl6m7Z7 e8e9Z:ej;e<d< g dZ=G dd de'Z>G dd de$Z?G dd de?Z@	d6deAeBe	f dedeCde#fddZDd eEe# deEe# fd!d"ZFdeAeBe	f d#eCde&fd$d%ZG	d6d eEe& d&eCdeHeEe& ef fd'd(ZIdedefd)d*ZJd+ed,edeCfd-d.ZKd/ejLd0edeCfd1d2ZMd3eEe& dedeCfd4d5ZNdS )7    N)ChainMap)reduce)AnycastOptionalUnion)narrow_tensor_by_index)dedup_save_plans)FLATTEN_MAPPINGflatten_state_dict)_flatten_sharded_tensors)set_element)BytesStorageMetadataChunkStorageMetadataMetadataMetadataIndexSTATE_DICT_TYPESTORAGE_TYPESStorageMetaTensorStorageMetadata)LoadPlanLoadPlannerReadItemSavePlanSavePlanner	WriteItemWriteItemType)_compare_save_plans_contains_usable_plan"_create_default_metadata_only_plan_create_read_items_create_write_items_init_state_dict_merge_delta_local_plans)find_state_dict_object)DTensor   )_versionlogger)DefaultSavePlannerDefaultLoadPlannercreate_default_local_load_plancreate_default_global_load_plancreate_default_local_save_plancreate_default_global_save_planc                   @   sf  e Zd ZU eed< 					d+dededee ded	ed
dfddZ		d,dedee	 ded
dfddZ
d
efddZdee d
ee fddZdee d
eee ef fddZdee d
eee ee ef fddZdee d
eee ef fddZded
efddZded
efd d!Zd"ed
eejejf fd#d$Zd%ed
efd&d'Zd"ed(efd)d*Z dS )-r)   mappingsTNFr   flatten_sharded_tensorsdedup_replicated_tensorsdedup_save_to_lowest_rankenable_plan_cachingreturnc                 C   s>   || _ || _i | _|| _|d urtd | jj| _|| _	d S )NzDefaultSavePlanner's `dedup_replicated_tensors` argument is being deprecated, and no longer has any effect. Please remove this argument from your call.)
r   r0   r/   r2   r(   warning	__class____name___cached_plans_key_enable_plan_caching)selfr   r0   r1   r2   r3    r;   r/home/www/facesmatcher.com/frenv_anti/lib/python3.10/site-packages/torch/distributed/checkpoint/default_planner.py__init__H   s   

zDefaultSavePlanner.__init__
state_dictstorage_metais_coordinatorc                 C   s2   | j r
t |\}| _| jrt|}|| _|| _d S N)r   r/   r0   r   r>   r@   )r:   r>   r?   r@   r;   r;   r<   set_up_planner]   s   
z!DefaultSavePlanner.set_up_plannerc                 C   sv   t | j| j}| jrtj|| jd}|| _| jr8| j	t
jv r2t|t
j| j	 r2td tg ddS |t
j| j	< | jS )Nplanner_datazINo change in the local plan. Skipping sending the plan to the coordinatorFusable)r-   r>   r@   r   dataclassesreplacer/   planr9   r8   r   Z_cached_save_planr   r(   infor   )r:   rI   r;   r;   r<   create_local_planj   s"   
z$DefaultSavePlanner.create_local_plan	all_plansc                 C   s   t || jS rA   )r	   r2   )r:   rL   r;   r;   r<   _dedup_save_plans   s   z$DefaultSavePlanner._dedup_save_plansc                 C   s^   |  |}t|\}}| jr"dd |D }tt| }tj||d}t||s+td||fS )Nc                 S   s   g | ]}|j qS r;   rC   ).0pr;   r;   r<   
<listcomp>   s    z:DefaultSavePlanner._create_global_plan.<locals>.<listcomp>rC   zFailed to validate global plan)	rM   r.   r   dictr   rG   rH   _validate_global_plan
ValueError)r:   rL   Zdeduped_plansglobal_planmetadataZplanner_data_dictZmerged_mappingsr;   r;   r<   _create_global_plan   s   

z&DefaultSavePlanner._create_global_planc                 C   s"  g }| j tjvr&|tj| j < | |\}}|tj| j < |tj| j < |||fS t|sBtg ddgt| }tj| j  }tj| j  }nJt	tj| j  |}|tj| j < | |\}}| j | jv rt
tj| j  |D ]\}}t||rz|tg dd qg|| qg|tj| j < |tj| j < |||fS )zw
        Create global plan with caching.
        Returns a tuple of global_plan_delta, global_plan, metadata.
        FrE   )r8   r   Z_cached_all_plansrV   Z_cached_global_planZ_cached_metadatar   r   lenr#   zipr   append)r:   rL   global_plan_deltarT   rU   Zmerged_plansZcached_plannew_planr;   r;   r<    _create_global_plan_with_caching   s4   


z3DefaultSavePlanner._create_global_plan_with_cachingc                 C   sD   g }| j r| |\}}}n	| |\}}|}|| _|| _|| jfS rA   )r9   r\   rV   rT   rU   )r:   rL   rZ   rT   rU   r;   r;   r<   create_global_plan   s   
z%DefaultSavePlanner.create_global_planr[   c                 C   s.   |}|j stj| j }|S |}|tj| j< |S rA   )rF   r   Z_cached_final_save_planr8   r:   r[   Zfinished_planr;   r;   r<   _finish_plan_with_caching   s   z,DefaultSavePlanner._finish_plan_with_cachingc                 C   s    |}| j r
| |}|| _| jS rA   )r9   r_   rI   r^   r;   r;   r<   finish_plan   s
   
zDefaultSavePlanner.finish_plan
write_itemc                 C      |  |j}| ||S rA   )lookup_objectindextransform_object)r:   ra   objectr;   r;   r<   resolve_data      zDefaultSavePlanner.resolve_datard   c                 C      t | j|S zSExtension from the planner interface to make it easy to extend the default planner.r$   r>   r:   rd   r;   r;   r<   rc        z DefaultSavePlanner.lookup_objectrf   c                 C   s(   |j tjkrt }t|| |}|S rj   )typer   BYTE_IOioBytesIOtorchsave)r:   ra   rf   bytesr;   r;   r<   re     s
   z#DefaultSavePlanner.transform_object)TTNFFNF)!r7   
__module____qualname__r
   __annotations__boolr   r=   r   r   rB   r   rK   listrM   tupler   rV   r\   r]   r_   r`   r   r   rr   Tensorrp   rq   rg   r   r   rc   re   r;   r;   r;   r<   r)   E   sj   
 



;

	r)   c                	   @   s  e Zd ZU dZeed< eed< 			d(dededed	d
fddZ	
	d)dede	e
 ded	d
fddZd	efddZdee d	ee fddZded	efddZdedejd	d
fddZdefddZded ejd	d
fd!d"Zd#ed	ejfd$d%Zded ejfd&d'Zd
S )*r*   ak  
    DefaultLoadPlanner that adds multiple features on top of LoadPlanner.

    In particular it adds the following:

    flatten_state_dict: Handle state_dict with nested dicts
    flatten_sharded_tensors: For FSDP in 2D parallel mode
    allow_partial_load: If False, will raise a runtime error if a key is present in state_dict, but not in the checkpoint.
    original_state_dictr/   TFr   r0   allow_partial_loadr4   Nc                 C   s"   || _ || _i | _i | _|| _d S rA   )r   r0   r}   r/   r~   )r:   r   r0   r~   r;   r;   r<   r=     s
   
zDefaultLoadPlanner.__init__r>   rU   r@   c                 C   sF   t | || _| jrt|}| jrt|\}| _|| _|| _|| _d S rA   )	r"   r}   r0   r   r   r/   r>   rU   r@   )r:   r>   rU   r@   r;   r;   r<   rB   (  s   
z!DefaultLoadPlanner.set_up_plannerc                 C   s   | j d usJ | jr=t| j }t| j j }|| }|r=dt_t| j\}}t| }||@ r:||| _| _	d t_t
| j| j | j S )NZ2_3)rU   r   setr>   keysstate_dict_metadatar'   Z_derived_versionr}   r/   r+   r~   )r:   Zcurrent_keysZ	load_keysZmissing_keysZold_state_dictZold_mappingsZold_keysr;   r;   r<   rK   ;  s"   z$DefaultLoadPlanner.create_local_planrT   c                 C   s   t |S rA   )r,   )r:   rT   r;   r;   r<   r]   b  s   z%DefaultLoadPlanner.create_global_planr[   c                 C   s   |S rA   r;   )r:   r[   r;   r;   r<   r`   e     zDefaultLoadPlanner.finish_plan	read_itemvaluec                 C   sH   | j rt| j| j|jj tj|dd d S tj|dd| j|jj< d S )NF)Zweights_only)	r   r   r}   r/   
dest_indexfqnrr   loadr>   )r:   r   r   r;   r;   r<   
load_bytesh  s   zDefaultLoadPlanner.load_bytesc                 C   rb   rA   )lookup_tensorr   transform_tensorr:   r   tensorr;   r;   r<   resolve_tensort  rh   z!DefaultLoadPlanner.resolve_tensorr   c                 C   s   d S rA   r;   r   r;   r;   r<   commit_tensorx  r   z DefaultLoadPlanner.commit_tensorrd   c                 C   ri   rj   rk   rl   r;   r;   r<   r   {  rm   z DefaultLoadPlanner.lookup_tensorc                 C   s   t ||j|jS rj   )r   Zdest_offsetslengthsr   r;   r;   r<   r     s   z#DefaultLoadPlanner.transform_tensor)TTFru   )r7   rv   rw   __doc__r   rx   r
   ry   r=   r   r   rB   r   rK   rz   r]   r`   r   rp   rq   r   r   rr   r|   r   r   r   r   r;   r;   r;   r<   r*     sF   
 


'r*   c                	       s`   e Zd ZdZd fdd	Zdededefdd	Z		
dde	de
e deddf fddZ  ZS )_EmptyStateDictLoadPlannera  
    Extension of DefaultLoadPlanner, which rebuilds state_dict from the saved metadata.
    Useful for loading in state_dict without first initializing a model, such as
    when converting a DCP checkpoint into a Torch save file.

    . N.B. `state_dict` must be an empty dictionary when used with this LoadPlanner

    .. warning::
        Because the entire state dict is initialized, It's recommended to only utilize
        this LoadPlanner on a single rank or process to avoid OOM.

    Nc                    s   || _ t j|i | d S rA   )r   superr=   )r:   r   argskwargsr6   r;   r<   r=     s   z#_EmptyStateDictLoadPlanner.__init__keyrU   r4   c                    s~    j d u rdS | j v r	 g }|j|}|D ]}|r*|d|d t|g q|| qt fdd|D r=dS dS )NT.c                 3   s    | ]}| j v V  qd S rA   )r   )rN   unflattened_keyr:   r;   r<   	<genexpr>  s    zA_EmptyStateDictLoadPlanner._should_include_key.<locals>.<genexpr>F)r   rD   getrY   joinstrany)r:   r   rU   Zunflattened_keysrD   r   r;   r   r<   _should_include_key  s   

z._EmptyStateDictLoadPlanner._should_include_keyFr>   r@   c                    s   |rJ |d us
J |j  D ]2\}}| ||sqt|tr)tj|j|jj	d}|j
d ur=||j
v r=t||j
| | q|||< qt ||| d S )N)dtype)r   itemsr   
isinstancer   rr   emptysize
propertiesr   rD   r   r   rB   )r:   r>   rU   r@   kvr   r;   r<   rB     s   

z)_EmptyStateDictLoadPlanner.set_up_plannerrA   ru   )r7   rv   rw   r   r=   r   r   ry   r   r   r   rB   __classcell__r;   r;   r   r<   r     s    r   Tr>   rU   strictr4   c                 C   s   g }	 |   D ]Z\}}||jvr|rtd| dq|j| }t|trDt|dd d urD|j| krDtd|j d|  d| t|trY|j	
 d urX|t|||7 }q|t|||7 }qt|S )Nz&Missing key in checkpoint state_dict: r   r   zSize mismatch between saved z and current: z for )r   r   RuntimeErrorr   r   getattrr   rS   r%   device_meshget_coordinater    r   )r>   rU   r   requestsr   objmdr;   r;   r<   r+     s.   



r+   rL   c                 C   s   | S )z
    Create global load plan used by DefaultLoadPlanner.

    The default load behavior involved no global coordination and this function
    currently doesn't change the local plans.
    r;   )rL   r;   r;   r<   r,     s   	r,   r@   c                 C   sT   g }|   D ]\}}t|tr|j dur|t||7 }q|t||7 }qt|S )a  
    Create the ``SavePlan`` used by DefaultSavePlanner.

    On non-coordinator ranks, this function ignores tensors and non-tensor objects,
    only producing writes for ShardedTensor objects.

    On the coordinator rank, produce writes for all values.
    N)r   r   r%   r   r   r!   r   )r>   r@   r   r   r   r;   r;   r<   r-     s   
r-   rewrite_index_hintsc           
      C   s   i }g }| D ]}g }|j D ]q}|jtjks|jj|vsJ |jtjkr0t ||jj< || q|j	dus7J t
t||jjt|j	j|j	jg d}|}|ratj|jt|jd}	tj||	d}|| |j	jdusvJ d|jj d|j|j	j q|tj||d q|t|fS )a6  
    Create the global plan and metadata used by DefaultSavePlanner.

    Metadata is produced by concatenating the metadata of all ``WriteItem`` from the supplied plans.

    The only global planning change is to update index hints in all ``MetadataIndex`` objects if
    ``rewrite_index_hints`` is True.
    N)r   r   chunks)rd   zZ
                    Cannot create MD for tensor without bounds.
                    FQN: z
                )r   )r   rn   r   ZSHARDrd   r   ro   r   rY   Ztensor_datar   r   
setdefaultr   r   rG   rH   rW   r   chunkr   )
rL   r   r   Z	new_plansrI   Z	new_itemsitemZ	tensor_mdZnew_itemZ	new_indexr;   r;   r<   r.     sF   


r.   c                 C   s   t | }t|g\}}|S )zTReturn the ``Metadata`` if DefaultSavePlanner was used to checkpoint ``state_dict``.)r   r.   )r>   rI   _r   r;   r;   r<   _create_default_local_metadataK  s   r   box0box1c                 C   sd   t | j}t|D ]&}| j| |j| |j|  kr dS |j| | j| | j|  kr/ dS q	dS )z9Check if two boxes overlap. Tuples are (offset, lengths).FT)rW   offsetsrangesizes)r   r   Zndimsir;   r;   r<   _check_box_overlapR  s   
r   outer_box_size	inner_boxc                 C   s`   t t| D ]'}|j| dk r dS |j| dk r dS |j| |j|  | | kr- dS qdS )Nr   FT)r   rW   r   r   )r   r   r   r;   r;   r<   _check_box_boundsb  s   r   rT   c           
   	   C   s   d}|j  D ]j\}}t|trqt|jdkrqd}t|jD ]:\}}t|j|s5t	
d||j| d}|ttj|jd7 }|j|d d  D ]}t||rYt	
d||| d}qHq ttj|jd}	||	krqt	
d||	| d}q|S )NTr   z~
                        key:%s has out of bounds chunk:
                        tensor-size:%s chunk: %s
                    Fr&   z$key:%s has overlapping chunks: %s %szq
                    key:%s invalid fill tensor-volume:
                    %s chunks-volume: %s
                )r   r   r   r   rW   r   	enumerater   r   r(   r5   r   operatormulr   r   )
rT   rU   all_goodr   r   Zchunks_volumeZ	chunk_idxZchunk0Zchunk1Ztensor_volumer;   r;   r<   rR   p  sH   
	
	rR   )T)OrG   rp   loggingr   collectionsr   	functoolsr   typingr   r   r   r   rr   Ztorch.distributed._shard._utilsr   Z.torch.distributed.checkpoint._dedup_save_plansr	   Z)torch.distributed.checkpoint._nested_dictr
   r   Z2torch.distributed.checkpoint._sharded_tensor_utilsr   Z&torch.distributed.checkpoint._traverser   Z%torch.distributed.checkpoint.metadatar   r   r   r   r   r   r   r   Z$torch.distributed.checkpoint.plannerr   r   r   r   r   r   r   Z,torch.distributed.checkpoint.planner_helpersr   r   r   r    r!   r"   r#   Z"torch.distributed.checkpoint.utilsr$   Ztorch.distributed.tensorr%    r'   	getLoggerr7   r(   Loggerrx   __all__r)   r*   r   rQ   r   ry   r+   rz   r,   r-   r{   r.   r   r   Sizer   rR   r;   r;   r;   r<   <module>   s   
($
$		 JvB

*



5
