ёi-xjSSKJr SSKrSSKJrJrJr SSKrSSK r SSK J r J r SSK J r SSKJrJr SSKJr SS KJr \(aSS KJr SSKJr SS K Jr /rS r"S S\R8S9r"SS\5r"SS\5r"SS\5r "SS\5r!SSSjjr"g)) annotationsN) TYPE_CHECKINGAnyLiteral)_C_ops _legacy_C_ops)check_variable_and_dtype)_create_tensor in_pir_mode) LayerHelper)in_dynamic_mode)Sequence)TensorcV[U[R[R45$N) isinstancenpndarraygeneric)vars U/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/metric/metrics.py _is_numpy_r(s cBJJ 3 44c\rSrSrSrS Sjr\RS Sj5r\RS Sj5r \RS Sj5r \RSSj5r SSjr S r g )Metric,a Base class for metric, encapsulates metric logic and APIs Usage: .. code-block:: text m = SomeMetric() for prediction, label in ...: m.update(prediction, label) m.accumulate() Advanced usage for :code:`compute`: Metric calculation can be accelerated by calculating metric states from model outputs and labels by built-in operators not by Python/NumPy in :code:`compute`, metric states will be fetched as NumPy array and call :code:`update` with states in NumPy format. Metric calculated as follows (operations in Model and Metric are indicated with curly brackets, while data nodes not): .. code-block:: text inputs & labels || ------------------ | || {model} || | || outputs & labels || | || tensor data {Metric.compute} || | || metric states(tensor) || | || {fetch as numpy} || ------------------ | || metric states(numpy) || numpy data | || {Metric.update} \/ ------------------ Examples: For :code:`Accuracy` metric, which takes :code:`pred` and :code:`label` as inputs, we can calculate the correct prediction matrix between :code:`pred` and :code:`label` in :code:`compute`. For examples, prediction results contains 10 classes, while :code:`pred` shape is [N, 10], :code:`label` shape is [N, 1], N is mini-batch size, and we only need to calculate accuracy of top-1 and top-5, we could calculate the correct prediction matrix of the top-5 scores of the prediction of each sample like follows, while the correct prediction matrix shape is [N, 5]. .. code-block:: python :name: code-compute-example >>> import paddle >>> def compute(pred, label): ... # sort prediction and slice the top-5 scores ... pred = paddle.argsort(pred, descending=True)[:, :5] ... # calculate whether the predictions are correct ... correct = pred == label ... return paddle.cast(correct, dtype='float32') ... With the :code:`compute`, we split some calculations to OPs (which may run on GPU devices, will be faster), and only fetch 1 tensor with shape as [N, 5] instead of 2 tensors with shapes as [N, 10] and [N, 1]. :code:`update` can be define as follows: .. code-block:: python :name: code-update-example >>> def update(self, correct): ... accs = [] ... for i, k in enumerate(self.topk): ... num_corrects = correct[:, :k].sum() ... num_samples = len(correct) ... accs.append(float(num_corrects) / num_samples) ... self.total[i] += num_corrects ... self.count[i] += num_samples ... return accs cgrselfs r__init__Metric.__init__s rcH[SURRS35e) Reset states and result z$function 'reset' not implemented in .NotImplementedError __class____name__r s rreset Metric.resets( "24>>3J3J2K1 M  rcH[SURRS35e)a= Update states for metric Inputs of :code:`update` is the outputs of :code:`Metric.compute`, if :code:`compute` is not defined, the inputs of :code:`update` will be flatten arguments of **output** of mode and **label** from data: :code:`update(output1, output2, ..., label1, label2,...)` see :code:`Metric.compute` z%function 'update' not implemented in r&r'r!argss rupdate Metric.updates("3DNN4K4K3LA N  rcH[SURRS35e)z? Accumulates statistics, computes and returns the metric value z)function 'accumulate' not implemented in r&r'r s r accumulateMetric.accumulates) "78O8O7PPQ R  rcH[SURRS35e) Returns metric name z#function 'name' not implemented in r&r'r s rname Metric.names( "1$..2I2I1J! L  rcU$)a This API is advanced usage to accelerate metric calculating, calculations from outputs of model to the states which should be updated by Metric can be defined here, where Paddle OPs is also supported. Outputs of this API will be the inputs of "Metric.update". If :code:`compute` is defined, it will be called with **outputs** of model and **labels** from data as arguments, all outputs and labels will be concatenated and flatten and each filed as a separate argument as follows: :code:`compute(output1, output2, ..., label1, label2,...)` If :code:`compute` is not defined, default behaviour is to pass input to output, so output format will be: :code:`return output1, output2, ..., label1, label2,...` see :code:`Metric.update` rr.s rcomputeMetric.computes & rrNreturnNone)r/rr=r>)r=rr=str)r/rr=r)r* __module__ __qualname____firstlineno____doc__r"abcabstractmethodr+r0r3r7r:__static_attributes__rrrrr,s{Pd               rr) metaclassc^\rSrSr%SrS\S'S\S'SSU4SjjjrSSjrSS jrSS jr SS jr SS jr SS jr Sr U=r$)Accuracya Encapsulates accuracy metric logic. Args: topk (list[int]|tuple[int]): Number of top elements to look at for computing accuracy. Default is (1,). name (str|None, optional): String name of the metric instance. Default is `acc`. Examples: .. code-block:: python :name: code-standalone-example >>> import numpy as np >>> import paddle >>> x = paddle.to_tensor(np.array([ ... [0.1, 0.2, 0.3, 0.4], ... [0.1, 0.4, 0.3, 0.2], ... [0.1, 0.2, 0.4, 0.3], ... [0.1, 0.2, 0.3, 0.4]])) >>> y = paddle.to_tensor(np.array([[0], [1], [2], [3]])) >>> m = paddle.metric.Accuracy() >>> correct = m.compute(x, y) >>> m.update(correct) >>> res = m.accumulate() >>> print(res) 0.75 .. code-block:: python :name: code-model-api-example >>> # doctest: +TIMEOUT(80) >>> import paddle >>> from paddle.static import InputSpec >>> import paddle.vision.transforms as T >>> from paddle.vision.datasets import MNIST >>> input = InputSpec([None, 1, 28, 28], 'float32', 'image') >>> label = InputSpec([None, 1], 'int64', 'label') >>> transform = T.Compose([T.Transpose(), T.Normalize([127.5], [127.5])]) >>> train_dataset = MNIST(mode='train', transform=transform) >>> model = paddle.Model(paddle.vision.models.LeNet(), input, label) >>> optim = paddle.optimizer.Adam( ... learning_rate=0.001, parameters=model.parameters()) >>> model.prepare( ... optim, ... loss=paddle.nn.CrossEntropyLoss(), ... metrics=paddle.metric.Accuracy()) ... >>> model.fit(train_dataset, batch_size=64) Sequence[int]topkintmaxkc>[TU]"U0UD6 Xl[U5UlUR U5 UR 5 gr)superr"rMmaxrO _init_namer+)r!rMr7r/kwargsr)s rr"Accuracy.__init__s< $)&) I   rc[R"USS9n[R"U[UR5S- /S/UR /S9n[UR5S:Xd,[UR5S:Xa+URSS:Xa[R "US5nO)URSS:wa[R"USSS 9nXRUR5:Hn[R"US S 9$) a Compute the top-k (maximum value in `topk`) indices. Args: pred (Tensor): The predicted value is a Tensor with dtype float32 or float64. Shape is [batch_size, d0, ..., dN]. label (Tensor): The ground truth value is Tensor with dtype int64. Shape is [batch_size, d0, ..., 1], or [batch_size, d0, ..., num_classes] in one hot representation. Return: Tensor: Correct mask, a tensor with shape [batch_size, d0, ..., topk]. T) descendingr)axesstartsendsr )r\rX)axiskeepdimfloat32dtype) paddleargsortslicelenshaperOreshapeargmaxastyperacast)r!predlabelr/corrects rr:Accuracy.compute s~~dt4|| DJJ!+,aS {    !   !ekk"o&: NN5'2E [[_ !MM%b$?E,,tzz22{{7)44rc&[U[R5(a[R"U5n[R "[R"UR SS55n/n[UR5HgupVUSSU24R5nUR[U5U- 5 URU==U- ss'URU==U- ss'Mi [UR5S:XaUSnU$UnU$)a7 Update the metrics states (correct count and total count), in order to calculate cumulative accuracy of all instances. This function also returns the accuracy of current step. Args: correct: Correct mask, a tensor with shape [batch_size, d0, ..., topk]. Return: Tensor: the accuracy of current step. Nr\.rXr)rrbrrarrayprodrf enumeraterMsumappendfloattotalcountre)r!rmr/ num_samplesaccsik num_correctss rr0Accuracy.update+s gv}} - -hhw'Gggbhhw}}Sb'9:; dii(DA"37+//1L KKl+k9 : JJqM\ )M JJqM[ (M ) dii.A-tAw 48 rc|S/[UR5-UlS/[UR5-Ulg)! Resets all of the metric state. rN)rerMrvrwr s rr+Accuracy.resetCs0US^+ S3tyy>) rc/n[URUR5H,up#US:a[U5U- OSnUR U5 M. [ UR 5S:XaUSnU$UnU$)z. Computes and returns the accumulated metric. rrrX)ziprvrwrurtrerM)r!restcrs rr3Accuracy.accumulateJso DJJ/DA !Aa1 3A JJqM0DII!+c!f 25 rcU=(d SnURS:wa'URVs/sH o!SU3PM snUlgU/Ulgs snf)NaccrX_top)rOrM_name)r!r7r{s rrSAccuracy._init_nameUsG}u 99>48II>IqF$qc*I>DJDJ?sA cUR$)z! Return name of metric instance. rr s rr7 Accuracy.name\zzr)rrwrOrMrv))rXN) rMrLr7 str | Noner/rrTrr=r>)rkrrlrr/rr=r)rmrr/rr=rr<)r=z list[float])r7rr=r>)r=z list[str])r*rArBrCrD__annotations__r"r:r0r+r3rSr7rG __classcell__r)s@rrJrJs{6p  I#         5>0*  rrJc^\rSrSr%SrS\S'S\S'S S U4SjjjrSSjrSSjrSS jr SS jr S r U=r $) Precisionicag Precision (also called positive predictive value) is the fraction of relevant instances among the retrieved instances. Refer to https://en.wikipedia.org/wiki/Evaluation_of_binary_classifiers Noted that this class manages the precision score only for binary classification task. Args: name (str, optional): String name of the metric instance. Default is `precision`. Examples: .. code-block:: python :name: code-standalone-example >>> import numpy as np >>> import paddle >>> x = np.array([0.1, 0.5, 0.6, 0.7]) >>> y = np.array([0, 1, 1, 1]) >>> m = paddle.metric.Precision() >>> m.update(x, y) >>> res = m.accumulate() >>> print(res) 1.0 .. code-block:: python :name: code-model-api-example >>> import numpy as np >>> import paddle >>> import paddle.nn as nn >>> class Data(paddle.io.Dataset): # type: ignore[type-arg] ... def __init__(self): ... super().__init__() ... self.n = 1024 ... self.x = np.random.randn(self.n, 10).astype('float32') ... self.y = np.random.randint(2, size=(self.n, 1)).astype('float32') ... ... def __getitem__(self, idx): ... return self.x[idx], self.y[idx] ... ... def __len__(self): ... return self.n ... >>> model = paddle.Model(nn.Sequential( ... nn.Linear(10, 1), ... nn.Sigmoid() ... )) >>> optim = paddle.optimizer.Adam( ... learning_rate=0.001, parameters=model.parameters()) >>> model.prepare( ... optim, ... loss=nn.BCELoss(), ... metrics=paddle.metric.Precision()) ... >>> data = Data() >>> model.fit(data, batch_size=16) rNtpfpcN>[TU]"U0UD6 SUlSUlXlgNr)rQr"rrrr!r7r/rTr)s rr"Precision.__init__s* $)&) rc\[U[R5(a[R"U5nO[ U5(d [ S5e[U[R5(a[R"U5nO[ U5(d [ S5eURSn[R"US-5RS5n[U5HDnXnX$nUS:XdMXV:XaU=RS- sl M/U=RS- sl MF g)a Update the states based on the current mini-batch prediction results. Args: preds (numpy.ndarray): The prediction result, usually the output of two-class sigmoid function. It should be a vector (column vector or row vector) with data type: 'float64' or 'float32'. labels (numpy.ndarray): The ground truth (labels), the shape should keep the same as preds. The data type is 'int32' or 'int64'. .The 'preds' must be a numpy ndarray or Tensor./The 'labels' must be a numpy ndarray or Tensor.rg?int32rXN) rrbrrrpr ValueErrorrffloorrirangerrr!predslabels sample_numrzrkrls rr0Precision.updates eV]] + +HHUOEE""MN N ffmm , ,XXf%FF##NO O\\!_ %,,W5z"A8DIEqy=GGqLGGGqLG#rc SUlSUlgrrN)rrr s rr+Precision.resetrctURUR-nUS:wa[UR5U- $S$)zc Calculate the final precision. Returns: A scaler float: results of the calculated precision. rr)rrru)r!aps rr3Precision.accumulates4WWtww &(AguTWW~"636rcUR$r6rr s rr7Precision.namerr)rrr) precisionr7r@r/rrTrr=r>rz-npt.NDArray[np.float32 | np.float64] | Tensorrz)npt.NDArray[np.int32 | np.int64] | Tensorr=r>r<r=rur?) r*rArBrCrDrr"r0r+r3r7rGrrs@rrrcsz>@ G G&.1=@ $!<$!:$!  $!L7rrc~^\rSrSr%SrS\S'S\S'S S U4SjjjrSSjrSSjrSS jr SS jr S r U=r $)Recallia Recall (also known as sensitivity) is the fraction of relevant instances that have been retrieved over the total amount of relevant instances Refer to: https://en.wikipedia.org/wiki/Precision_and_recall Noted that this class manages the recall score only for binary classification task. Args: name (str, optional): String name of the metric instance. Default is `recall`. Examples: .. code-block:: python :name: code-standalone-example >>> import numpy as np >>> import paddle >>> x = np.array([0.1, 0.5, 0.6, 0.7]) >>> y = np.array([1, 0, 1, 1]) >>> m = paddle.metric.Recall() >>> m.update(x, y) >>> res = m.accumulate() >>> print(res) 0.6666666666666666 .. code-block:: python :name: code-model-api-example >>> import numpy as np >>> import paddle >>> import paddle.nn as nn >>> class Data(paddle.io.Dataset): # type: ignore[type-arg] ... def __init__(self): ... super().__init__() ... self.n = 1024 ... self.x = np.random.randn(self.n, 10).astype('float32') ... self.y = np.random.randint(2, size=(self.n, 1)).astype('float32') ... ... def __getitem__(self, idx): ... return self.x[idx], self.y[idx] ... ... def __len__(self): ... return self.n ... >>> model = paddle.Model(nn.Sequential( ... nn.Linear(10, 1), ... nn.Sigmoid() ... )) >>> optim = paddle.optimizer.Adam( ... learning_rate=0.001, parameters=model.parameters()) >>> model.prepare( ... optim, ... loss=nn.BCELoss(), ... metrics=[paddle.metric.Precision(), paddle.metric.Recall()]) ... >>> data = Data() >>> model.fit(data, batch_size=16) rNrfncN>[TU]"U0UD6 SUlSUlXlgr)rQr"rrrrs rr"Recall.__init__4s( $)&) rcV[U[R5(a[R"U5nO[ U5(d [ S5e[U[R5(a[R"U5nO[ U5(d [ S5eURSn[R"U5RS5n[U5HDnXnX$nUS:XdMXV:XaU=RS- sl M/U=RS- sl MF g)a Update the states based on the current mini-batch prediction results. Args: preds(numpy.array): prediction results of current mini-batch, the output of two-class sigmoid function. Shape: [batch_size, 1]. Dtype: 'float64' or 'float32'. labels(numpy.array): ground truth (labels) of current mini-batch, the shape should keep the same as preds. Shape: [batch_size, 1], Dtype: 'int32' or 'int64'. rrrrrXN) rrbrrrprrrfrintrirrrrs rr0 Recall.update:s eV]] + +HHUOEE""MN N ffmm , ,XXf%FF##NO O\\!_ %%g.z"A8DIEz=GGqLGGGqLG#rctURUR-nUS:wa[UR5U- $S$)z] Calculate the final recall. Returns: A scaler float: results of the calculated Recall. rr)rrru)r!recalls rr3Recall.accumulate`s4477"*0A+uTWW~&>3>rc SUlSUlgr)rrr s rr+ Recall.resetjrrcUR$rrr s rr7 Recall.nameqrr)rrr)rrrrr<r?) r*rArBrCrDrr"r0r3r+r7rGrrs@rrrsVAF G G $!<$!:$!  $!L?rrc^\rSrSrSrS S U4SjjjrS Sjr\S Sj5rSSjr SSjr SSjr S r U=r $)Aucixa@ The auc metric is for binary classification. Refer to https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve. Please notice that the auc metric is implemented with python, which may be a little bit slow. The `auc` function creates four local variables, `true_positives`, `true_negatives`, `false_positives` and `false_negatives` that are used to compute the AUC. To discretize the AUC curve, a linearly spaced set of thresholds is used to compute pairs of recall and precision values. The area under the ROC-curve is therefore computed using the height of the recall values by the false positive rate, while the area under the PR-curve is the computed using the height of the precision values by the recall. Args: curve (str): Specifies the mode of the curve to be computed, 'ROC' or 'PR' for the Precision-Recall-curve. Default is 'ROC'. num_thresholds (int): The number of thresholds to use when discretizing the roc curve. Default is 4095. name (str, optional): String name of the metric instance. Default is `auc`. "NOTE: only implement the ROC curve type via Python now." Examples: .. code-block:: python :name: code-standalone-example >>> import numpy as np >>> import paddle >>> m = paddle.metric.Auc() >>> n = 8 >>> class0_preds = np.random.random(size = (n, 1)) >>> class1_preds = 1 - class0_preds >>> preds = np.concatenate((class0_preds, class1_preds), axis=1) >>> labels = np.random.randint(2, size = (n, 1)) >>> m.update(preds=preds, labels=labels) >>> res = m.accumulate() .. code-block:: python :name: code-model-api-example >>> import numpy as np >>> import paddle >>> import paddle.nn as nn >>> class Data(paddle.io.Dataset): # type: ignore[type-arg] ... def __init__(self): ... super().__init__() ... self.n = 1024 ... self.x = np.random.randn(self.n, 10).astype('float32') ... self.y = np.random.randint(2, size=(self.n, 1)).astype('int64') ... ... def __getitem__(self, idx): ... return self.x[idx], self.y[idx] ... ... def __len__(self): ... return self.n ... >>> model = paddle.Model(nn.Sequential( ... nn.Linear(10, 2), nn.Softmax()) ... ) >>> optim = paddle.optimizer.Adam( ... learning_rate=0.001, parameters=model.parameters()) ... >>> def loss(x, y): ... return nn.functional.nll_loss(paddle.log(x), y) ... >>> model.prepare( ... optim, ... loss=loss, ... metrics=paddle.metric.Auc()) >>> data = Data() >>> model.fit(data, batch_size=16) c>[TU]"U0UD6 XlX lUS-n[R "U5Ul[R "U5UlX0lg)NrX) rQr"_curve_num_thresholdsrzeros _stat_pos _stat_negr)r!curvenum_thresholdsr7r/rT_num_pred_bucketsr)s rr" Auc.__init__sT $)&) -*Q."34"34 rc:[U[R5(a[R"U5nO[ U5(d [ S5e[U[R5(a[R"U5nO[ U5(d [ S5e[U5Hjup4XS4n[XPR-5nX`R::deU(aURU==S- ss'MSURU==S- ss'Ml g)a Update the auc curve with the given predictions and labels. Args: preds (numpy.array): An numpy array in the shape of (batch_size, 2), preds[i][j] denotes the probability of classifying the instance i into the class j. labels (numpy.array): an numpy array in the shape of (batch_size, 1), labels[i] is either o or 1, representing the label of the instance i. rrrXg?N) rrbrrrprrrrrNrrr)r!rrrzlblvaluebin_idxs rr0 Auc.updates ffmm , ,XXf%FF##NO O eV]] + +HHUOEE""MN N'FAQ$KE%"6"667G222 22w'3.'w'3.'(rc,[X- 5X#--S- $)Ng@)abs)x1x2y1y2s rtrapezoid_areaAuc.trapezoid_areas27|rw'#--rcSnSnSnURnUS:aGUnUnXRU- nX RU- nX0RX&X5- nUS-nUS:aMGUS:a US:aX1- U- $S$)z^ Return the area (a float score) under auc curve Return: float: the area under auc curve rrrX)rrrr)r!tot_postot_negaucidx tot_pos_prev tot_neg_prevs rr3Auc.accumulates""Qh"L"L ~~c* *G ~~c* *G &&w C 1HCQh(/}3CMG # LO rcURS-n[R"U5Ul[R"U5Ulg)r%rXN)rrrrr)r!rs rr+ Auc.resets7!0014"34"34rcUR$rrr s rr7Auc.name"rr)rrrrr)ROCir) rzLiteral['ROC', 'PR']rrNr7r@r/rrTrr=r>r) rrurrurrurrur=rurr<r?)r*rArBrCrDr"r0 staticmethodrr3r+r7rGrrs@rrrxsMb'," #      "!/<!/:!/  !/F.. 45rrcUR[R:Xa%[R"U[R5n[ 5(aLUc [ SS9nUc [ SS9n[R"XS9upg[R"XgXU5un n U$[5(a3[R"XS9upg[R"XgU5un n U$[S 0[5D6n [US/SQS5 [R"XS9upgU RSS9n UcU RSS9nUcU RSS9nU R!SU/U/U/S.U /U/U/S .S 9 U $) aO accuracy layer. Refer to the https://en.wikipedia.org/wiki/Precision_and_recall This function computes the accuracy using the input and label. If the correct label occurs in top k predictions, then correct will increment by one. Note: the dtype of accuracy is determined by input. the input and label dtype can be different. Args: input(Tensor): The input of accuracy layer, which is the predictions of network. A Tensor with type float32,float64. The shape is ``[sample_number, class_dim]`` . label(Tensor): The label of dataset. Tensor with type int64 or int32. The shape is ``[sample_number, 1]`` . k(int, optional): The top k predictions for each class will be checked. Data type is int64 or int32. correct(Tensor, optional): The correct predictions count. A Tensor with type int64 or int32. total(Tensor, optional): The total entries count. A tensor with type int64 or int32. name(str|None, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` Returns: Tensor, the correct rate. A Tensor with type float32. Examples: .. code-block:: python >>> import paddle >>> predictions = paddle.to_tensor([[0.2, 0.1, 0.4, 0.1, 0.1], [0.2, 0.3, 0.1, 0.15, 0.25]], dtype='float32') >>> label = paddle.to_tensor([[2], [0]], dtype="int64") >>> result = paddle.metric.accuracy(input=predictions, label=label, k=1) >>> print(result) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 0.50000000) rr`)r{accuracyinput)float16uint16r_float64r_)OutIndicesLabel)rJCorrectTotal)typeinputsoutputs)r)rarbrrjint64rr rMrrr rr localsr "create_variable_for_type_inference append_op) rrlr{rmrvr7topk_out topk_indices_acc_helperacc_outs rrr)spR {{fll" E6<<0 ?$73G ="1E!'U!8"++ EE a !'U!8__XUC a  0vx 0F wCZ$[[4H77i7HG;;';J }999H   z|nwO yW  Nr)rXNNN)rrrlrr{rNrm Tensor | Nonervrr7rr=r)# __future__rrEtypingrrrnumpyrrbrrbase.data_feederr base.frameworkr r base.layer_helperr frameworkrcollections.abcr numpy.typingnptr__all__rABCMetarrJrrrrrrrrs# .. (78+'( 5Ts{{Tn]v]@GGTHVHVn&nh! O O O O O  O  O Or