
    Ph:              	       |   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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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' d d
l(m)Z)m*Z* d dl+m,Z, d dl-m.Z. d dl/m0Z0 d dl1m2Z2  ejf                  e4      Z5ejl                  e7d<   g dZ8 G d de      Z9 G d de      Z:dee;ef   de!defdZ<de	e   de	e   fdZ=dee;ef   de>defdZ?	 d(de	e   de>de
e	e   e!f   fdZ@de"de!fdZAd ed!ede>fd"ZBd#ej                  d$ede>fd%ZDd&e	e   de!de>fd'ZEy))    N)ChainMap)reduce)ListTupleDictAnyUnioncast)narrow_tensor_by_index)DTensor)SavePlannerLoadPlannerSavePlanLoadPlanReadItem	WriteItemWriteItemType)BytesStorageMetadataChunkStorageMetadataTensorStorageMetadataMetadataIndexMetadataSTATE_DICT_TYPESTORAGE_TYPES)_create_read_items_create_write_items"_create_default_metadata_only_plan)FLATTEN_MAPPINGflatten_state_dict)_flatten_sharded_tensors)dedup_tensors)find_state_dict_object)set_elementlogger)DefaultSavePlannerDefaultLoadPlannercreate_default_local_load_plancreate_default_global_load_plancreate_default_local_save_plancreate_default_global_save_planc            	           e Zd ZU eed<   	 	 	 ddedededdfdZded	eddfd
Zde	fdZ
dee	   deee	   ef   fdZde	de	fdZdedeej&                  ej*                  f   fdZdedefdZdedefdZy)r%   mappingsr   flatten_sharded_tensorsdedup_replicated_tensorsreturnNc                 <    || _         || _        || _        i | _        y N)r   r-   r.   r,   )selfr   r-   r.   s       wC:\Users\daisl\Desktop\realtime-object-detection\venv\Lib\site-packages\torch/distributed/checkpoint/default_planner.py__init__zDefaultSavePlanner.__init__G   s#     #5'>$(@%    
state_dictis_coordinatorc                     | j                   rt        |      \  }| _        | j                  rt        |      }|| _        || _        y r1   )r   r,   r-   r    r6   r7   )r2   r6   r7   s      r3   set_up_plannerz!DefaultSavePlanner.set_up_plannerR   s@     ""(::(F%J''1*=J$,r5   c                     t        | j                  | j                        }| j                  r!t	        j
                  || j                        }|| _        | j                  S )Nplanner_data)r)   r6   r7   r   dataclassesreplacer,   plan)r2   r?   s     r3   create_local_planz$DefaultSavePlanner.create_local_plan\   sM    -OOT00
 ""&&t$--HD	yyr5   	all_plansc                 j   | j                   rt        |      }t        |      \  }}| j                  rA|D cg c]  }|j                   }}t        t        |       }t        j                  ||      }t        ||      st        d      || _        || _        | j                  | j                  fS c c}w )Nr;   zFailed to validate global plan)r.   r!   r*   r   r<   dictr   r=   r>   _validate_global_plan
ValueErrorglobal_planmetadata)r2   rA   rF   rG   pplanner_data_dictmerged_mappingss          r3   create_global_planz%DefaultSavePlanner.create_global_planf   s     ((%i0I ?	 JX""
 :E EA E"8->#?@O"**H %[(;=>>& .. !Fs   B0new_planc                     || _         |S r1   )r?   r2   rL   s     r3   finish_planzDefaultSavePlanner.finish_plan   s    	r5   
write_itemc                 \    | j                  |j                        }| j                  ||      S r1   )lookup_objectindextransform_object)r2   rP   objects      r3   resolve_datazDefaultSavePlanner.resolve_data   s-     ##J$4$45$$Z88r5   rS   c                 .    t        | j                  |      S zSExtension from the planner interface to make it easy to extend the default planner.r"   r6   r2   rS   s     r3   rR   z DefaultSavePlanner.lookup_object       %doou==r5   rU   c                     |j                   t        j                  k(  r,t        j                         }t        j                  ||       |}|S rX   )typer   BYTE_IOioBytesIOtorchsave)r2   rP   rU   bytess       r3   rT   z#DefaultSavePlanner.transform_object   s7    ??m333JJLEJJvu%Fr5   )TTT)__name__
__module____qualname__r   __annotations__boolr4   r   r9   r   r@   r   r   r   rK   rO   r   r	   ra   Tensorr_   r`   rV   r   r   rR   rT    r5   r3   r%   r%   D   s     $((,)-		 	 "&	 #'		
 
	-)-;?-	-8 /h/	tH~x'	(/6H  9#9	u||RZZ'	(9>= >S >9 c r5   r%   c                   4   e Zd ZU dZeed<   eed<   	 	 ddededdfdZd	ed
e	deddfdZ
defdZdee   dee   fdZdedefdZdedej$                  ddfdZdefdZdedej,                  ddfdZdedej,                  fdZdedej,                  fdZy)r&   z
    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
    original_state_dictr,   r   r-   r/   Nc                 <    || _         || _        i | _        i | _        y r1   )r   r-   rl   r,   )r2   r   r-   s      r3   r4   zDefaultLoadPlanner.__init__   s#    
 #5'>$#% r5   r6   rG   r7   c                     || _         | j                  rt        |      }| j                  rt        |      \  }| _        || _        || _        || _        y r1   )rl   r-   r    r   r,   r6   rG   r7   )r2   r6   rG   r7   s       r3   r9   z!DefaultLoadPlanner.set_up_planner   sO     $. ''1*=J""(::(F%J$ ,r5   c                 B    t        | j                  | j                        S r1   )r'   r6   rG   )r2   s    r3   r@   z$DefaultLoadPlanner.create_local_plan   s    -doot}}MMr5   rF   c                     t        |      S r1   )r(   )r2   rF   s     r3   rK   z%DefaultLoadPlanner.create_global_plan   s    .{;;r5   rL   c                     |S r1   rj   rN   s     r3   rO   zDefaultLoadPlanner.finish_plan   s    r5   	read_itemvaluec                     | j                   rLt        | j                  | j                  |j                  j
                     t        j                  |             y t        j                  |      | j                  |j                  j
                  <   y r1   )	r   r#   rl   r,   
dest_indexfqnra   loadr6   )r2   rr   rs   s      r3   
load_byteszDefaultLoadPlanner.load_bytes   se    ""((i22667

5! 9>

58IDOOI00445r5   c                 \    | j                  |j                        }| j                  ||      S r1   )lookup_tensorru   transform_tensorr2   rr   tensors      r3   resolve_tensorz!DefaultLoadPlanner.resolve_tensor   s+    ##I$8$89$$Y77r5   r}   c                      y r1   rj   r|   s      r3   commit_tensorz DefaultLoadPlanner.commit_tensor   s    r5   rS   c                 .    t        | j                  |      S rX   rY   rZ   s     r3   rz   z DefaultLoadPlanner.lookup_tensor   r[   r5   c                 D    t        ||j                  |j                        S rX   )r   dest_offsetslengthsr|   s      r3   r{   z#DefaultLoadPlanner.transform_tensor   s"    %I**I,=,=
 	
r5   )TT)rd   re   rf   __doc__r   rg   r   rh   r4   r   r9   r   r@   r   rK   rO   r   r_   r`   rx   r~   ra   ri   r   r   rz   r{   rj   r5   r3   r&   r&      s    )( $((,  "& 
	-#- - 	-
 
-$N8 N<d8n <h <H  JH JRZZ JD J8 8x  $ >= >U\\ >
( 
ELL 
r5   r&   r6   rG   r/   c                    g }	 | j                         D ]`  \  }}|j                  |   }t        |t              r,|j                  j                         @|t        |||      z  }Q|t        |||      z  }b t        |      S r1   )itemsstate_dict_metadata
isinstancer   device_meshget_coordinater   r   )r6   rG   requestsrv   objmds         r3   r'   r'      s     H $$&S))#. c7#--/;.sB<<*3C88H ' Hr5   rA   c                     | 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.
    rj   )rA   s    r3   r(   r(     s
     r5   r7   c                    g }| j                         D ]l  \  }}t        |t              r+|j                  j	                         1|t        ||      z  }At        |t        j                        s|s^|t        ||      z  }n 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.
    )	r   r   r   r   r   r   ra   ri   r   )r6   r7   r   rv   r   s        r3   r)   r)     s     H$$&S c7#--/;/S99ell,+C55H ' Hr5   rewrite_index_hintsc                 .   i }g }| D ]  }g }|j                   D ]  }|j                  t        j                  k(  s|j                  j
                  |vsJ |j                  t        j                  k(  r3t               ||j                  j
                  <   |j                  |       |j                  J t        t        |j                  |j                  j
                  t        |j                  j                  |j                  j                  g                   }|}|rKt        j                   |j                  t#        |j$                              }	t        j                   ||	      }|j                  |       |j                  j&                  J d|j                  j
                   d       |j$                  j                  |j                  j&                          |j                  t        j                   ||              |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.
    )
propertiessizechunks)rS   zZ
                    Cannot create MD for tensor without bounds.
                    FQN: z
                )r   )r   r]   r   SHARDrS   rv   r^   r   appendtensor_datar
   r   
setdefaultr   r   r=   r>   lenr   chunkr   )
rA   r   r   	new_plansr?   	new_itemsitem	tensor_mdnew_item	new_indexs
             r3   r*   r*   &  s    $&BI	JJD99 3 33zz~~R///yyM111%9%;4::>>"  &''333 )MM

-'+'7'7'B'B!%!1!1!6!6#%
	  & + 3 3

#i.>.>*?!I  +224yIH  * $$**6**..) *6
   ''(8(8(>(>?E F 	,,TCDK L x|$$r5   c                 :    t        |       }t        |g      \  }}|S )zTReturn the ``Metadata`` if DefaultSavePlanner was used to checkpoint ``state_dict``.)r   r*   )r6   r?   _r   s       r3   _create_default_local_metadatar   ]  s!    -j9D+TF3EArIr5   box0box1c                    t        | j                        }t        |      D ]d  }| j                  |   |j                  |   |j                  |   z   k\  r y|j                  |   | j                  |   | j                  |   z   k\  sd y y)z9Check if two boxes overlap. Tuples are (offset, lengths).FT)r   offsetsrangesizes)r   r   ndimsis       r3   _check_box_overlapr   d  su     E5\<<?dll1o

1==<<?dll1o

1==	  r5   outer_box_size	inner_boxc                     t        t        |             D ]Q  }|j                  |   dk  r y|j                  |   dk  r y|j                  |   |j                  |   z   | |   kD  sQ y y)Nr   FT)r   r   r   r   )r   r   r   s      r3   _check_box_boundsr   v  sp     3~&'Q!#??1!Q)//!"44~a7HH ( r5   rF   c           	         d}|j                   j                         D ]5  \  }}t        |t              rt	        |j
                        dk(  r1d}t        |j                        D ]  \  }}t        |j
                  |      s$t        j                  d||j
                  |       d}|t        t        j                  |j                  d      z  }|j                  |dz   d  D ])  }t        ||      st        j                  d|||       d}+  t        t        j                  |j
                  d      }	||	k7  st        j                  d||	|       d}8 |S )NTr   z~
                        key:%s has out of bounds chunk:
                        tensor-size:%s chunk: %s
                    F   z$key:%s has overlapping chunks: %s %szq
                    key:%s invalid fill tensor-volume:
                    %s chunks-volume: %s
                )r   r   r   r   r   r   	enumerater   r   r$   warningr   operatormulr   r   )
rF   rG   all_goodkeyrs   chunks_volume	chunk_idxchunk0chunk1tensor_volumes
             r3   rD   rD     s=    H2288:
Ue12uzz?a!*5<<!8Iv$UZZ8 ejj&	 !VHLL&,,BBM  ,,y1}7%ff5NN>VV  %H 8 "9* x||UZZ;M)NN -	 HG ;J Or5   )T)Fr=   r_   loggingr   collectionsr   	functoolsr   typingr   r   r   r   r	   r
   ra   torch.distributed._shard._utilsr   torch.distributed._tensorr   $torch.distributed.checkpoint.plannerr   r   r   r   r   r   r   %torch.distributed.checkpoint.metadatar   r   r   r   r   r   r   ,torch.distributed.checkpoint.planner_helpersr   r   r   )torch.distributed.checkpoint._nested_dictr   r   2torch.distributed.checkpoint._sharded_tensor_utilsr    +torch.distributed.checkpoint._dedup_tensorsr!   "torch.distributed.checkpoint.utilsr"   &torch.distributed.checkpoint._traverser#   	getLoggerrd   r$   Loggerrg   __all__r%   r&   strr'   r(   rh   r)   r*   r   r   Sizer   rD   rj   r5   r3   <module>r      s    	      6 6  B -      F E >***84 4Q QhK
 K
\S#X 8	H~		(^	S#X044 !%4%H~4%4% 4>8#$4%n 8 
&:	$JJ+?	)h)+3)	)r5   