§
    “©ºj#n  ã                   ón	  — U 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mZ erd dlmZ d dlmZ eeeeef         f         Z G d„ d	¦  «        Z G d
„ de¦  «        Z	 džde	j        j        deg e	j        f         deee	j        ge	j        f                  defd„Zi de	j        de	j        ddde	j         de	j!        de	j"        di“de	j        de	j        ddde	j         de	j!        de	j"        di“de	j        de	j        ddd e	j         d!e	j!        d!e	j"        d"i“d#e	j        d$e	j        d%dd&e	j         d e	j!        d e	j"        d'i“d(e	j        d)e	j        d*dd+e	j         d,e	j!        d,e	j"        d-i“d.e	j        d/dd/e	j         d/e	j!        d/e	j"        d0d1d2i“d3e	j        d4dd4e	j         d4e	j!        d4e	j"        d5d1d6i“d7e	j        d8dd8e	j         d8e	j!        d8e	j"        d9d1d:i“d;e	j        d<dde	j         d=e	j!        d=e	j"        d>d1d?i“d@e	j        dAddAe	j         dBe	j!        dBe	j"        dCd1dDi“dEe	j        dFe	j        dGddHe	j         dIe	j!        dIe	j"        dJi“dKe	j        dLddMe	j         dLe	j!        dLe	j"        dNd1dOi“dPe	j        dQddRe	j         dQe	j!        dQe	j"        dSd1dTi“dUe	j        dVddWe	j         dXe	j!        dXe	j"        dYd1dZi“d[e	j        d\dd\e	j         d\e	j!        d\e	j"        d]d1d^i“d_e	j        d`dd`e	j         d`e	j!        d`e	j"        dad1dbi“dce	j        ddddde	j         dde	j!        dde	j"        ded1dfi“e	j        dgddge	j         dge	j!        dge	j"        dhd1diie	j        djddje	j         dje	j!        dje	j"        dkd1dlie	j        dme	j!        dne	j"        dod1dpie	j        dqe	j!        drie	j        dqe	j!        dse	j"        dtd1duie	j        dve	j!        dwe	j"        dxd1dyie	j        dze	j!        d{e	j"        d|d1d}ie	j        d~e	j!        de	j"        d€d1d�ie	j        d‚e	j!        dƒe	j"        d„d1d…ie	j        d†e	j        d‡e	j!        dXie	j        dˆe	j        d‰e	j!        dŠie	j        d‹e	j        dŒe	j!        doid�œ¥Z#eeeeee	j$        f         ef         f         e%dŽ<   d�d�d‘d’d“œZ&d”e	j'        d•ee	j$        ef         dee         fd–„Z(d—d˜de	j$        fd™„Z) edše¬›¦  «        Z* G dœ„ d�e+e*         ¦  «        Z,dS )Ÿé    )Údeque)ÚTYPE_CHECKINGÚAnyÚCallableÚOptionalÚTypeVarÚUnionN)Úoverride)Úrank_zero_onlyÚrank_zero_warn)ÚFabric)Ú	Precisionc                   ó’   — e Zd ZdZ	 ddee         deded	ed
df
d„Zdddœdedededee         dee         d
dfd„Z	d
e
fd„Zdd„ZdS )Ú
Throughputaƒ  Computes throughput.

    +------------------------+-------------------------------------------------------------------------------------+
    | Key                    | Value                                                                               |
    +========================+=====================================================================================+
    | batches_per_sec        | Rolling average (over ``window_size`` most recent updates) of the number of batches |
    |                        | processed per second                                                                |
    +--------------------------+-----------------------------------------------------------------------------------+
    | samples_per_sec        | Rolling average (over ``window_size`` most recent updates) of the number of samples |
    |                        | processed per second                                                                |
    +--------------------------+-----------------------------------------------------------------------------------+
    | items_per_sec          | Rolling average (over ``window_size`` most recent updates) of the number of items   |
    |                        | processed per second                                                                |
    +--------------------------+-----------------------------------------------------------------------------------+
    | flpps_per_sec          | Rolling average (over ``window_size`` most recent updates) of the number of flops   |
    |                        | processed per second                                                                |
    +--------------------------+-----------------------------------------------------------------------------------+
    | device/batches_per_sec | batches_per_sec divided by world size                                               |
    +--------------------------+-----------------------------------------------------------------------------------+
    | device/samples_per_sec | samples_per_sec divided by world size                                               |
    +--------------------------+-----------------------------------------------------------------------------------+
    | device/items_per_sec   | items_per_sec divided by world size. This may include padding depending on the data |
    +--------------------------+-----------------------------------------------------------------------------------+
    | device/flops_per_sec   | flops_per_sec divided by world size.                                                |
    +--------------------------+-----------------------------------------------------------------------------------+
    | device/mfu             | device/flops_per_sec divided by world size.                                         |
    +--------------------------+-----------------------------------------------------------------------------------+
    | time                   | Total elapsed time                                                                  |
    +--------------------------+-----------------------------------------------------------------------------------+
    | batches                | Total batches seen                                                                  |
    +--------------------------+-----------------------------------------------------------------------------------+
    | samples                | Total samples seen                                                                  |
    +--------------------------+-----------------------------------------------------------------------------------+
    | lengths                | Total items seen                                                                    |
    +--------------------------+-----------------------------------------------------------------------------------+

    Example::

        throughput = Throughput()
        t0 = time()
        for i in range(1000):
            do_work()
            if torch.cuda.is_available(): torch.cuda.synchronize()  # required or else time() won't be correct
            throughput.update(time=time() - t0, samples=i)
            if i % 10 == 0:
                print(throughput.compute())

    Notes:
        - The implementation assumes that devices FLOPs are all the same as it normalizes by the world size and only
          takes a single ``available_flops`` value.
        - items_per_sec, flops_per_sec and MFU do not account for padding if present. We suggest using
          samples_per_sec or batches_per_sec to measure throughput under this circumstance.

    Args:
        available_flops: Number of theoretical flops available for a single device.
        world_size: Number of devices available across hosts. Global metrics are not included if the world size is 1.
        window_size: Number of batches to use for a rolling average.
        separator: Key separator to use when creating per-device and global metrics.

    Né   éd   ú/Úavailable_flopsÚ
world_sizeÚwindow_sizeÚ	separatorÚreturnc                 ó"  — || _         || _        |dk    sJ ‚|| _        |dk    sJ ‚t          |¬¦  «        | _        t          |¬¦  «        | _        t          |¬¦  «        | _        t          |¬¦  «        | _        t          |¬¦  «        | _	        d S )Nr   r   )Úmaxlen)
r   r   r   Ú_MonotonicWindowÚ_timeÚ_batchesÚ_samplesÚ_lengthsr   Ú_flops)Úselfr   r   r   r   s        úu/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/lightning_fabric/utilities/throughput.pyÚ__init__zThroughput.__init__^   s–   € ð  /ˆÔØ"ˆŒØ˜AŠ~ˆ~ˆ~ˆ~Ø$ˆŒð ˜QŠˆˆˆõ /?ÀkÐ.RÑ.RÔ.RˆŒ
Ý/?À{Ð/SÑ/SÔ/SˆŒÝ/?À{Ð/SÑ/SÔ/SˆŒÝ/?À{Ð/SÑ/SÔ/SˆŒÝ"'¨{Ð";Ñ";Ô";ˆŒˆˆó    )ÚlengthsÚflopsÚtimeÚbatchesÚsamplesr%   r&   c                ó^  — | j                              |¦  «         ||k     rt          d|› d|› d�¦  «        ‚| j                             |¦  «         | j                             |¦  «         |�š||k     rt          d|› d|› d�¦  «        ‚| j                             |¦  «         t          | j        ¦  «        t          | j        ¦  «        k    r:t          dt          | j        ¦  «        › dt          | j        ¦  «        › d�¦  «        ‚|�$| j                             || j	        z  ¦  «         dS dS )	ad  Update throughput metrics.

        Args:
            time: Total elapsed time in seconds. It should monotonically increase by the iteration time with each
                call.
            batches: Total batches seen per device. It should monotonically increase with each call.
            samples: Total samples seen per device. It should monotonically increase by the batch size with each call.
            lengths: Total length of the samples seen. It should monotonically increase by the lengths of a batch with
                each call.
            flops: Flops elapased per device since last ``update()`` call. You can easily compute this by using
                :func:`measure_flops` and multiplying it by the number of batches that have been processed.
                The value might be different in each device if the batch size is not the same.

        zExpected samples (z') to be greater or equal than batches (ú)NzExpected lengths (z') to be greater or equal than samples (zIf lengths are passed (z1), there needs to be the same number of samples ()
r   ÚappendÚ
ValueErrorr   r   r   ÚlenÚRuntimeErrorr    r   )r!   r'   r(   r)   r%   r&   s         r"   ÚupdatezThroughput.updateq   sY  € ð. 	Œ
×Ò˜$ÑÔÐØ�WÒÐÝÐl°'ÐlÐlÐbiÐlÐlÐlÑmÔmÐmØŒ×Ò˜WÑ%Ô%Ð%ØŒ×Ò˜WÑ%Ô%Ð%ØÐØ˜Ò Ð Ý Ð!p°gÐ!pÐ!pÐfmÐ!pÐ!pÐ!pÑqÔqÐqØŒM× Ò  Ñ)Ô)Ð)Ý�4”=Ñ!Ô!¥S¨¬Ñ%7Ô%7Ò7Ð7Ý"ð/­c°$´-Ñ.@Ô.@ð /ð /Ý˜Tœ]Ñ+Ô+ð/ð /ð /ñô ð ð ÐàŒK×Ò˜u t¤Ñ6Ñ7Ô7Ð7Ð7Ð7ð Ðr$   c                 óJ  — | j         d         | j        d         | j        d         dœ}| j        r| j        d         |d<   | j        dk    }t          | j         ¦  «        | j         j        k    �r| j         d         | j         d         z
  }| j        d         | j        d         z
  }| j        d         | j        d         z
  }||z  }||z  }|                     d| j        › d�||z  d| j        › d�|i¦  «         |r*|| j        z  }|                     ||| j        z  d	œ¦  «         t          | j        ¦  «        | j        j        k    r?| j        d         | j        d         z
  }	|	|z  }
|
|d| j        › d
�<   |r|
| j        z  }||d
<   t          | j	        ¦  «        | j	        j        k    r~t          | j	        ¦  «        | j	        d         z
  }| j         d         | j         d         z
  }||z  }|| j        z  }|r||d<   ||d| j        › d�<   | j        r|| j        z  |d| j        › d�<   |S )zCompute throughput metrics.éÿÿÿÿ)r'   r(   r)   r%   r   r   ÚdeviceÚbatches_per_secÚsamples_per_sec)r4   r5   Úitems_per_secÚflops_per_secÚmfu)r   r   r   r   r   r.   r   r0   r   r    Úsumr   )r!   ÚmetricsÚadd_global_metricsÚelapsed_timeÚelapsed_batchesÚelapsed_samplesÚdev_samples_per_secÚdev_batches_per_secr5   Úelapsed_lengthsÚdev_items_per_secr6   Úelapsed_flopsr7   Údev_flops_per_secs                  r"   ÚcomputezThroughput.computeš   s†  € ð ”J˜r”NØ”} RÔ(Ø”} RÔ(ð
ð 
ˆð
 Œ=ð 	3Ø!%¤¨rÔ!2ˆG�IÑà!œ_¨qÒ0Ðõ ˆtŒz‰?Œ?˜dœjÔ/Ò/Ñ/Øœ: bœ>¨D¬J°q¬MÑ9ˆLØ"œm¨BÔ/°$´-ÀÔ2BÑBˆOØ"œm¨BÔ/°$´-ÀÔ2BÑBˆOà"1°LÑ"@ÐØ"1°LÑ"@ÐØ�NŠNØ8˜œÐ8Ð8Ð8¸/ÈLÑ:XØ8˜œÐ8Ð8Ð8Ð:Mðñ ô ð ð "ð Ø"5¸¼Ñ"G�Ø—’Ø'6Ø':¸T¼_Ñ'Lð ð  ñ ô ð õ
 �4”=Ñ!Ô! T¤]Ô%9Ò9Ð9Ø"&¤-°Ô"3°d´mÀAÔ6FÑ"F�Ø$3°lÑ$BÐ!ØBS�Ð> ¤Ð>Ð>Ð>Ñ?Ø%ð =Ø$5¸¼Ñ$G�MØ/<�G˜OÑ,åˆtŒ{ÑÔ˜tœ{Ô1Ò1Ð1Ý ¤Ñ,Ô,¨t¬{¸1¬~Ñ=ˆMØœ: bœ>¨D¬J°q¬MÑ9ˆLØ)¨LÑ8ˆMØ -°´Ñ ?ÐØ!ð 9Ø+8�˜Ñ(Ø>OˆGÐ:˜Tœ^Ð:Ð:Ð:Ñ;ØÔ#ð aØ8IÈDÔL`Ñ8`�Ð4 ¤Ð4Ð4Ð4Ñ5àˆr$   c                 ó   — | j                              ¦   «          | j                             ¦   «          | j                             ¦   «          | j                             ¦   «          | j                             ¦   «          d S ©N)r   Úclearr   r   r   r    ©r!   s    r"   ÚresetzThroughput.resetÎ   sl   € ØŒ
×ÒÑÔÐØŒ×ÒÑÔÐØŒ×ÒÑÔÐØŒ×ÒÑÔÐØŒ×ÒÑÔÐÐÐr$   )Nr   r   r   )r   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   ÚfloatÚintÚstrr#   r0   Ú_THROUGHPUT_METRICSrE   rJ   © r$   r"   r   r       s  € € € € € ð;ð ;ð| vyð<ð <Ø'¨œð<ØCFð<ØY\ð<Øorð<à	ð<ð <ð <ð <ð2 "&Ø#ð'8ð '8ð '8ð ð'8ð ð	'8ð
 ð'8ð ˜#”ð'8ð ˜Œ}ð'8ð 
ð'8ð '8ð '8ð '8ðR2Ð,ð 2ð 2ð 2ð 2ðhð ð ð ð ð r$   r   c                   óR   ‡ — e Zd ZdZdddeddfˆ fd„Zd
dee         dedefd	„Z	ˆ xZ
S )ÚThroughputMonitora  Computes throughput.

    This class will automatically keep a count of the number of log calls (``step``). But that can be modified as
    desired. For manual logging, using :class:`Throughput` directly might be desired.

    Example::

        logger = ...
        fabric = Fabric(logger=logger)
        throughput = ThroughputMonitor(fabric)
        t0 = time()
        for i in range(1, 100):
            do_work()
            if torch.cuda.is_available(): torch.cuda.synchronize()  # required or else time() won't be correct
            throughput.update(time=time() - t0, batches=i, samples=i)
            if i % 10 == 0:
                throughput.compute_and_log(step=i)

    Args:
        fabric: The Fabric object.
        \**kwargs: See available parameters in :class:`Throughput`

    Úfabricr   Úkwargsr   Nc                 óº  •— |                      ¦   «          t          |j        j        ¦  «        }t	          |j        |¦  «        } t          ¦   «         j        d||j        dœ|¤Ž || _	        d| _
        t          | j        ¦  «        | _        t          | j        i ¬¦  «        | _        t          | j        i ¬¦  «        | _        t          | j        ¦  «        | _        d S )N)r   r   r2   )ÚdefaultrS   )Ú_validate_launchedÚ_plugin_to_compute_dtypeÚstrategyÚ	precisionÚget_available_flopsr3   Úsuperr#   r   Ú_fabricÚstepr   r0   rE   Úcompute_and_logrJ   )r!   rV   rW   Údtyper   Ú	__class__s        €r"   r#   zThroughputMonitor.__init__ï   sÂ   ø€ Ø×!Ò!Ñ#Ô#Ð#Ý(¨¬Ô)BÑCÔCˆÝ-¨f¬m¸UÑCÔCˆØ�‰ŒÔÐa¨ÀVÔEVÐaÐaÐZ`ÐaÐaÐaØˆŒØˆŒ	å$ T¤[Ñ1Ô1ˆŒÝ% d¤l¸BÐ?Ñ?Ô?ˆŒÝ-¨dÔ.BÈBÐOÑOÔOˆÔÝ# D¤JÑ/Ô/ˆŒ
ˆ
ˆ
r$   ra   c                 óˆ   — |€
| j         dz   n|| _          | j        di |¤Ž}| j                             || j         ¬¦  «         |S )zÁSee :meth:`Throughput.compute`

        Args:
            step: Can be used to override the logging step.
            \**kwargs: See available parameters in :meth:`Throughput.compute`

        Nr   )r:   ra   rS   )ra   rE   r`   Úlog_dict)r!   ra   rW   r:   s       r"   rb   z!ThroughputMonitor.compute_and_logü   sR   € ð (, |�T”Y ‘]�]¸ˆŒ	Ø�$”,Ð(Ð( Ð(Ð(ˆØŒ×Ò g°D´IÐÑ>Ô>Ð>Øˆr$   rG   )rK   rL   rM   rN   r   r#   r   rP   rR   rb   Ú__classcell__©rd   s   @r"   rU   rU   Ö   s�   ø€ € € € € ðð ð00˜xð 0°3ð 0¸4ð 0ð 0ð 0ð 0ð 0ð 0ðð  H¨S¤Mð ÀCð ÐL_ð ð ð ð ð ð ð ð r$   rU   ÚmodelÚ
forward_fnÚloss_fnr   c                 óæ   — ddl m}  |d¬¦  «        }|5  |€ |¦   «          n% | |¦   «         ¦  «                             ¦   «          ddd¦  «         n# 1 swxY w Y   |                     ¦   «         S )a-  Utility to compute the total number of FLOPs used by a module during training or during inference.

    It's recommended to create a meta-device model for this:

    Example::

        with torch.device("meta"):
            model = MyModel()
            x = torch.randn(2, 32)

        model_fwd = lambda: model(x)
        fwd_flops = measure_flops(model, model_fwd)

        model_loss = lambda y: y.sum()
        fwd_and_bwd_flops = measure_flops(model, model_fwd, model_loss)

    Args:
        model: The model whose FLOPs should be measured.
        forward_fn: A function that runs ``forward`` on the model and returns the result.
        loss_fn: A function that computes the loss given the ``forward_fn`` output. If provided, the loss and `backward`
            FLOPs will be included in the result.

    r   )ÚFlopCounterModeF)ÚdisplayN)Útorch.utils.flop_counterrm   ÚbackwardÚget_total_flops)ri   rj   rk   rm   Úflop_counters        r"   Úmeasure_flopsrs   
  sË   € ð8 9Ð8Ð8Ð8Ð8Ð8à"�?¨5Ð1Ñ1Ô1€LØ	ð -ð -Øˆ?ØˆJ‰LŒLˆLˆLàˆG�J�J‘L”LÑ!Ô!×*Ò*Ñ,Ô,Ð,ð	-ð -ð -ñ -ô -ð -ð -ð -ð -ð -ð -øøøð -ð -ð -ð -ð
 ×'Ò'Ñ)Ô)Ð)s   •3AÁAÁAú	h200 sxm1g   ì=ì¾Bg  ˜™ÓwÎBÚtfloat32g  Ÿ²2#Cg  4&õkCg  4&õk,Cú	h200 nvl1g  àWëH»Bg  àWëHËBg  äìÍßCg  y`�(Cg €„?ªr'Cúh100 nvlg  $^/lÞBg €SÕCg €SÕCg  />2,Cúh100 sxmg  ˜™Ów¾Bg  $^/lÎBg €SÕüBg  />2Cú	h100 pcieg   èvH·Bg   èvHÇBg  š»Ÿ|õBg  š»Ÿ|Cg @.C€Czrtx 4090g  $êóÇÒBg €µbÆCÚint4g €µbÆCzrtx 4080g  ¬m%ÆBg €÷¯Ê)öBg €÷¯Ê)Czrtx 4080 superg  ˆ:á¼ÇBg  ˆ:á¼÷Bg  ˆ:á¼CÚl4g  ˜¼ÄŽ»Bg  $� ƒÛBg  $� ƒëBg  $� ƒûBÚl40g  ŠË“ÔBg  ŠË“äBg  ŠË“ôBg  ŠË“CÚa100g  Ðê¤¡Bg  ¸’2¼±Bg  ¸’2¼áBg  ¸’2¼ñBg  ¸’2¼CÚa6000g  \àE™ÁBg  \àE™ÑBg €ÊgºšñBg @$ šCÚa40g  xÛîÁBg  xÛîÑBg €æbcñBg À�¦CÚa10gg  ÀêP`¼Bg  4&õkÌBg  4&õkÜBg  4&õkìBg  4&õküBzrtx 3090 tig  @åœ0ÂBg  @åœ0òBg  @åœ0Czrtx 3090g  P­b0ÀBg  Üq¾$ðBg  Üq¾$ Czrtx 3080 tig  c†¿Bg  c†ïBg  Y­ÿBg  jZ»Bg  œ.¶ëBg  œ.¶ûBg  øIvv²Bg  ²gH|âBg  ²gH|òBg   }¶w�Bg  ˆôþŽÍBg  ˆôþŽÝBg  ˆôþŽíBg   h_¤Bg  ”HÔBg  ”H´Bg  ”HäBg  ”HôBg  `écÔ©Bg  H`¬ë¹Bg  ±3ñâéBg  ±3ñâùBg   xH£Bg   xH³Bg   xHãBg €±ð�FóBg  ðˆ„� Bg  <v°Bg  Â/|àBg  Â/|ðBg  pkG¦­Bg  pkG¦½Bg  *‰¬íBg  *‰¬ýBg  ÀêP`œBg  �ØáŽ¬Bg  ÀBw™Bg  ÀBw©Bg  ÀBwÙBg  @YØÔ�Bg  @YØÔ­B)zrtx 3080zrtx 3070Út4úquadro rtx 5000zrtx 2080 superzrtx 2080 tizrtx 2080zrtx 2070 superú	titan rtxúv100 sxmú	v100 pcieú
v100s pcieÚ_CUDA_FLOPSg  è�°vÄBg  ¬ÓŠ÷ÛBg  ª�CïBg  ª`teæB)Úv2Úv3Úv4Ú	v5litepodr3   rc   c                 óà  — | j         dk    �r’t          j                             | ¦  «        }|                     ¦   «         }d|v rd|v rd}nÁd|v rd}nºd|v rd|v rd	}n¯d
|v rd}n¨d|v sd|v rd}n�d|v r	d|v rdnd}n�d|v r2|                     d¦  «        d         }d}d|v rd}nd|v rd}d|› |› �}nZd|v rd}nSd|v rd}nLd|v rd}nEd|v rd}n>d|v rd}n7d |v rd }n0d!|v rd!}n)d"|v rd#}n"d$|v rd%}nd&|v rd'}nt          d(|›�¦  «         d)S |t          vrt          d(|›d*|›�¦  «         d)S t          |         }|t          j        u r)d+d,l	m
}  |¦   «         rt          j        ¦   «         d-k    rd.}||vrt          |›d/|› �¦  «         d)S t          ||         ¦  «        S | j         d0k    rÄd+d1lm} |rd+d2lm}	 nd+d2lm}	 |	                     ¦   «         }
|
                     d3¦  «        p |
d4                              d5¦  «        d+         }|                     ¦   «         }t)          |t*          ¦  «        sJ ‚|t,          vrt          d6|›d7|› �¦  «         d)S t          t,          |         ¦  «        S d)S )8z²Returns the available theoretical FLOPs.

    This is an optimistic upper limit that could only be achievable if only thick matmuls were run in a benchmark
    environment.

    ÚcudaÚh200Úsxm1rt   Únvl1rv   Úh100Úhbm3rx   Únvlrw   ÚpcieÚhbm2ery   r{   Úteslar|   zgeforce rtxú é   Ú r_   z superÚtiz tizrtx r~   r}   r   r€   r�   r‚   rƒ   zv100-sxmr„   z	v100-pcier…   z
v100s-pcier†   zFLOPs not found for Nz
, chip is r   )Ú_is_ampere_or_laterÚhighestru   z does not support Úxla)Ú_XLA_GREATER_EQUAL_2_1)ÚtpuÚTYPEÚACCELERATOR_TYPEú-zFLOPs not found for TPU z with )ÚtypeÚtorchr�   Úget_device_nameÚlowerÚsplitr   r‡   Úfloat32Ú"lightning_fabric.accelerators.cudar›   Úget_float32_matmul_precisionrP   Ú!lightning_fabric.accelerators.xlarž   Útorch_xla._internalrŸ   Útorch_xla.experimentalÚget_tpu_envÚgetÚ
isinstancerQ   Ú
_TPU_FLOPS)r3   rc   Údevice_nameÚchipÚnumberÚextraÚdtype_to_flopsr›   rž   rŸ   Útpu_envs              r"   r^   r^   "  s˜  € ð „{�fÒÑÝ”j×0Ò0°Ñ8Ô8ˆØ× Ò Ñ"Ô"ˆØ�Tˆ>ˆ>Ø˜ˆ~ˆ~Ø"��Ø˜4��Ø"�øØ�tˆ^ˆ^Ø˜ˆ~ˆ~Ø!��Ø˜$��Ø!��Ø˜4�� 7¨d ? ?Ø"�øØ�Tˆ\ˆ\Ø# t˜O˜O�5�5°ˆDˆDØ˜dÐ"Ð"Ø—Z’Z ‘_”_ QÔ'ˆFØˆEØ˜$ˆˆØ ��Ø˜��Ø�Ø)˜&Ð) %Ð)Ð)ˆDˆDØ˜ˆ_ˆ_ØˆDˆDØ�tˆ^ˆ^ØˆDˆDØ�dˆ]ˆ]ØˆDˆDØ�tˆ^ˆ^ØˆDˆDØ�Tˆ\ˆ\ØˆDˆDØ $Ð&Ð&Ø$ˆDˆDØ˜DÐ Ð ØˆDˆDØ˜4ÐÐØˆDˆDØ˜DÐ Ð ØˆDˆDØ˜TÐ!Ð!ØˆDˆDõ ÐA°+ÐAÐAÑBÔBÐBØ�4Ø•{Ð"Ð"åÐS°+ÐSÐSÈ4ÐSÐSÑTÔTÐTØ�4Ý$ TÔ*ˆØ•E”MÐ!Ð!ØNÐNÐNÐNÐNÐNà"Ð"Ñ$Ô$ð #­Ô)KÑ)MÔ)MÐQZÒ)ZÐ)ZØ"�Ø˜Ð&Ð&å˜kÐFÐF¸uÐFÐFÑGÔGÐGØ�4Ý�> %Ô(Ñ)Ô)Ð)à„{�eÒÐØLÐLÐLÐLÐLÐLà!ð 	3Ø/Ð/Ð/Ð/Ð/Ð/Ð/à2Ð2Ð2Ð2Ð2Ð2à—/’/Ñ#Ô#ˆà—k’k &Ñ)Ô)ÐV¨WÐ5GÔ-H×-NÒ-NÈsÑ-SÔ-SÐTUÔ-VˆØ× Ò Ñ"Ô"ˆÝ˜+¥sÑ+Ô+Ð+Ð+Ð+Ø•zÐ!Ð!ÝÐR°kÐRÐRÈ5ÐRÐRÑSÔSÐSØ�4Ý•:˜dÔ#Ñ$Ô$Ð$ð! Ðr$   Úpluginr   c                 ó  — ddl m}m}m}m}m}m}m}m}m	}	 t          | |¦  «        st          d| › �¦  «        ‚t          | |¦  «        r| j        S t          | ||f¦  «        r| j        S t          | |¦  «        rt          j        S t          | |	|f¦  «        r| j        S t          | |¦  «        rt          j        S t          | |¦  «        r| j        j        pt          j        S t          | |¦  «        rt          j        S t+          | ¦  «        ‚)Nr   )	ÚBitsandbytesPrecisionÚDeepSpeedPrecisionÚDoublePrecisionÚFSDPPrecisionÚHalfPrecisionÚMixedPrecisionr   ÚTransformerEnginePrecisionÚXLAPrecisionz!Expected a precision plugin, got )Úlightning_fabric.pluginsrº   r»   r¼   r½   r¾   r¿   r   rÀ   rÁ   r°   r/   rc   Ú_desired_input_dtyper¤   ÚdoubleÚ_desired_dtypeÚint8Úmixed_precision_configÚreduce_dtyper¨   ÚNotImplementedError)
r¸   rº   r»   r¼   r½   r¾   r¿   r   rÀ   rÁ   s
             r"   r[   r[   }  s{  € ð
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
õ �f˜iÑ(Ô(ð IÝÐG¸vÐGÐGÑHÔHÐHÝ�&Ð/Ñ0Ô0ð ØŒ|ÐÝ�&˜=¨.Ð9Ñ:Ô:ð +ØÔ*Ð*Ý�&˜/Ñ*Ô*ð ÝŒ|ÐÝ�&˜<Ð);Ð<Ñ=Ô=ð %ØÔ$Ð$Ý�&Ð4Ñ5Ô5ð ÝŒzÐÝ�&˜-Ñ(Ô(ð KØÔ,Ô9ÐJ½U¼]ÐJÝ�&˜)Ñ$Ô$ð ÝŒ}ÐÝ
˜fÑ
%Ô
%Ð%r$   ÚT)Úboundc                   ó˜   ‡ — e Zd ZdZdeddfˆ fd„Zedee         fd„¦   «         Z	e
deddfd„¦   «         Ze
d	ed
eddfd„¦   «         Zˆ xZS )r   zjCustom fixed size list that only supports right-append and ensures that all values increase monotonically.r   r   Nc                 óV   •— t          ¦   «                              ¦   «          || _        d S rG   )r_   r#   r   )r!   r   rd   s     €r"   r#   z_MonotonicWindow.__init__¤  s$   ø€ Ý‰Œ×ÒÑÔÐØˆŒˆˆr$   c                 ó<   — t          | ¦  «        dk    r| d         S d S )Nr   r2   )r.   rI   s    r"   Úlastz_MonotonicWindow.last¨  s   € åˆt‰9Œ9�qŠ=ˆ=Ø˜”8ˆOØˆtr$   Úxc                 ó¾   — | j         }|�||k    rt          d|› d|› �¦  «        ‚t                               | |¦  «         t	          | ¦  «        | j        k    r| d= d S d S )Nz&Expected the value to increase, last: z, current: r   )rÏ   r-   Úlistr,   r.   r   )r!   rÐ   rÏ   s      r"   r,   z_MonotonicWindow.append®  sq   € àŒyˆØÐ ¨¢	 	ÝÐZÀdÐZÐZÐWXÐZÐZÑ[Ô[Ð[Ý�Š�D˜!ÑÔÐåˆt‰9Œ9�t”{Ò"Ð"Ø�Q���ð #Ð"r$   ÚkeyÚvaluec                 ó    — t          d¦  «        ‚)Nz__setitem__ is not supported)rÉ   )r!   rÓ   rÔ   s      r"   Ú__setitem__z_MonotonicWindow.__setitem__¸  s   € õ "Ð"@ÑAÔAÐAr$   )rK   rL   rM   rN   rP   r#   Úpropertyr   rÊ   rÏ   r
   r,   r   rÖ   rg   rh   s   @r"   r   r   ¡  sê   ø€ € € € € ØtÐtð˜sð  tð ð ð ð ð ð ð ð�h˜q”kð ð ð ñ „Xðð
 ð˜ð ˜dð ð ð ñ „Xðð ðB˜sð B¨3ð B°4ð Bð Bð Bñ „XðBð Bð Bð Bð Br$   r   rG   )-Úcollectionsr   Útypingr   r   r   r   r   r	   r¤   Útyping_extensionsr
   Ú$lightning_fabric.utilities.rank_zeror   r   Úlightning_fabricr   rÂ   r   ÚdictrQ   rP   rO   rR   r   rU   ÚnnÚModuleÚTensorrs   Úfloat64r¨   Úbfloat16Úfloat16rÆ   r‡   rc   Ú__annotations__r±   r3   r^   r[   rÊ   rÒ   r   rS   r$   r"   ú<module>rå      s  ðð Ð Ð Ð Ð Ð Ð Ø IÐ IÐ IÐ IÐ IÐ IÐ IÐ IÐ IÐ IÐ IÐ IÐ IÐ IÐ IÐ Ià €€€Ø &Ð &Ð &Ð &Ð &Ð &à OÐ OÐ OÐ OÐ OÐ OÐ OÐ Oàð 3Ø'Ð'Ð'Ð'Ð'Ð'Ø2Ð2Ð2Ð2Ð2Ð2à˜3  c¨5 jÔ 1Ð1Ô2Ð ð
sð sð sð sð sñ sô sð sðl1ð 1ð 1ð 1ð 1˜
ñ 1ô 1ð 1ðn AEð$*ð $*ØŒ8Œ?ð$*à˜˜Uœ\Ð)Ô*ð$*ð �h ¤˜~¨u¬|Ð;Ô<Ô=ð$*ð 	ð	$*ð $*ð $*ð $*ðN`@ð ØŒ�vØŒ�vØ�FØŒ˜ØŒ�vØŒ
�Fðð`@ð ØŒ�vØŒ�vØ�FØŒ˜ØŒ�vØŒ
�Fðð`@ð( ØŒ�uØŒ�xØ�HØŒ˜	ØŒ�yØŒ
�Iðð)`@ð8 ØŒ�wØŒ�wØ�HØŒ˜ØŒ�xØŒ
�Iðð9`@ðH ØŒ�wØŒ�wØ�FØŒ˜ØŒ�vØŒ
�GððI`@ð\ ØŒ�wØ�GØŒ˜ØŒ�wØŒ
�HØ�	ðð]`@ðl ØŒ�wØ�GØŒ˜ØŒ�wØŒ
�HØ�ððm`@ð| ØŒ�wØ�GØŒ˜ØŒ�wØŒ
�HØ�ðð}`@ðL 	ØŒ�wØ�EØŒ˜ØŒ�vØŒ
�FØ�ððM`@ð\ 
ØŒ�wØ�GØŒ˜ØŒ�vØŒ
�FØ�ðð]`@ðr ØŒ�vØŒ�wØ�FØŒ˜ØŒ�vØŒ
�Fððs`@ðB ØŒ�wØ�GØŒ˜ØŒ�wØŒ
�HØ�ððC`@ðR 
ØŒ�wØ�GØŒ˜ØŒ�wØŒ
�HØ�ððS`@ðd ØŒ�wØ�GØŒ˜ØŒ�vØŒ
�FØ�ððe`@ðt ØŒ�uØ�EØŒ˜ØŒ�uØŒ
�FØ�ððu`@ðD ØŒ�wØ�GØŒ˜ØŒ�wØŒ
�FØ�ððE`@ðT ØŒ�wØ�GØŒ˜ØŒ�wØŒ
�HØ�ððU`@ðf 	Œ�wØ�GØŒ˜ØŒ�wØŒ
�FØ�ðð 	Œ�wØ�GØŒ˜ØŒ�wØŒ
�HØ�ðð 	Œ�vØŒ�uØŒ
�FØ�ð	ð 	Œ�wØŒ�wðð
 	Œ�wØŒ�wØŒ
�HØ�ð	ð 	Œ�wØŒ�wØŒ
�HØ�ð	ð 	Œ�wØŒ�wØŒ
�HØ�ð	ð 	Œ�vØŒ�wØŒ
�FØ�ð	ð 	Œ�wØŒ�wØŒ
�FØ�ð	ð 	Œ�vØŒ�wØŒ�vðð 	Œ�tØŒ�uØŒ�vðð 	Œ�vØŒ�wØŒ�vððw`@ð `@ð `@€ˆT�#�t˜E # u¤{Ð"2Ô3°UÐ:Ô;Ð;Ô<ð `ð `ñ `ðN à
à
àðð €
ðX% ¤ð X%°U¸5¼;ÈÐ;KÔ5Lð X%ÐQYÐZ]ÔQ^ð X%ð X%ð X%ð X%ðv& [ð &°U´[ð &ð &ð &ð &ðB €GˆC�uÐÑÔ€ðBð Bð Bð Bð B�t˜A”wñ Bô Bð Bð Bð Br$   