ёiEJ%SSKJr SSKrSSKrSSKrSSKrSSKJrJr SSK J r J r J r J r JrJrJr SSKrSSKJr SSKrSSKJr \ (a5SSKJ r SSKJr SS KJr SS KJ r J!r!J"r"J#r# \\ S r$S \%S 'SSKJ&r&J'r'J(r( \"SSSSSS9r)\"SSSSSS9r*"SS\\ \)\*45r+/r,Sr-SS\."S54S4Sjr/"SS\+\)\*45r0"SS\+\)\*45r1"S S!\1\)S45r2"S"S#\1\)\*45r3"S$S%\1\)\*45r4"S&S'\1\)\*45r5"S(S)\1\)\*45r6"S*S+\1\)\*45r7"S,S-\1\)\*45r8"S.S/\1\)\*45r9"S0S1\1\)\*45r:"S2S3\1\)\*45r;"S4S5\1\)\*45r<"S6S7\1\)\*45r="S8S9\1\)\*45r>"S:S;\1\)\*45r?"S<S=\1\)\*45r@S>rASJS?jrB"S@SA\1\)\*45rC"SBSC\1\)\*45rD"SDSE\1\)\*45rE"SFSG\1\)\*45rF"SHSI\1\)\*45rGg)K) annotationsN)IterableSequence) TYPE_CHECKINGAnyGenericLiteralProtocolTypeVaroverload) TypeAlias) functional)Image)Tensor)DataLayoutImageSize2Size3Size4)imagecoordsboxesmaskr _TransformInputKeys)_InterpolationCv2_InterpolationPil _PaddingMode_InputTrPILImageznpt.NDArray[Any]T) contravariant_RetT) covariantcF\rSrSr\SSj5r\SSj5rS SjrSrg) _Transform?cgNselfdatas c/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/vision/transforms/transforms.py__call___Transform.__call__@03cgr'r(r)s r,r-r.CHKr0cgr'r(r)s r,r-r.FsSr0r(Nr+rreturnr!r+tuple[_InputT, ...]r5tuple[_RetT, ...]r5r)__name__ __module__ __qualname____firstlineno__r r-__static_attributes__r(r0r,r$r$?s! 33 KK(r0r$c[R"U5(a UR$[R"U5(aURSSSSS2$[R "U5(a}[ UR5S:XaURSSSSS2$[ UR5S:XaURSSSSS2$[S[ UR535e[S[U535e)NrzQ 99QR=2& & ^q 99QR=2& &NsSVS\S\~N^_ *49+677r0infc[U[R5(a7US:a[SUS35eX - X -/nU(a[ USS5US'Ok[U[ [ 45(aB[U5S:Xa3USUSs=::aUSs=::a US::dO [USU35eO[US35eUSUSs=:XaU:XaO U$SnU$)NrIf z- is a single number, it must be non negative.r@rz values should be between z9 should be a single number or a list/tuple with length 2.) isinstancenumbersNumberrKmaxtuplelistrJrL)valuenamecenterboundclip_first_on_zeros r, _check_inputr_^s%(( 19dVHI 0 58Q'E!H EE4= ) )c%jAoQx58;uQx;58;v%?wGH H<fM N   Qx58%v% L Lr0cj\rSrSr%SrS\S'S Sjr\S Sj5r\SSj5rSSjrSS jr S r g )Composeva) Composes several transforms together use for composing list of transforms together for a dataset transform. Args: transforms (list|tuple): List/Tuple of transforms to compose. Returns: A compose object which is callable, __call__ for this Compose object will call each given :attr:`transforms` sequently. Examples: .. code-block:: python >>> from paddle.vision.datasets import Flowers >>> from paddle.vision.transforms import Compose, ColorJitter, Resize >>> transform = Compose([ColorJitter(), Resize(size=608)]) >>> flowers = Flowers(mode='test', transform=transform) >>> for i in range(3): ... sample = flowers[i] ... print(sample[0].size, sample[1]) (916, 608) [1] (758, 608) [1] (811, 608) [1] Sequence[_Transform[Any, Any]] transformscXlgr'rd)r*rds r,__init__Compose.__init__s$r0cgr'r(r)s r,r-Compose.__call__r/r0cgr'r(r)s r,r-rjr2r0c URH nU"U5nM U$![a0n[R"5n[ SUSUSU35 UeSnAff=f)Nzfail to perform transform [z] with error: z and stack: )rd Exception traceback format_excprint)r*r+fe stack_infos r,r-rjsmA w!  &113 1!Nczl4  s A+AAcURRS-nURHnUS- nUSU3- nM US- nU$)N( z z )) __class__r:rd)r* format_stringts r,__repr__Compose.__repr__sP//#5 A T !M tA3Z 'M!  r0rfN)rdrcr5Noner4r6r9)r5str) r:r;r<r=__doc____annotations__rgr r-rzr>r(r0r,raravs<6/.%33 KK r0rac\rSrSr%SrS\S'S\S'SSSjjrS r\SS j5r \SS j5r SS jr S r Sr Sr Sr SrSrg) BaseTransforma Base class of all transforms used in computer vision. calling logic: .. code-block:: text if keys is None: _get_params -> _apply_image() else: _get_params -> _apply_*() for * in keys If you want to implement a self-defined transform method for image, rewrite _apply_* method in subclass. Args: keys (list[str]|tuple[str], optional): Input type. Input is a tuple contains different structures, key is used to specify the type of input. For example, if your input is image type, then the key can be None or ("image"). if your input is (image, image) type, then the keys should be ("image", "image"). if your input is (image, boxes), then the keys should be ("image", "boxes"). Current available strings & data type are describe below: - "image": input image, with shape of (H, W, C) - "coords": coordinates, with shape of (N, 2) - "boxes": bounding boxes, with shape of (N, 4), "xyxy" format,the 1st "xy" represents top left point of a box,the 2nd "xy" represents right bottom point. - "mask": map used for segmentation, with shape of (H, W, 1) You can also customize your data types only if you implement the corresponding _apply_*() methods, otherwise ``NotImplementedError`` will be raised. Examples: .. code-block:: python >>> import numpy as np >>> from PIL import Image >>> import paddle.vision.transforms.functional as F >>> from paddle.vision.transforms import BaseTransform >>> def _get_image_size(img): ... if F._is_pil_image(img): ... return img.size ... elif F._is_numpy_image(img): ... return img.shape[:2][::-1] ... else: ... raise TypeError("Unexpected type {}".format(type(img))) ... >>> class CustomRandomFlip(BaseTransform): # type: ignore[type-arg] ... def __init__(self, prob=0.5, keys=None): ... super().__init__(keys) ... self.prob = prob ... ... def _get_params(self, inputs): ... image = inputs[self.keys.index('image')] ... params = {} ... params['flip'] = np.random.random() < self.prob ... params['size'] = _get_image_size(image) ... return params ... ... def _apply_image(self, image): ... if self.params['flip']: ... return F.hflip(image) ... return image ... ... # if you only want to transform image, do not need to rewrite this function ... def _apply_coords(self, coords): ... if self.params['flip']: ... w = self.params['size'][0] ... coords[:, 0] = w - coords[:, 0] ... return coords ... ... # if you only want to transform image, do not need to rewrite this function ... def _apply_boxes(self, boxes): ... idxs = np.array([(0, 1), (2, 1), (0, 3), (2, 3)]).flatten() ... coords = np.asarray(boxes).reshape(-1, 4)[:, idxs].reshape(-1, 2) ... coords = self._apply_coords(coords).reshape((-1, 4, 2)) ... minxy = coords.min(axis=1) ... maxxy = coords.max(axis=1) ... trans_boxes = np.concatenate((minxy, maxxy), axis=1) ... return trans_boxes ... ... # if you only want to transform image, do not need to rewrite this function ... def _apply_mask(self, mask): ... if self.params['flip']: ... return F.hflip(mask) ... return mask ... >>> # create fake inputs >>> fake_img = Image.fromarray((np.random.rand(400, 500, 3) * 255.).astype('uint8')) >>> fake_boxes = np.array([[2, 3, 200, 300], [50, 60, 80, 100]]) >>> fake_mask = fake_img.convert('L') >>> # only transform for image: >>> flip_transform = CustomRandomFlip(1.0) >>> converted_img = flip_transform(fake_img) >>> # transform for image, boxes and mask >>> flip_transform = CustomRandomFlip(1.0, keys=('image', 'boxes', 'mask')) >>> (converted_img, converted_boxes, converted_mask) = flip_transform((fake_img, fake_boxes, fake_mask)) >>> converted_boxes array([[300, 3, 498, 300], [420, 60, 450, 100]]) rkeysrparamsNcUcSnO#[U[5(d[SU35eUH#nURU5bM[ US35e XlSUlg)N)rz(keys should be a sequence, but got keys=z is unsupported data structure)rTrrK _get_applyNotImplementedErrorrr)r*rks r,rgBaseTransform.__init__!sh <DD(++GvNO OAq!))QC/M*NOO  r0cgr'r(r*inputss r, _get_paramsBaseTransform._get_params.s r0cgr'r(rs r,r-BaseTransform.__call__1s25r0cgr'r(rs r,r-r4sJMr0cH[U[5(dU4nURU5Ul/n[ [ [ U5[ UR555HRnURURU5nUcURX5 M9URU"X55 MT [ U5[ UR5:a'URU[ UR5S5 [ U5S:XaUSnU$[U5nU$)z$Apply transform on single input dataNrr) rTrXrrrangeminrJrrappendextend)r*routputsi apply_funcs r,r-r7s&%((YF&&v. s3v;DII78A16J!vy)z&)45 9 v;TYY ' NN6#dii."23 4 w<1 ajGGnGr0c"[USU3S5$)N_apply_)getattr)r*keys r,rBaseTransform._get_applyNstwse_d33r0c[er'r)r*rs r, _apply_imageBaseTransform._apply_imageQ!!r0c[er'r)r*rs r, _apply_boxesBaseTransform._apply_boxesTrr0c[er'r)r*rs r, _apply_maskBaseTransform._apply_maskWrr0c[er'r)r*rs r, _apply_coordsBaseTransform._apply_coordsZrr0)rrr')r_TransformInputKeys | Noner5r|)rrr5r!)rr7r5r8r9)r:r;r<r=r~rrgrr r-rrrrrr>r(r0r,rrs\hT  K  55 MM.4""""r0rcT^\rSrSr%SrS\S'SS U4SjjjrSrSrU=r $) ToTensori^aConvert a ``PIL.Image`` or ``numpy.ndarray`` to ``paddle.Tensor``. Converts a PIL.Image or numpy.ndarray (H x W x C) to a paddle.Tensor of shape (C x H x W). If input is a grayscale image (H x W), it will be converted to an image of shape (H x W x 1). And the shape of output tensor will be (1 x H x W). If you want to keep the shape of output tensor as (H x W x C), you can set data_format = ``HWC`` . Converts a PIL.Image or numpy.ndarray in the range [0, 255] to a paddle.Tensor in the range [0.0, 1.0] if the PIL Image belongs to one of the modes (L, LA, P, I, F, RGB, YCbCr, RGBA, CMYK, 1) or if the numpy.ndarray has dtype = np.uint8. In the other cases, tensors are returned without scaling. Args: data_format (str, optional): Data format of output tensor, should be 'HWC' or 'CHW'. Default: 'CHW'. keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray): The input image with shape (H x W x C). - output(np.ndarray): A tensor with shape (C x H x W) or (H x W x C) according option data_format. Returns: A callable object of ToTensor. Examples: .. code-block:: pycon >>> from PIL import Image >>> import paddle >>> import paddle.vision.transforms as T >>> import paddle.vision.transforms.functional as F >>> img_arr = ((paddle.rand((4, 5, 3)) * 255.0).astype('uint8')).numpy() >>> fake_img = Image.fromarray(img_arr) >>> transform = T.ToTensor() >>> tensor = transform(fake_img) >>> print(tensor.shape) paddle.Size([3, 4, 5]) >>> print(tensor.dtype) paddle.float32 r data_formatc0>[TU]U5 Xlgr')superrgr)r*rrrws r,rgToTensor.__init__s &r0cB[R"XR5$)zo Args: img (PIL.Image|np.ndarray): Image to be converted to tensor. Returns: Tensor: Converted image. )rD to_tensorrr*rOs r,rToTensor._apply_images{{3 0 011r0)r)CHWN)rrrrr5r| r:r;r<r=r~rrgrr> __classcell__rws@r,rr^sI,\! (-+/'$')'  ''22r0rcb^\rSrSr%SrS\S'S\S'S S U4SjjjrSrS rU=r $) ResizeiaResize the input Image to the given size. Args: size (int|list|tuple): Desired output size. If size is a sequence like (h, w), output size will be matched to this. If size is an int, smaller edge of the image will be matched to this number. i.e, if height > width, then image will be rescaled to (size * height / width, size) interpolation (int|str, optional): Interpolation method. Default: 'bilinear'. when use pil backend, support method are as following: - "nearest": Image.NEAREST, - "bilinear": Image.BILINEAR, - "bicubic": Image.BICUBIC, - "box": Image.BOX, - "lanczos": Image.LANCZOS, - "hamming": Image.HAMMING when use cv2 backend, support method are as following: - "nearest": cv2.INTER_NEAREST, - "bilinear": cv2.INTER_LINEAR, - "area": cv2.INTER_AREA, - "bicubic": cv2.INTER_CUBIC, - "lanczos": cv2.INTER_LANCZOS4 keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): A resized image. Returns: A callable object of Resize. Examples: .. code-block:: python >>> import numpy as np >>> from PIL import Image >>> from paddle.vision.transforms import Resize >>> fake_img = Image.fromarray((np.random.rand(256, 300, 3) * 255.).astype(np.uint8)) >>> transform = Resize(size=224) >>> converted_img = transform(fake_img) >>> print(converted_img.size) (262, 224) >>> transform = Resize(size=(200,150)) >>> converted_img = transform(fake_img) >>> print(converted_img.size) (150, 200) rrF%_InterpolationPil | _InterpolationCv2 interpolationc>[TU]U5 [U[5(d&[U[5(a[ U5S:XdeXlX lg)Nr@)rrgrTintrrJrFr)r*rFrrrws r,rgResize.__init__sM $$$ tX & &3t9>   *r0cX[R"XRUR5$r')rDresizerFrrs r,rResize._apply_imagesxxYY(:(:;;r0)rrF)bilinearN)rFrrrrrr5r|rrs@r,rrsZ0d K88 @J+/ + += +) +  + +<>> import numpy as np >>> from PIL import Image >>> from paddle.vision.transforms import RandomResizedCrop >>> transform = RandomResizedCrop(224) >>> fake_img = Image.fromarray((np.random.rand(300, 320, 3) * 255.).astype(np.uint8)) >>> fake_img = transform(fake_img) >>> print(fake_img.size) (224, 224) rrFSequence[float]scaleratiorrc>[TU]U5 [U[5(a X4UlOXlUSUS::dS5eUSUS::dS5eX lX0lX@lg)Nrrz"scale should be of kind (min, max)"ratio should be of kind (min, max))rrgrTrrFrrr)r*rFrrrrrws r,rgRandomResizedCrop.__init__ su  dC  DIIQx58#I%II#Qx58#I%II#  *r0c  [U5up4XC-n[U5GH*n[RR"UR 6U-n[ SUR55n[R"[RR"U65n [[[R"Xy-555n [[[R"Xy- 555n SU s=:aU::dMO MSU s=:aU::dMO M[R"SXK- 5n [R"SX:- 5n XX4s $ [U5[U5- nU[UR5:a-Un [[U [UR5- 55n OJU[!UR5:a-Un [[U [!UR5-55n OUn Un XK- S-n X:- S-n XX4$)Nc3N# UHn[R"U5v M g7fr'mathlog.0xs r, 7RandomResizedCrop._dynamic_get_param..9s>:adhhqkk:#%rr@)rPrnprandomuniformrrXrrexprroundsqrtrandintfloatrrW)r*rattemptswidthheightarea_ target_area log_ratio aspect_ratiowhrjin_ratios r,_dynamic_get_param$RandomResizedCrop._dynamic_get_param3s'. ~xA))++TZZ84?K>4::>>I88BII$5$5y$ABLE$))K$>?@AAE$))K$>?@AA1~~~!a/6//NN1fj1NN1ei0Qz!!<%-/ c$**o %AE!c$**o-./A DJJ 'AE!c$**o-./AAA ZA  Y1 Qzr0c @^^^^^ ^ ^ ^ ^ ^^[U5umm T T-m[STR55m [R"S/SSS9m[R"S/SSS9n[R "S/SS9m [R "S/SS9m [R "S/SS9T S--m [R "S/SS9TS--mU U4SjnUU U UU4S jn[RRRXETUT T T T/5umnm m m mUU4S jm[RRR[R"[R"ST :T T :*5[R"ST:TT:*55UU U U U4S jUU U4S j5$) Nc3N# UHn[R"U5v M g7fr'rrs r,r6RandomResizedCrop._static_get_param..Ws:z!$((1++zrrrint32rH fill_valuedtype rcl>[R"X:[R"UT:UT:55$r'paddle logical_and logical_or)countertenrrrrrrs r,cond1RandomResizedCrop._static_get_param..condfs7%% !!IJ r0c >^^^^[R"S/T RST RSS9T-n[R"[R"S/T ST SS95n[R"[R "Xg-55R S5m[R"[R "Xg- 55R S5m[RRR[R"[R"ST:TT :*5[R"ST:TT :*55UU 4SjU4Sj5m[RRR[R"[R"ST:TT :*5[R"ST:TT :*55UU 4SjU4Sj5mUS- nXTTTT4$) NrrrHrrWrcV>[R"S/STT- S9RS5$Nrrrrrrastype)rrsr,CRandomResizedCrop._static_get_param..body..s&aSaVaZHOOr0c>T$r'r()rsr,rr r0cV>[R"S/STT- S9RS5$rr)rrsr,rr s&aSaUQYGNNr0c>T$r'r()rsr,rr r r0) rrrrrrrstaticnnrr) rrrrrrrrrrrr*rs ```` r,body1RandomResizedCrop._static_get_param..bodyosaSdjjmAO "::aSil ! ML V[[)CDELLA V[[)CDELLA   %%""&&q1ua6k:&&q1ua5j9 A   %%""&&q1ua6k:&&q1ua5j9 A qLGAq!+ +r0c>^^^[R"T/5RS5m[R"T/5RS5mTT- m[RRR TTR S:UU4SjUUUU4Sj5up#TRS5U- S-nTRS5U- S-nXEX2T4$)Nfloat32rc>TRS5[R"TTRS- 5RS5/$)Nrr)rrrr)r*rsr,rKRandomResizedCrop._static_get_param..central_crop..s8LL)LLA!67>>wGr0c>[RRRTTRS:UU4SjUU4Sj5$)Nrc>[R"TTRS-5RS5TRS5/$)Nrr)rrrr)rr*sr,r]RandomResizedCrop._static_get_param..central_crop....s8 Vdjjm%;<CCGL g.r0cH>TRS5TRS5/$)Nr)r)rrsr,rrsU\\'2FMM'4JKr0)rrrrr)rrr*rsr,rrs5 ((--tzz!},L r0rr@)rassignrrrrr) rrrrrrrrr*s `` @r, central_crop9RandomResizedCrop._static_get_param..central_crops]]F8,33I>FMM5'*11)TTTTT/$r'r()rrrrrsr,r5RandomResizedCrop._static_get_param..sQ1a)r0c>T"TT5$r'r()rrrsr,rrs L/r0) rPrXrrfullzerosonesrr while_looprr)r*rrrrrrrrrrrrrrrs` @@@@@@@@@@r,_static_get_param#RandomResizedCrop._static_get_paramTss'. v~:tzz:: ++#!7 kk#"G  LL!G , LL!G , KK7 +vz : KK7 +uqy 9 ( ,( ,T$*==#3#3#>#> #q!Q2$  aAq '6}}$$   ""1q5!v+6""1q5!u*5  * ) /   r0c[R"5(aURU5up#pEOURU5up#pEn[R "XX4U5n[R "XpRUR5$r') rin_dynamic_moderr$rDcroprrFr)r*rOrrrrr cropped_imgs r,rRandomResizedCrop._apply_imagesk  ! ! # #005JA!Q"&"8"8"= A!ffSQ1- xx YY0B0BCCr0)rrrrF))g{Gz??)g?gUUUUUU?rN) rFrrrrrrrrrr5r|)r) r:r;r<r=r~rrgrr$rr>rrs@r,rrs/b K  88 "-!3?I+/ +++ + = + ) + ++&Bk ZDDr0rcR^\rSrSr%SrS\S'SS U4SjjjrSrSrU=r $) CenterCropia;Crops the given the input data at the center. Args: size (int|list|tuple): Target size of output image, with (height, width) shape. keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): A cropped image. Returns: A callable object of CenterCrop. Examples: .. code-block:: python >>> import numpy as np >>> from PIL import Image >>> from paddle.vision.transforms import CenterCrop >>> transform = CenterCrop(224) >>> fake_img = Image.fromarray((np.random.rand(300, 320, 3) * 255.).astype(np.uint8)) >>> fake_img = transform(fake_img) >>> print(fake_img.size) (224, 224) rrFc>[TU]U5 [U[R5(a[ U5[ U54UlgXlgr')rrgrTrUrVrrF)r*rFrrws r,rgCenterCrop.__init__s<  dGNN + +TCI.DIIr0cB[R"XR5$r')rD center_croprFrs r,rCenterCrop._apply_images}}S)),,r0rFr')rFrrrr5r|rrs@r,r-r-sA: K?C!; --r0r-c^^\rSrSr%SrS\S'S S U4SjjjrSrSrSr S r U=r $) RandomHorizontalFlipiaHorizontally flip the input data randomly with a given probability. Args: prob (float, optional): Probability of the input data being flipped. Should be in [0, 1]. Default: 0.5 keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): A horizontal flipped image. Returns: A callable object of RandomHorizontalFlip. Examples: .. code-block:: python >>> import paddle >>> fake_img = paddle.to_tensor([[[0, 0, 1], [0, 0, 1], [1, 1, 1]]]) >>> print(fake_img) Tensor(shape=[1, 3, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[[0, 0, 1], [0, 0, 1], [1, 1, 1]]]) >>> transform = paddle.vision.transforms.RandomHorizontalFlip(prob=1) >>> result = transform(fake_img) >>> print(result) Tensor(shape=[1, 3, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[[1, 0, 0], [1, 0, 0], [1, 1, 1]]]) rprobch>[TU]U5 SUs=::a S::dS5e S5eXlgNrr#probability must be between 0 and 1rrgr6r*r6rrws r,rgRandomHorizontalFlip.__init__8 D~A~DDD~DDD~ r0cz[R"5(aURU5$URU5$r'rr'_dynamic_apply_image_static_apply_imagers r,r!RandomHorizontalFlip._apply_image$3  ! ! # #,,S1 1++C0 0r0cx[R"5UR:a[R"U5$U$r')rr6rDhfliprs r,r@)RandomHorizontalFlip._dynamic_apply_image*' ==?TYY &773<  r0c^[RRR[R"SS9UR :U4SjU4Sj5$)NrrHc0>[R"T5$r')rDrErNsr,r:RandomHorizontalFlip._static_apply_image..2 AGGCLr0c>T$r'r(rNsr,rrL3Cr0rrrrrandr6rs `r,rA(RandomHorizontalFlip._static_apply_image/;}}$$ KKd #dii /   r0r6?Nr6rrrr5r| r:r;r<r=r~rrgrr@rAr>rrs@r,r5r5M D KEI'A 1    r0r5c^^\rSrSr%SrS\S'S S U4SjjjrSrSrSr S r U=r $) RandomVerticalFlipi7agVertically flip the input data randomly with a given probability. Args: prob (float, optional): Probability of the input data being flipped. Default: 0.5 keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): A vertical flipped image. Returns: A callable object of RandomVerticalFlip. Examples: .. code-block:: python >>> import paddle >>> fake_img = paddle.to_tensor([[[0, 0, 1], [0, 0, 1], [1, 1, 1]]]) >>> print(fake_img) Tensor(shape=[1, 3, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[[0, 0, 1], [0, 0, 1], [1, 1, 1]]]) >>> transform = paddle.vision.transforms.RandomVerticalFlip(prob=1) >>> result = transform(fake_img) >>> print(result) Tensor(shape=[1, 3, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[[1, 1, 1], [0, 0, 1], [0, 0, 1]]]) rr6ch>[TU]U5 SUs=::a S::dS5e S5eXlgr8r:r;s r,rgRandomVerticalFlip.__init__\r=r0cz[R"5(aURU5$URU5$r'r?rs r,rRandomVerticalFlip._apply_imagecrCr0cx[R"5UR:a[R"U5$U$r')rr6rDvfliprs r,r@'RandomVerticalFlip._dynamic_apply_imageirGr0c^[RRR[R"SS9UR :U4SjU4Sj5$)NrIrJc0>[R"T5$r')rDrarNsr,r8RandomVerticalFlip._static_apply_image..qrMr0c>T$r'r(rNsr,rrerrOr0rPrs `r,rA&RandomVerticalFlip._static_apply_imagenrSr0rTrUrWrXrs@r,r[r[7rYr0r[c^\rSrSr%SrS\S'S\S'S\S'S\S 'S SU4S jjjrS rS rU=r $) NormalizeivaNormalize the input data with mean and standard deviation. Given mean: ``(M1,...,Mn)`` and std: ``(S1,..,Sn)`` for ``n`` channels, this transform will normalize each channel of the input data. ``output[channel] = (input[channel] - mean[channel]) / std[channel]`` Args: mean (int|float|list|tuple, optional): Sequence of means for each channel. std (int|float|list|tuple, optional): Sequence of standard deviations for each channel. data_format (str, optional): Data format of img, should be 'HWC' or 'CHW'. Default: 'CHW'. to_rgb (bool, optional): Whether to convert to rgb. Default: False. keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): A normalized array or tensor. Returns: A callable object of Normalize. Examples: .. code-block:: python :name: code-example >>> import paddle >>> from paddle.vision.transforms import Normalize >>> paddle.seed(2023) >>> normalize = Normalize(mean=[127.5, 127.5, 127.5], ... std=[127.5, 127.5, 127.5], ... data_format='HWC') ... >>> fake_img = paddle.rand([300,320,3]).numpy() * 255. >>> fake_img = normalize(fake_img) >>> print(fake_img.shape) (300, 320, 3) >>> print(fake_img.max(), fake_img.min()) 0.99999464 -0.9999929 rmeanstdrrboolto_rgbc>[TU]U5 [U[R5(aXU/n[U[R5(aX"U/nXlX lX0lX@lgr') rrgrTrUrVrjrkrrm)r*rjrkrrmrrws r,rgNormalize.__init__s\  dGNN + +%D c7>> * *S/C & r0c[R"XRURURUR 5$r')rD normalizerjrkrrmrs r,rNormalize._apply_images.{{ DHHd&6&6   r0)rrjrkrm)r+rFN) rjfloat | Sequence[float]rkrtrrrmrlrrr5r|rrs@r,ririvs(T    L),'*',+/ %%%    )  (  r0ricT^\rSrSr%SrS\S'SS U4SjjjrSrSrU=r $) Transposeia*Transpose input data to a target format. For example, most transforms use HWC mode image, while the Neural Network might use CHW mode input tensor. output image will be an instance of numpy.ndarray. Args: order (list|tuple, optional): Target order of input data. Default: (2, 0, 1). keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(np.ndarray|Paddle.Tensor): A transposed array or tensor. If input is a PIL.Image, output will be converted to np.ndarray automatically. Returns: A callable object of Transpose. Examples: .. code-block:: python >>> import numpy as np >>> from PIL import Image >>> from paddle.vision.transforms import Transpose >>> transform = Transpose() >>> fake_img = Image.fromarray((np.random.rand(300, 320, 3) * 255.).astype(np.uint8)) >>> fake_img = transform(fake_img) >>> print(fake_img.shape) (3, 300, 320) Sequence[int]orderc0>[TU]U5 Xlgr')rrgrx)r*rxrrws r,rgTranspose.__init__s  r0cb[R"U5(aURUR5$[R"U5(a[ R "U5n[UR5S:XaUS[ R4nURUR5$)Nr@.) rDrI transposerxrErasarrayrJrHnewaxisrs r,rTranspose._apply_imagesw  c " "==, , ??3  **S/C syy>Q c2::o&C}}TZZ((r0)rx))r@rrN)rxrwrrr5r|rrs@r,rvrvsIB  )+/)   ) )r0rvcR^\rSrSr%SrS\S'SS U4SjjjrSrSrU=r $) BrightnessTransformiaJAdjust brightness of the image. Args: value (float): How much to adjust the brightness. Can be any non negative number. 0 gives the original image. keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): An image with a transform in brightness. Returns: A callable object of BrightnessTransform. Examples: .. code-block:: python >>> import numpy as np >>> from PIL import Image >>> from paddle.vision.transforms import BrightnessTransform >>> np.random.seed(2023) >>> transform = BrightnessTransform(0.4) >>> fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8)) >>> print(fake_img.load()[1,1]) # type: ignore[index] (60, 169, 34) >>> # doctest: +SKIP('random sample in Brightness function') >>> fake_img = transform(fake_img) >>> print(fake_img.load()[1,1]) (68, 192, 38) rrZcF>[TU]U5 [US5Ulg)N brightnessrrgr_rZr*rZrrws r,rgBrightnessTransform.__init__  !%6 r0cURcU$[R"URSURS5n[R"X5$Nrr)rZrrrDadjust_brightness)r*rObrightness_factors r,r BrightnessTransform._apply_image#C :: J"NN4::a=$**Q-H""3::r0rZr'rZrrrr5r|rrs@r,rrsC D L@D77"<7 77 ;;r0rcR^\rSrSr%SrS\S'SS U4SjjjrSrSrU=r $) ContrastTransformi+azAdjust contrast of the image. Args: value (float): How much to adjust the contrast. Can be any non negative number. 0 gives the original image. keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): An image with a transform in contrast. Returns: A callable object of ContrastTransform. Examples: .. code-block:: python >>> import numpy as np >>> from PIL import Image >>> from paddle.vision.transforms import ContrastTransform >>> transform = ContrastTransform(0.4) >>> fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8)) >>> fake_img = transform(fake_img) >>> print(fake_img.size) (224, 224) rrZch>[TU]U5 US:a [S5e[US5Ulg)Nrz%contrast value should be non-negativecontrast)rrgrKr_rZrs r,rgContrastTransform.__init__Ls3  19DE E!%4 r0cURcU$[R"URSURS5n[R"X5$r)rZrrrDadjust_contrast)r*rOcontrast_factors r,rContrastTransform._apply_imageTsB :: J ..A 1 F  66r0rr'rrrs@r,rr+sB< L@D55"<5 5577r0rcR^\rSrSr%SrS\S'SS U4SjjjrSrSrU=r $) SaturationTransformi\aAdjust saturation of the image. Args: value (float): How much to adjust the saturation. Can be any non negative number. 0 gives the original image. keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): An image with a transform in saturation. Returns: A callable object of SaturationTransform. Examples: .. code-block:: python >>> import numpy as np >>> from PIL import Image >>> from paddle.vision.transforms import SaturationTransform >>> transform = SaturationTransform(0.4) >>> fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8)) >>> fake_img = transform(fake_img) >>> print(fake_img.size) (224, 224) rrZcF>[TU]U5 [US5Ulg)N saturationrrs r,rgSaturationTransform.__init__|rr0cURcU$[R"URSURS5n[R"X5$r)rZrrrDadjust_saturation)r*rOsaturation_factors r,r SaturationTransform._apply_imagerr0rr'rrrs@r,rr\sB: L@D77"<7 77 ;;r0rcR^\rSrSr%SrS\S'SS U4SjjjrSrSrU=r $) HueTransformiaaAdjust hue of the image. Args: value (float): How much to adjust the hue. Can be any number between 0 and 0.5, 0 gives the original image. keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): An image with a transform in hue. Returns: A callable object of HueTransform. Examples: .. code-block:: python >>> import numpy as np >>> from PIL import Image >>> from paddle.vision.transforms import HueTransform >>> transform = HueTransform(0.4) >>> fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8)) >>> fake_img = transform(fake_img) >>> print(fake_img.size) (224, 224) rrZcH>[TU]U5 [USSSSS9Ulg)Nhuer)grVF)r\r]r^rrs r,rgHueTransform.__init__s) ! 5+%  r0cURcU$[R"URSURS5n[R"X5$r)rZrrrD adjust_hue)r*rO hue_factors r,rHueTransform._apply_images@ :: J^^DJJqM4::a=A ||C,,r0rr'rrrs@r,rrsB< L@D  "<   --r0rc^\rSrSr%SrS\S'S\S'S\S'S\S'S S U4SjjjrS rS rS r U=r $) ColorJitteriaRandomly change the brightness, contrast, saturation and hue of an image. Args: brightness (float, optional): How much to jitter brightness. Chosen uniformly from [max(0, 1 - brightness), 1 + brightness]. Should be non negative numbers. Default: 0. contrast (float, optional): How much to jitter contrast. Chosen uniformly from [max(0, 1 - contrast), 1 + contrast]. Should be non negative numbers. Default: 0. saturation (float, optional): How much to jitter saturation. Chosen uniformly from [max(0, 1 - saturation), 1 + saturation]. Should be non negative numbers. Default: 0. hue (float, optional): How much to jitter hue. Chosen uniformly from [-hue, hue]. Should have 0<= hue <= 0.5. Default: 0. keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): A color jittered image. Returns: A callable object of ColorJitter. Examples: .. code-block:: python >>> import numpy as np >>> from PIL import Image >>> from paddle.vision.transforms import ColorJitter >>> transform = ColorJitter(0.4, 0.4, 0.4, 0.4) >>> fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8)) >>> fake_img = transform(fake_img) >>> print(fake_img.size) (224, 224) rrrrrcT>[TU]U5 XlX lX0lX@lgr')rrgrrrr)r*rrrrrrws r,rgColorJitter.__init__s& $ $r0c/nUb$UR[XR55 Ub$UR[X R55 Ub$UR[ X0R55 Ub$UR[ X@R55 [ R"U5 [U5nU$)zGet a randomized transform to be applied on image. Arguments are same as that of __init__. Returns: Transform which randomly adjusts brightness, contrast and saturation in a random order. ) rrrrrrrshufflera)r*rrrrrd transforms r, _get_paramColorJitter._get_params  !   1*iiH I     /))D E  !   1*iiH I ?   l3 : ;z"J' r0cURURURURUR5nU"U5$)zX Args: img (PIL Image): Input image. Returns: PIL Image: Color jittered image. )rrrrr)r*rOrs r,rColorJitter._apply_images7OO OOT]]DOOTXX ~r0)rrrr)rrrrN) rrrrrrrrrrr5r| r:r;r<r=r~rrgrrr>rrs@r,rrs"HO J+/       )    8  r0rc^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'SSU4S jjjrSrSrSr U=r $) RandomCropia Crops the given CV Image at a random location. Args: size (sequence|int): Desired output size of the crop. If size is an int instead of sequence like (h, w), a square crop (size, size) is made. padding (int|sequence, optional): Optional padding on each border of the image. If a sequence of length 4 is provided, it is used to pad left, top, right, bottom borders respectively. Default: None, without padding. pad_if_needed (boolean, optional): It will pad the image if smaller than the desired size to avoid raising an exception. Default: False. fill (float|tuple, optional): Pixel fill value for constant fill. If a tuple of length 3, it is used to fill R, G, B channels respectively. This value is only used when the padding_mode is constant. Default: 0. padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default: 'constant'. - constant: pads with a constant value, this value is specified with fill - edge: pads with the last value on the edge of the image - reflect: pads with reflection of image (without repeating the last value on the edge) padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode will result in [3, 2, 1, 2, 3, 4, 3, 2] - symmetric: pads with reflection of image (repeating the last value on the edge) padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode will result in [2, 1, 1, 2, 3, 4, 4, 3] keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): A random cropped image. Returns: A callable object of RandomCrop. Examples: .. code-block:: pycon :name: code-example1 >>> import paddle >>> from paddle.vision.transforms import RandomCrop >>> transform = RandomCrop(224) >>> fake_img = paddle.randint(0, 255, shape=(3, 324, 300), dtype='int32') >>> print(fake_img.shape) paddle.Size([3, 324, 300]) >>> crop_img = transform(fake_img) >>> print(crop_img.shape) paddle.Size([3, 224, 224]) rrFSize2 | Size4 | Nonepaddingrl pad_if_neededrfillr padding_modec>[TU]U5 [U[R5(a[ U5[ U54UlOXlX lX0lX@l XPl gr') rrgrTrUrVrrFrrrr)r*rFrrrrrrws r,rgRandomCrop.__init__\sR  dGNN + +TCI.DII * (r0c@[U5up4UupVX6:Xa XE:XaSSXC4$[R"5(a3[R"SXE- 5n[R"SX6- 5nO.[R"SXE- S9n[R"SX6- S9nXxXV4$)zGet parameters for ``crop`` for a random crop. Args: img (PIL Image): Image to be cropped. output_size (tuple): Expected output size of the crop. Returns: tuple: params (i, j, h, w) to be passed to ``crop`` for random crop. r)lowhigh)rPrr'rr) r*rO output_sizerrthtwrrs r,rRandomCrop._get_paramoss# 7qwa:   ! ! # #q!&)Aq!&)A1162A1162AR|r0cURb6[R"XRURUR5n[ U5up#UR (aPX RS:a>[R"XRSU- S4URUR5nUR (aQX0RS:a?[R"USURSU- 4URUR5nURXR5upEp2[R"XXSU5$)zY Args: img (PIL Image): Image to be cropped. Returns: PIL Image: Cropped image. rr) rrDpadrrrPrrFrr()r*rOrrrrs r,rRandomCrop._apply_images << #%%\\499d6G6GHCs#   !iil"2%%iilQ&*DIIt7H7HC   !iil"2%%a1)*DIIt7H7HC__S))4 avvcaA&&r0)rrrrrF)NFrconstantN)rFrrrrrlrrrrrrr5r|rrs@r,rrs6p K !! K )-#%/+/))&) )  ) # ))) ))&.''r0rcr^\rSrSr%SrS\S'S\S'S\S'S S U4S jjjrS rS rU=r $)PadiaPads the given CV Image on all sides with the given "pad" value. Args: padding (int|list|tuple): Padding on each border. If a single int is provided this is used to pad all borders. If list/tuple of length 2 is provided this is the padding on left/right and top/bottom respectively. If a list/tuple of length 4 is provided this is the padding for the left, top, right and bottom borders respectively. fill (int|list|tuple): Pixel fill value for constant fill. Default is 0. If a list/tuple of length 3, it is used to fill R, G, B channels respectively. This value is only used when the padding_mode is constant padding_mode (str): Type of padding. Should be: constant, edge, reflect or symmetric. Default is constant. ``constant`` means pads with a constant value, this value is specified with fill. ``edge`` means pads with the last value at the edge of the image. ``reflect`` means pads with reflection of image (without repeating the last value on the edge) padding ``[1, 2, 3, 4]`` with 2 elements on both sides in reflect mode will result in ``[3, 2, 1, 2, 3, 4, 3, 2]``. ``symmetric`` means pads with reflection of image (repeating the last value on the edge) padding ``[1, 2, 3, 4]`` with 2 elements on both sides in symmetric mode will result in ``[2, 1, 1, 2, 3, 4, 4, 3]``. keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): A padded image. Returns: A callable object of Pad. Examples: .. code-block:: python >>> import numpy as np >>> from PIL import Image >>> from paddle.vision.transforms import Pad >>> transform = Pad(2) >>> fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8)) >>> fake_img = transform(fake_img) >>> print(fake_img.size) (228, 228) Size2 | Size4rrrrrc>[U[R[[45(de[U[R[ [[45(deUS;de[U[5(a [ U5n[U[5(a [ U5n[U[ 5(a)[U5S;a[S[U5S3-5e[TU])U5 Xl X l X0l g)N)redgereflect symmetricr@rCz9Padding must be an int or a 2, or 4 element tuple, not a z element tuple)rTrUrVrYrXr}rrJrKrrgrrr)r*rrrrrws r,rg Pad.__init__s'GNND%#@AAAA$dE BCCCCKKKK gt $ $GnG dD ! !;D gx ( (S\-GK\N.12    (r0cn[R"XRURUR5$)zW Args: img (PIL Image): Image to be padded. Returns: PIL Image: Padded image. )rDrrrrrs r,rPad._apply_images%uuS,, 43D3DEEr0)rrr)rrN) rrrrrrrrr5r|rrs@r,rrsm*X K %/+/ )))# ) ) )  ))6FFr0rc[U5S:aUSO*SRUVs/sHn[U5PM sn5n[U[5(d[ USUS35e[U5U;a[ USUS35egs snf)Nr@rz or z should be a sequence of length .z should be sequence of length )rJjoinr}rTrrLrK)rr[ req_sizessmsgs r,_check_sequence_inputrs y>A  ! [[)4)Q#a&)4 5 a " "4& @QGHH 1vYD6!?uAFGG 5sBc[U[R5(aUS:a[SUS35eU*U/nO [ XU5 UVs/sHn[ U5PM sn$s snf)NrrSz) is a single number, it must be positive.)rTrUrVrKrr)rr[rds r, _setup_anglersg!W^^$$ q5dVDE RGay1 aE!Ha  s A#c^\rSrSr%SrS\S'S\S'S\S'S\S 'S \S 'S \S 'S\S'SSU4SjjjrSSjrSrSr U=r $) RandomAffineia Random affine transformation of the image. Args: degrees (int|float|tuple): The angle interval of the random rotation. If set as a number instead of sequence like (min, max), the range of degrees will be (-degrees, +degrees) in clockwise order. If set 0, will not rotate. translate (tuple, optional): Maximum absolute fraction for horizontal and vertical translations. For example translate=(a, b), then horizontal shift is randomly sampled in the range -img_width * a < dx < img_width * a and vertical shift is randomly sampled in the range -img_height * b < dy < img_height * b. Default is None, will not translate. scale (tuple, optional): Scaling factor interval, e.g (a, b), then scale is randomly sampled from the range a <= scale <= b. Default is None, will keep original scale and not scale. shear (sequence or number, optional): Range of degrees to shear, ranges from -180 to 180 in clockwise order. If set as a number, a shear parallel to the x axis in the range (-shear, +shear) will be applied. Else if set as a sequence of 2 values a shear parallel to the x axis in the range (shear[0], shear[1]) will be applied. Else if set as a sequence of 4 values, a x-axis shear in (shear[0], shear[1]) and y-axis shear in (shear[2], shear[3]) will be applied. Default is None, will not apply shear. interpolation (str, optional): Interpolation method. If omitted, or if the image has only one channel, it is set to PIL.Image.NEAREST or cv2.INTER_NEAREST according the backend. When use pil backend, support method are as following: - "nearest": Image.NEAREST, - "bilinear": Image.BILINEAR, - "bicubic": Image.BICUBIC When use cv2 backend, support method are as following: - "nearest": cv2.INTER_NEAREST, - "bilinear": cv2.INTER_LINEAR, - "bicubic": cv2.INTER_CUBIC fill (int|list|tuple, optional): Pixel fill value for the area outside the transformed image. If given a number, the value is used for all bands respectively. center (tuple|None, optional): Optional center of rotation, (x, y). Origin is the upper left corner. Default is the center of the image. keys (list[str]|tuple[str]|None, optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): An affined image. Returns: A callable object of RandomAffine. Examples: .. code-block:: pycon >>> import paddle >>> from paddle.vision.transforms import RandomAffine >>> transform = RandomAffine( ... [-90, 90], ... translate=[0.2, 0.2], ... scale=[0.5, 0.5], ... shear=[-10, 10], ... ) >>> fake_img = paddle.randn((3, 256, 300)).astype(paddle.float32) >>> fake_img = transform(fake_img) >>> print(fake_img.shape) paddle.Size([3, 256, 300]) )float | list[float] | tuple[float, float]degrees(list[float] | tuple[float, float] | None translaterTfloat | list[float] | tuple[float, float] | tuple[float, float, float, float] | Noneshearrrrrr\c >[USSS9Ul[T U] U5 US;deXPlUb.[ USSS9 UHn SU s=::aS::aMO [ S 5e X lUb%[ US SS9 UHn U S ::dM [ S 5e X0lUb[US SS9Ul OX@l UcS nO0[U[[R45(d [S5eX`lUb [ USSS9 Xplg)Nrr@)r[rnearestrbicubicr)rrsr+z,translation values should be between 0 and 1rrzscale values should be positiverrz-Fill should be either a sequence or a number.r\)rrrrgrrrKrrrrTrrUrVrLrr\) r*rrrrrrr\rryrrws r,rgRandomAffine.__init___s"$G)tL   BBBB*  !)[D IqC$F #   !%D A6$%FGG  %e'VLDJJ <DD8W^^"<==KL L   !&(d C r0c[R"USUS5nUbn[USUS-5n[USUS-5n[[R"U*U55n [[R"U*U55n X4n OSn Ub[R"USUS5n OSn SupUbI[R"USUS5n [ U5S:Xa[R"USUS5nX4nXkX4$) zhGet parameters for affine transformation Returns: params to be passed to the affine transformation rr)rrr+)rsrsrCr@rB)rrrrrJ)r*img_sizerr scale_rangesshearsanglemax_dxmax_dytxty translationsrshear_xshear_yrs r,rRandomAffine._get_params wqz71:6  9Q<(1+56F9Q<(1+56FV^^VGV45BV^^VGV45B8L!L  #NN<?LODEE#  nnVAYq :G6{a ..F1I>"E00r0c[U5up#X#/nURX@RURURUR 5n[ R"U/UQ7URURURS.6$)z Args: img (PIL.Image|np.array): Image to be affine transformed. Returns: PIL.Image or np.array: Affine transformed image. )rrr\) rPrrrrrrDaffinerrr\)r*rOrrrrets r,rRandomAffine._apply_imageszs#6oo llDNNDJJ  xx   ,,;;   r0)r\rrrrrr)NNNrrNN)rrrrrrrrrrrrr\rrrr5r|)NNNrrs@r,rrs;z7677 33 98 K 44 ?C:> ?H;?+/4:4<48 4   4=4494)4 !44nLP1B  r0rc^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'SSU4S jjjrSrSrSr U=r $)RandomRotationiaRotates the image by angle. Args: degrees (sequence or float or int): Range of degrees to select from. If degrees is a number instead of sequence like (min, max), the range of degrees will be (-degrees, +degrees) clockwise order. interpolation (str, optional): Interpolation method. If omitted, or if the image has only one channel, it is set to PIL.Image.NEAREST or cv2.INTER_NEAREST according the backend. when use pil backend, support method are as following: - "nearest": Image.NEAREST, - "bilinear": Image.BILINEAR, - "bicubic": Image.BICUBIC when use cv2 backend, support method are as following: - "nearest": cv2.INTER_NEAREST, - "bilinear": cv2.INTER_LINEAR, - "bicubic": cv2.INTER_CUBIC expand (bool|optional): Optional expansion flag. Default: False. If true, expands the output to make it large enough to hold the entire rotated image. If false or omitted, make the output image the same size as the input image. Note that the expand flag assumes rotation around the center and no translation. center (2-tuple|optional): Optional center of rotation. Origin is the upper left corner. Default is the center of the image. keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): A rotated image. Returns: A callable object of RandomRotation. Examples: .. code-block:: python >>> import numpy as np >>> from PIL import Image >>> from paddle.vision.transforms import RandomRotation >>> transform = RandomRotation(90) >>> fake_img = Image.fromarray((np.random.rand(200, 150, 3) * 255.).astype(np.uint8)) >>> fake_img = transform(fake_img) >>> print(fake_img.size) (150, 200) rrrrrlexpandztuple[float, float]r\rrc >[U[R5(aUS:a [S5eU*U4UlO [ U5S:wa [S5eXl[ TU]U5 X lX0l X@l XPl g)Nrz3If degrees is a single number, it must be positive.r@z.If degrees is a sequence, it must be of len 2.) rTrUrVrKrrJrrgrrr\r)r*rrrr\rrrws r,rgRandomRotation.__init__s gw~~ . .{ I%Hg.DL7|q  D#L *   r0c[R"5(a[R"USUS5nU$[R"S/SUSUSS9nU$)Nrrr)rrrW)rr'rr)r*rrs r,rRandomRotation._get_param!sZ  ! ! # #NN71:wqz:E  NN9'!*'!*E r0cURUR5n[R"XURUR UR UR5$)zn Args: img (PIL.Image|np.array): Image to be rotated. Returns: PIL.Image or np.array: Rotated image. )rrrDrotaterrr\r)r*rOrs r,rRandomRotation._apply_image+sD -xx **DKKdii  r0)r\rrrr)rFNrN)rrtrrrrlr\ztuple[float, float] | Nonerrrrr5r|rrs@r,rrs-^88 L  K @I-1+/(=  +   ) 8   r0rc^\rSrSr%SrS\S'S\S'S\S'S\S 'SSU4S jjjrSS jrS rS r U=r $)RandomPerspectivei;aRandom perspective transformation with a given probability. Args: prob (float, optional): Probability of using transformation, ranges from 0 to 1, default is 0.5. distortion_scale (float, optional): Degree of distortion, ranges from 0 to 1, default is 0.5. interpolation (str, optional): Interpolation method. If omitted, or if the image has only one channel, it is set to PIL.Image.NEAREST or cv2.INTER_NEAREST. When use pil backend, support method are as following: - "nearest": Image.NEAREST, - "bilinear": Image.BILINEAR, - "bicubic": Image.BICUBIC When use cv2 backend, support method are as following: - "nearest": cv2.INTER_NEAREST, - "bilinear": cv2.INTER_LINEAR, - "bicubic": cv2.INTER_CUBIC fill (int|list|tuple, optional): Pixel fill value for the area outside the transformed image. If given a number, the value is used for all bands respectively. keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): A perspectived image. Returns: A callable object of RandomPerspective. Examples: .. code-block:: pycon >>> import paddle >>> from paddle.vision.transforms import RandomPerspective >>> transform = RandomPerspective(prob=1.0, distortion_scale=0.9) >>> fake_img = paddle.randn((3, 200, 150)).astype(paddle.float32) >>> fake_img = transform(fake_img) >>> print(fake_img.shape) paddle.Size([3, 200, 150]) rr6distortion_scalerrrrc6>[TU]U5 SUs=::a S::dS5e S5eSUs=::a S::dS5e S5eUS;de[U[R[ [ [45(deXlX l X0l X@l g)Nrrr9z(distortion_scale must be between 0 and 1r) rrgrTrUrVr}rYrXr6r rr)r*r6r rrrrws r,rgRandomPerspective.__init__ls D~A~DDD~DDD~$)) 6 ) 6 ) BBBB$dE BCCCC 0* r0c PUS-nUS-n[[R"S[X5-5S-55[[R"S[X4-5S-55/n[[R"U[X5-5- S- U55[[R"S[X4-5S-55/n[[R"U[X5-5- S- U55[[R"U[X4-5- S- U55/n[[R"S[X5-5S-55[[R"U[X4-5- S- U55/n SS/US- S/US- US- /SUS- //n XgX/n X4$)z Returns: startpoints (list[list[int]]): [top-left, top-right, bottom-right, bottom-left] of the original image, endpoints (list[list[int]]): [top-left, top-right, bottom-right, bottom-left] of the transformed image. r@rr)rrr) r*rrr  half_height half_widthtoplefttoprightbotrightbotleft startpoints endpointss r, get_paramsRandomPerspective.get_paramssk aZ q#&6&C"Dq"HI J q#&6&D"E"IJ K  C 0 =>>BE  q#&6&D"E"IJ K   C 0 =>>BE  S!1!?@@1Df    q#&6&C"Dq"HI J S!1!?@@1Df  F QYN QY #  O  : %%r0c[U5up#[R"5UR:aJURX#UR5upE[ R "XXPRUR5$U$)z Args: img (PIL.Image|np.array|paddle.Tensor): Image to be Perspectively transformed. Returns: PIL.Image|np.array|paddle.Tensor: Perspectively transformed image. ) rPrr6rr rD perspectiverr)r*rOrrrrs r,rRandomPerspective._apply_imagesi(,  ==?TYY &%)__t44& "K==)-?-?  r0)r rrr6)rVrVrrN) r6rr rrrrrrrr5r|)rrrrr rr5z'tuple[list[list[int]], list[list[int]]]) r:r;r<r=r~rrgrrr>rrs@r,r r ;s)V K88 K"%?H+/  =    )  *2&2&"%2&9>2& 02&hr0r cT^\rSrSr%SrS\S'SS U4SjjjrSrSrU=r $) GrayscaleiaConverts image to grayscale. Args: num_output_channels (int, optional): (1 or 3) number of channels desired for output image. Default: 1. keys (list[str]|tuple[str], optional): Same as ``BaseTransform``. Default: None. Shape: - img(PIL.Image|np.ndarray|Paddle.Tensor): The input image with shape (H x W x C). - output(PIL.Image|np.ndarray|Paddle.Tensor): Grayscale version of the input image. - If output_channels == 1 : returned image is single channel - If output_channels == 3 : returned image is 3 channel with r == g == b Returns: A callable object of Grayscale. Examples: .. code-block:: python >>> import numpy as np >>> from PIL import Image >>> from paddle.vision.transforms import Grayscale >>> transform = Grayscale() >>> fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8)) >>> fake_img = transform(fake_img) >>> print(np.array(fake_img).shape) (224, 224) rnum_output_channelsc0>[TU]U5 Xlgr')rrgr)r*rrrws r,rgGrayscale.__init__s #6 r0cB[R"XR5$)zt Args: img (PIL Image): Image to be converted to grayscale. Returns: PIL Image: Randomly grayscaled image. )rD to_grayscalerrs r,rGrayscale._apply_images~~c#;#;<>> import paddle >>> fake_img = paddle.randn((1, 5, 5)).astype(paddle.float32) >>> transform = paddle.vision.transforms.RandomErasing() >>> result = transform(fake_img) >>> # doctest: +SKIP('random sample') >>> print(result) Tensor(shape=[1, 5, 5], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[[-0.22141267, -0.71004093, 1.71224928, 2.99622107, -0.82959402], [ 0.36916021, -0.25601348, 0.86669374, 1.27504587, -0.56462914], [-0.45704395, -0.87613666, 1.12195814, -0.87974882, 0.04902615], [-0.91549885, -0.15066874, 1.26381516, 0. , 0. ], [ 0.87887472, -1.59914243, -0.73970413, 0. , 0. ]]]) rr6rrrz#int | float | Sequence[float] | strrZrlinplacecH>[TU]U5 [U[[45(dS5eUSS:aUSS::a USUS::dS5e[U[[45(dS5eUSS:a USUS::dS5eUS:aUS::dS5e[U[ R [[[45(dS5e[U[5(aUS :wa [S 5eXl X l X0l X@l XPl g) Nzscale should be a tuple or listrrz6scale should be of kind (min, max) and in range [0, 1]zratio should be a tuple or listrz)The probability should be in range [0, 1]z,value should be a number, tuple, list or strrz'value must be 'random' when type is str)rrgrTrXrYrUrVr}rKr6rrrZr&)r*r6rrrZr&rrws r,rgRandomErasing.__init__0s> %%// - /Qx1}qQ58uQx3G D G%%// - /Qx1}qU1X!5 0 5qyTQY 7 &%'..#ud!CDD : D eS ! !ex&7FG G     r0c [R"U5(aL[R"U5R [R 5R nUSUSUSpnO[R"U5(a-UR SUR SUR SpnOG[R"U5(a,UR SUR SUR SpvnWW-n [R"U5n [S5GHn [RR"U6U -n [R"[RR"U 65n [[[R "X-555n[[[R "X- 555nX:dX:aM[R"U5(aZUc0["R$"WX/S9R UR&5nOk["R("XAR&S9SS2SS4nODUc#[RR%XW/S9S -nO[R*"U5SSSS24n[RR-S Xn- S -5n[RR-S X- S -5nUUXU4s $ S S XgU4$) aGet parameters for ``erase`` for a random erasing in dynamic mode. Args: img (paddle.Tensor | np.array | PIL.Image): Image to be erased. scale (sequence, optional): The proportional range of the erased area to the input image. ratio (sequence, optional): Aspect ratio range of the erased area. value (sequence | None): The value each pixel in erased area will be replaced with. If value is a sequence with length 3, the R, G, B channels will be erased respectively. If value is None, each pixel will be erased with random values. Returns: tuple: params (i, j, h, w, v) to be passed to ``erase`` for random erase. rArNrJrr3rr)rDrErr}ruint8rHrGrIrrrrrrrrrnormalrrarrayr)r*rOrrrZrHrrcimg_arearr erase_arearerase_herase_wvtoplefts r,r RandomErasing._dynamic_get_paramUsE ??3  JJsO**2884::EBirE"I!A!   s # #iimSYYr]CIIbM!A!    $ $iimSYYr]CIIbM!Aq5FF5M rA**E2X=J66"))"3"3Y"?@L% (A BCDG% (A BCDG|w|!!#&&= Q,ABII A((ii@D$OA= ((w.C(DsJAdA 6A))##Aq{Q7C99$$Q a8Dg1 1-0!Q3r0cl^^^ ^ ^^^^^^TRSTRSTRSsnmmTT-m[R"[R"U55mUU4SjnUUU4Sjn[R "T/5R S5m[R "T/5R S5mTR5TR5sm m [R"S/SSS 9n[R"S/S SS 9n [RRRXgXT T /5upm m Uc1[R"UT T /S 9R TR5mO US S 2S S 4m[R"S/5R S5m[RRR[R "T T:T T:5U U4S jU4Sj5n [RRR[R "T T:T T:5U U4SjU4Sj5n [RRR[R "T T:T T:5U 4SjU4Sj5m [RRR[R "T T:T T:5U 4SjU4Sj5m [RRR[R "T T:T T:5U4SjU4Sj5mXT T TU4$)aGet parameters for ``erase`` for a random erasing in static mode. Args: img (paddle.static.Variable): Image to be erased. scale (sequence, optional): The proportional range of the erased area to the input image. ratio (sequence, optional): Aspect ratio range of the erased area. value (sequence | None): The value each pixel in erased area will be replaced with. If value is a sequence with length 3, the R, G, B channels will be erased respectively. If value is None, each pixel will be erased with random values. Returns: tuple: params (i, j, h, w, v) to be passed to ``erase`` for random erase. r*r+rAcl>[R"X:[R"UT:UT:55$r'r)rrr3r4rrs r,r-RandomErasing._static_get_param..conds7%% !!qLaK r0c>[R"S/TSTSS9T-n[R"[R"S/TSTSS95n[R"[R"XE-55R S5n[R"[R"XE- 55R S5nUS- nXX#/$)Nrr)rrWr)rrrrrcast) rrr3r4r2rr1rrs r,r-RandomErasing._static_get_param..bodyssaeAh?(J "::s ! )A,GLll6;;z/H#IJOOGll6;;z/H#IJOOG qLG'3 3r0rrrrrNrJc\>[R"S/STT- S-S9RS5$rr)r3rsr,r1RandomErasing._static_get_param..-FNNcqa'kAofWor0c>T$r'r(zerosr,rr@Dr0c\>[R"S/STT- S-S9RS5$rr)r4rsr,rr@rAr0c>T$r'r(rCsr,rr@rEr0c>T$r'r()r3sr,rr@Gr0c>T$r'r()rsr,rr@Ar0c>T$r'r()r4sr,rr@rIr0c>T$r'r()rsr,rr@rKr0c>T$r'r()r5sr,rr@s!r0c>T$r'r(rNsr,rr@sSr0)rHrrr/rrrcloner rrr#r.rr!rr)r*rOrrrZr0rrrrr6r7r3r4rr1rr5rrDs `` @@@@@@@@r,r$RandomErasing._static_get_params))B-2 " 1aq5FF288E?+   4$ MM1#  % %g . MM1#  % %g .779aggi++#!7 kk#"G *0)9)9)D)D w8* &gw = Q$9:AA#))LAatm$A||QC ''0mm##   w{GaK 8    }}$$   w{GaK 8    --""''   w{GaK 8    --""''   w{GaK 8    MM   ! !   w{GaK 8)[ '7Aw66r0c  [R"5UR:a[UR[R 5(aUR/nO.[UR[ 5(aSnO URnUb)[U5S:Xd[U5S:Xd [S5eURXRURU5up4pVn[R"XXEXgUR5$U$)z Args: img (paddle.Tensor | np.array | PIL.Image): Image to be Erased. Returns: output (paddle.Tensor | np.array | PIL.Image): A random erased image. NrrBTValue should be a single number or a sequence with length equals to image's channel.)rr6rTrZrUrVr}rJrKrrrrDeraser&)r*rOrZr6r7r3r4r5s r,r@"RandomErasing._dynamic_apply_images ==?TYY &$**gnn55 DJJ,,  #e*/SZ1_ j.2-D-DZZU. *Cw773TG M M r0c [UR[R5(a;[R "UR/5R UR5nO[[UR[5(aSnO9[R "UR5R UR5nUb1URSS:XdURSS:Xd [S5eURXRURU5up4pVpx[R"XXEXgUR 5$)z Args: img (paddle.static.Variable): Image to be Erased. Returns: output (paddle.static.Variable): A random erased image. NrrrBrS)rTrZrUrVrrrrr}rHrKr$rrrDrTr&) r*rOrZr6r7r3r4r5rs r,rA!RandomErasing._static_apply_image s djj'.. 1 1MM4::,/66syyAE  C ( (EMM$**-44SYY?E   KKNa 5;;q>Q#6f 372H2H TZZ3 /7QwwsDLLIIr0c^^[R"5(aTRT5$[RRR [R "S/5TR:UU4SjU4Sj5$)Nrc&>TRT5$r')rA)rOr*sr,r,RandomErasing._apply_image..& s005r0c>T$r'r(rNsr,rrZ' sr0)rr'r@rrrrQr6rs``r,rRandomErasing._apply_image s]  ! ! # #,,S1 1==##(( QC 499,5 r0)r&r6rrrZ)rV)g{Gz?gQ?)g333333?gffffff @rFN)r6rrrrrrZzfloat | Sequence[float] | strr&rlrrr5r|)r:r;r<r=r~rrgrr$r@rArr>rrs@r,r%r%s)V K   .. M!-!+/0+/### # - #  #)# ##J0db7H4J6r0r%)r)H __future__rrrUrrncollections.abcrrtypingrrrr r r r numpyrtyping_extensionsr rrrD numpy.typingnpt PIL.Imagerrrpaddle._typingrrrrrrrrrrr!r$__all__rPrr_rarrrrr-r5r[rirvrrrrrrrrrrrr rr%r(r0r,rhs#  .' +CC%-23&  x%7t   Xz#5  )77E>2) 8&!U5\!2t0:j%(:zh"Jw~.h"VA2}Wh./A2HD<]7E> *D2i XL gun5L^1= gun-1=hjM'5.1jr0