6biRSrSSKrSSKrSSKrSSKrSSKrSSKrSSKJ r SSK J r SSK J r SSK J r SSKJr SSKrSSKJr SS KJr SS KJr \"S 5"S S \ R,55rSrSr"SS5r\"S5"SS\\55r\"S5"SS\55rSr"SS\\5rSr\"S5"SS55r \"S5S2S j5r!\"S!5S2S"j5r"\"S#5S2S$j5r#\"S%5S2S&j5r$\"S'5S3S(j5r%\"S)5S3S*j5r&\"S+5S4S,j5r'\"S-5S4S.j5r(S/r)\"S05S5S1j5r*g!\a GNLf=f!\a SrGNTf=f)6atUtilies for image preprocessing and augmentation. Deprecated: `tf.keras.preprocessing.image` APIs do not operate on tensors and are not recommended for new code. Prefer loading data with `tf.keras.utils.image_dataset_from_directory`, and then transforming the output `tf.data.Dataset` with preprocessing layers. For more information, see the tutorials for [loading images]( https://www.tensorflow.org/tutorials/load_data/images) and [augmenting images]( https://www.tensorflow.org/tutorials/images/data_augmentation), as well as the [preprocessing layer guide]( https://www.tensorflow.org/guide/tf_keras/preprocessing_layers). N)backend) data_utils) image_utils)io_utils) keras_export)linalg)ndimage) ImageEnhancez"keras.preprocessing.image.Iteratorc^\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrg)Iterator:aBase class for image data iterators. Deprecated: `tf.keras.preprocessing.image.Iterator` is not recommended for new code. Prefer loading images with `tf.keras.utils.image_dataset_from_directory` and transforming the output `tf.data.Dataset` with preprocessing layers. For more information, see the tutorials for [loading images]( https://www.tensorflow.org/tutorials/load_data/images) and [augmenting images]( https://www.tensorflow.org/tutorials/images/data_augmentation), as well as the [preprocessing layer guide]( https://www.tensorflow.org/guide/tf_keras/preprocessing_layers). Every `Iterator` must implement the `_get_batches_of_transformed_samples` method. Args: n: Integer, total number of samples in the dataset to loop over. batch_size: Integer, size of a batch. shuffle: Boolean, whether to shuffle the data between epochs. seed: Random seeding for data shuffling. )pngjpgjpegbmpppmtiftiffcXlX lX@lX0lSUlSUl[ R"5UlSUl UR5Ul gNr) n batch_sizeseedshuffle batch_indextotal_batches_seen threadingLocklock index_array _flow_indexindex_generator)selfrrrrs Z/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/preprocessing/image.py__init__Iterator.__init__UsM$  "#NN$ #//1c[R"UR5UlUR(a/[R R UR5UlggN)nparangerr rrandom permutationr#s r$_set_index_arrayIterator._set_index_array`s>99TVV, <<!yy44TVV'>> ? 1$    #  ! ! #&& OOc !DOOsQw$? 77 DDr'cTURUR-S- UR-$)Nr4)rrr.s r$__len__Iterator.__len__vs#(1,@@r'c$UR5 gr))r/r.s r$ on_epoch_endIterator.on_epoch_endys r'cSUlgr)rr.s r$resetIterator.reset|s r'c#@# UR5 URb6[RRURUR-5 UR S:XaUR 5 URS:XaSnO&UR UR-UR-nURXR-:aU=R S- slOSUlU=RS- slURXUR-v GM 7f)Nr4r) rBrr*r,rrr/rrr )r# current_indexs r$r!Iterator._flow_indexs yy$ tyy4+B+BBC1$%%'vv{ ! !%!1!1DOO!Ctvv M vv 77  A% #$  # #q ( #"" ? !sDDcU$r)r.s r$__iter__Iterator.__iter__s  r'c&UR"U0UD6$r))next)r#argskwargss r$__next__Iterator.__next__syy$)&))r'cUR [UR5nSSS5 URW5$!,(df  N=f)z.For python 2.x. Returns: The next batch. N)rrLr"r8r#r s r$rL Iterator.nexts; YYt334K77 DD Ys < A c[e)Gets a batch of transformed samples. Args: index_array: Array of sample indices to include in batch. Returns: A batch of transformed samples. )NotImplementedErrorrRs r$r8,Iterator._get_batches_of_transformed_sampless "!r') rrr r"rrrrrN)__name__ __module__ __qualname____firstlineno____doc__white_list_formatsr%r/r9r<r?rBr!rIrOrLr8__static_attributes__rHr'r$r r :sJ.M 2= E"A . * E"r'r c#,^# U4SjnU"U5H}upEn[U5HhnUR5RS5(a[R"S5 UR5RU5(dMcXG4v Mj M g7f)azIterates on files with extension. Args: directory: Absolute path to the directory containing files to be counted white_list_formats: Set of strings containing allowed extensions for the files to be counted. follow_links: Boolean, follow symbolic links to subdirectories. Yields: Tuple of (root, filename) with extension in `white_list_formats`. c@>[[R"UTS9SS9$)N) followlinksc US$rrHxs r$<_iter_valid_files.._recursive_list..sadr')key)sortedoswalk)subpath follow_linkss r$_recursive_list*_iter_valid_files.._recursive_lists  GGG 6N  r'z.tiffzYUsing ".tiff" files with multiple bands will cause distortion. Please verify your output.N)rhlowerendswithwarningswarn) directoryr]rlrmroot_filesfnames ` r$_iter_valid_filesrxsy *)4E]E{{}%%g.. H{{}%%&899k!#5s A?BBc[RRU5nU(aF[[ XU55n[ U5n[ USU-5[ USU-5pXhU n O [ XU5n /n /n U HupU RX55 [RRX5n[RRU[RRX55nU RU5 M X4$)aLists paths of files in `subdir` with extensions in `white_list_formats`. Args: directory: absolute path to a directory containing the files to list. The directory name is used as class label and must be a key of `class_indices`. white_list_formats: set of strings containing allowed extensions for the files to be counted. split: tuple of floats (e.g. `(0.2, 0.6)`) to only take into account a certain fraction of files in each directory. E.g.: `segment=(0.6, 1.0)` would only account for last 40 percent of images in each directory. class_indices: dictionary mapping a class name to its index. follow_links: boolean, follow symbolic links to subdirectories. Returns: classes: a list of class indices filenames: the path of valid files in `directory`, relative from `directory`'s parent (e.g., if `directory` is "dataset/class1", the filenames will be `["class1/file1.jpg", "class1/file2.jpg", ...]`). rr4) ripathbasenamelistrxr5intappendjoinrelpath)rsr]split class_indicesrldirname all_files num_filesstartstop valid_filesclasses filenamesrtrw absolute_path relative_paths r$"_list_valid_filenames_in_directoryrs2ggy)G  i\ J  N %(Y./U1X 5I1Jtd+ ' < GI" }-. T1  RWW__]>  ' #  r'cT\rSrSrSrSrSr\S5r\S5r \S5r Sr g ) BatchFromFilesMixiniztAdds methods related to getting batches from filenames. It includes the logic to transform image files to batches. c Xl[U5UlXlUS;a [ SUS5eX0lX@lUR S:Xa:UR S:XaURS-UlOSUR-UlOUR S:Xa:UR S:XaURS-UlONSUR-UlO9UR S:XaURS -UlOS UR-UlXPlX`l Xpl Xl Ub<URRn US :XaS U 4n OUS :XaU S4n O[ SU<S35eS n Xl Xlg )a&Sets attributes to use later for processing files into a batch. Args: image_data_generator: Instance of `ImageDataGenerator` to use for random transformations and normalization. target_size: tuple of integers, dimensions to resize input images to. color_mode: One of `"rgb"`, `"rgba"`, `"grayscale"`. Color mode to read images. data_format: String, one of `channels_first`, `channels_last`. save_to_dir: Optional directory where to save the pictures being yielded, in a viewable format. This is useful for visualizing the random transformations being applied, for debugging purposes. save_prefix: String prefix to use for saving sample images (if `save_to_dir` is set). save_format: Format to use for saving sample images (if `save_to_dir` is set). subset: Subset of data (`"training"` or `"validation"`) if validation_split is set in ImageDataGenerator. interpolation: Interpolation method used to resample the image if the target size is different from that of the loaded image. Supported methods are "nearest", "bilinear", and "bicubic". If PIL version 1.1.3 or newer is installed, "lanczos" is also supported. If PIL version 3.4.0 or newer is installed, "box" and "hamming" are also supported. By default, "nearest" is used. keep_aspect_ratio: Boolean, whether to resize images to a target size without aspect ratio distortion. The image is cropped in the center with target aspect ratio before resizing. >rgbrgba grayscalezInvalid color mode:z); expected "rgb", "rgba", or "grayscale".r channels_last)r))r4N validationrtrainingr4zInvalid subset name: z$;expected "training" or "validation")image_data_generatortuple target_sizekeep_aspect_ratior6 color_mode data_format image_shape save_to_dir save_prefix save_format interpolation_validation_splitrsubset) r#rrrrrrrrrrvalidation_splitrs r$set_processing_attrs(BatchFromFilesMixin.set_processing_attrs szV%9! -!2 9 9%;  %& ??f $?2#'#3#3d#: #'$*:*:#: __ %?2#'#3#3d#: #'$*:*:#: ?2#'#3#3d#: #'$*:*:#: &&&*  #88JJ %,-:%)1- =CF E  r'c [R"[U54UR-URS9nUR n[ U5HupE[R"X5URURURURS9n[R"X`RS9n[US5(aUR!5 UR"(a[UR"R%UR&5nUR"R)Xx5nUR"R+U5nXrU'M UR,(a[ U5HupE[R."X$URSS9nSR1UR2U[R4R7S5UR8S 9n UR;[<R>RAUR,U 55 M URBS :XaURE5n GO$URBS ;aN[RF"[U5URS9n [ U5HupKURHU X'M OURBS :Xae[R"[U5[URJ54URS9n [ U5HupKS XURHU 4'M OQURBS:XaURLV s/sHoUPM n n O"URBS:XaURLUn OU$URNcX*4$X*URNU4$s sn f)rUdtype)rrrr)rcloseTscale {prefix}_{index}_{hash}.{format}gcAprefixindexhashr7input>binarysparse categoricalg? multi_outputraw)(r*zerosr5rr filepaths enumeraterload_imgrrrr img_to_arrayrhasattrrrget_random_transformshapeapply_transform standardizer array_to_imgr7rr,randintrsaverirzr class_modecopyemptyrrlabels sample_weight) r#r batch_xrijimgrdparamsrwbatch_y n_observationoutputs r$r87BatchFromFilesMixin._get_batches_of_transformed_samplescs((   $"2"2 2$**  NN k*DA&& ?? ,,"00"&"8"8 C((:J:JKAsG$$ ((22GGP--==aH--99!<AJ#+&   !+.!..J 0 0;AA++**3/++ B d&6&6>?/ ??g %llnG __ 4 4hhs7|4::>G$-k$: !\\-8 %; __ -hhWs4#5#567tzzG%.k$: :=4<< 667%; __ .9=Evk*GEG __ %kk+.GN    %# #T%7%7 %DD DFsM2c\[SR[U5R55e)z&List of absolute paths to image files.z;`filepaths` property method has not been implemented in {}.rVr7typerXr.s r$rBatchFromFilesMixin.filepathss*" &&,fT$Z-@-@&A  r'c\[SR[U5R55e)z"Class labels of every observation.z8`labels` property method has not been implemented in {}.rr.s r$rBatchFromFilesMixin.labelss," F M MT ##   r'c\[SR[U5R55e)Nz?`sample_weight` property method has not been implemented in {}.rr.s r$r!BatchFromFilesMixin.sample_weights(! &&,fT$Z-@-@&A  r') rrrrrrrrrrrrN) rXrYrZr[r\rr8propertyrrrr^rHr'r$rrsR WrCEJ      r'rz+keras.preprocessing.image.DirectoryIteratorc^\rSrSrSr1SkrS U4Sjjr\S5r\S5r \S5r Sr U=r $) DirectoryIteratoria) Iterator capable of reading images from a directory on disk. Deprecated: `tf.keras.preprocessing.image.DirectoryIterator` is not recommended for new code. Prefer loading images with `tf.keras.utils.image_dataset_from_directory` and transforming the output `tf.data.Dataset` with preprocessing layers. For more information, see the tutorials for [loading images]( https://www.tensorflow.org/tutorials/load_data/images) and [augmenting images]( https://www.tensorflow.org/tutorials/images/data_augmentation), as well as the [preprocessing layer guide]( https://www.tensorflow.org/guide/tf_keras/preprocessing_layers). Args: directory: Path to the directory to read images from. Each subdirectory in this directory will be considered to contain images from one class, or alternatively you could specify class subdirectories via the `classes` argument. image_data_generator: Instance of `ImageDataGenerator` to use for random transformations and normalization. target_size: tuple of integers, dimensions to resize input images to. color_mode: One of `"rgb"`, `"rgba"`, `"grayscale"`. Color mode to read images. classes: Optional list of strings, names of subdirectories containing images from each class (e.g. `["dogs", "cats"]`). It will be computed automatically if not set. class_mode: Mode for yielding the targets: - `"binary"`: binary targets (if there are only two classes), - `"categorical"`: categorical targets, - `"sparse"`: integer targets, - `"input"`: targets are images identical to input images (mainly used to work with autoencoders), - `None`: no targets get yielded (only input images are yielded). batch_size: Integer, size of a batch. shuffle: Boolean, whether to shuffle the data between epochs. seed: Random seed for data shuffling. data_format: String, one of `channels_first`, `channels_last`. save_to_dir: Optional directory where to save the pictures being yielded, in a viewable format. This is useful for visualizing the random transformations being applied, for debugging purposes. save_prefix: String prefix to use for saving sample images (if `save_to_dir` is set). save_format: Format to use for saving sample images (if `save_to_dir` is set). subset: Subset of data (`"training"` or `"validation"`) if validation_split is set in ImageDataGenerator. interpolation: Interpolation method used to resample the image if the target size is different from that of the loaded image. Supported methods are "nearest", "bilinear", and "bicubic". If PIL version 1.1.3 or newer is installed, "lanczos" is also supported. If PIL version 3.4.0 or newer is installed, "box" and "hamming" are also supported. By default, "nearest" is used. keep_aspect_ratio: Boolean, whether to resize images to a target size without aspect ratio distortion. The image is cropped in the center with target aspect ratio before resizing. dtype: Dtype to use for generated arrays. >Nrrrrc >^U c[R"5n Uc[R"5n[TU]UUUU U U U UUU5 TUlXPlX`R;a$[SRX`R55eX`l UUl SUl U(d}/n[[R"T55HXn[R R#[R R%TU55(dMGUR'U5 MZ [)U5Ul[-[/U[1[)U5555Ul[4R6R95n/n/UlSnU4SjU5HKnUR'UR=[>UUR@URBUR2U455 MM /nUH<nURE5unnUR'U5 U=R:U- slM> [)UR:5Ul [FRH"UR4SS9UlUH+nXPR UU[)U5-&U[)U5- nM- [JRL"SURSUR*S35 URO5 UR%5 UR:Vs/sH-n[R R%UR U5PM/ snUl([TU]URXxU 5 gs snf) N+Invalid class_mode: {}; expected one of: {}rc3d># UH%n[RRTU5v M' g7fr))rirzr).0subdirrss r$ -DirectoryIterator.__init__..@s#NgF Y77gs-0int32rFound z images belonging to classes.)*rimage_data_formatfloatxsuperrrsrallowed_class_modesr6r7rrsamplesrhrilistdirrzisdirrr~r5 num_classesdictziprangermultiprocessingpool ThreadPoolr apply_asyncrr]rgetr*rr print_msgr _filepathsr%)r#rsrrrrrrrrrrrrrlrrrrrrresultsrdirpath classes_listresrrw __class__s ` r$r%DirectoryIterator.__init__s*  !335K =NN$E $          # 55 5=DD 8 8  %  G I!6777==i!@AANN6*8w<!#guS\/B"CD##..0 NgNG NN  6// **$   O C!$ GY    ( NNi 'N4>>* xxw? #G18LLQW- . W A$ T\\N"7  +   =A^^ =KEBGGLL /^  zDA s64McUR$r)rr.s r$rDirectoryIterator.filepathsc r'cUR$r))rr.s r$rDirectoryIterator.labelsgs ||r'cgr)rHr.s r$rDirectoryIterator.sample_weightksr') rrrrrsrrrr)r rNr TNNNrFNnearestFN) rXrYrZr[r\rr%rrrrr^ __classcell__rs@r$rrs8tM   'bBHr'rz,keras.preprocessing.image.NumpyArrayIteratorcL^\rSrSrSrSU4SjjrSrSrU=r$)NumpyArrayIteratoriqaIterator yielding data from a Numpy array. Deprecated: `tf.keras.preprocessing.image.NumpyArrayIterator` is not recommended for new code. Prefer loading images with `tf.keras.utils.image_dataset_from_directory` and transforming the output `tf.data.Dataset` with preprocessing layers. For more information, see the tutorials for [loading images]( https://www.tensorflow.org/tutorials/load_data/images) and [augmenting images]( https://www.tensorflow.org/tutorials/images/data_augmentation), as well as the [preprocessing layer guide]( https://www.tensorflow.org/guide/tf_keras/preprocessing_layers). Args: x: Numpy array of input data or tuple. If tuple, the second elements is either another numpy array or a list of numpy arrays, each of which gets passed through as an output without any modifications. y: Numpy array of targets data. image_data_generator: Instance of `ImageDataGenerator` to use for random transformations and normalization. batch_size: Integer, size of a batch. shuffle: Boolean, whether to shuffle the data between epochs. sample_weight: Numpy array of sample weights. seed: Random seed for data shuffling. data_format: String, one of `channels_first`, `channels_last`. save_to_dir: Optional directory where to save the pictures being yielded, in a viewable format. This is useful for visualizing the random transformations being applied, for debugging purposes. save_prefix: String prefix to use for saving sample images (if `save_to_dir` is set). save_format: Format to use for saving sample images (if `save_to_dir` is set). subset: Subset of data (`"training"` or `"validation"`) if validation_split is set in ImageDataGenerator. ignore_class_split: Boolean (default: False), ignore difference in number of classes in labels across train and validation split (useful for non-classification tasks) dtype: Dtype to use for the generated arrays. c  >Uc[R"5nUc[R"5nXl[ U[ 5(d[ U[ 5(a[ US[ 5(d[R"US5/nO)USVs/sHn[R"U5PM nnUSnUH@n[U5[U5:wdM[S[U5<S[U5<35e O/nUbg[U5[U5:waO[S[R"U5R<S[R"U5R<35eUbg[U5[U5:waO[S[R"U5R<S[R"U5R<35eU GbU S ;a [S U S 5e[[U5UR-5nUb\U (dU[R"[R"USU5[R"UUS55(d [S 5eU S :Xa7USUnUVs/sHn[R"USU5PM nnUbUSUnO6UUSnUVs/sHn[R"UUS5PM nnUbUUSn[R"XRS9UlXlUR R$S:wa [SUR R5eUS:XaSOSnUR RUS;a[&R("SU-S-[+U5-S-[+U5-S-[+UR R5-S-[+UR RU5-S-5 Ub[R"U5UlOSUlUb[R"U5UlOSUlX0lXlXlXlXl[:TU]yURSXEU5 gs snfs snfs snf)Nr4rzUAll of the arrays in `x` should have the same length. Found a pair with: len(x[0]) = z, len(x[?]) = zS`x` (images tensor) and `y` (labels) should have the same length. Found: x.shape = z , y.shape = zV`x` (images tensor) and `sample_weight` should have the same length. Found: x.shape = z, sample_weight.shape = >rrzInvalid subset name:z&; expected "training" or "validation".zTraining and validation subsets have different number of classes after the split. If your numpy arrays are sorted by the label, you might want to shuffle them.rrrzUInput data in `NumpyArrayIterator` should have rank 4. You passed an array with shaperrr4rrz=NumpyArrayIterator is set to use the data format convention "" (channels on axis z4), i.e. expected either 1, 3, or 4 channels on axis -. However, it was passed an array with shape  ( channels).)rrrr isinstancerr|r*asarrayr5r6rr}r array_equaluniquerdx_miscndimrqrrstryrrrrrrrr%)r#rdr rrrrrrrrrrignore_class_splitrrxx split_idx channels_axisrs r$r%NumpyArrayIterator.__init__s"  !335K =NN$E a  :a#6#6adD))**QqT*+34Q484R"**R.48!Aq6SW$$q63r7,F =SVs1v-::a=&& 1 (;(;=   $Q3}3E)E::a=&& =(A(G(GI   77 *< CF%9%K%KKLI *IIa m,bii)* .F!'%jyM?EFv"**R ^4vF=*9 AijM?EFv"**R ^4vF=)* AAZZ0 66;;!    )O; 66<< &i 7 MMO()m$%I I m$ % B Bdffll#$dffll=12 3     =ZZ]DFDF  $!#M!:D !%D $8!&&&& Z$?G9jG Gs R#R=#R cZ[R"[[U5/[ UR R 5SS-5URS9n[U5Hup4UR UnURRUR 5nURRURUR5U5nURRU5nXRU'M UR(a[U5Hup4[R "X#UR"SS9nSR%UR&U[R(R+S5UR,S9nUR/[0R2R5URU55 M UR6V s/sHoUPM n n U (dUOU/U -4n UR8cU S$XR8U4- n UR:bXR:U4- n U $s sn f) Nr4rTrrg@rr)r*rrr5r|rdrrrrrrastyperrrrrr7rr,rrrrirzrrr r) r#r rrrrdrrrwr" batch_x_miscsrs r$r86NumpyArrayIterator._get_batches_of_transformed_sampless(( 3{#$tDFFLL'9!"'== >djj k*DAq A..CCAGGLF))99$fA))55a8AAJ+   !+.!..J 0 0;AA++**3/++ B d&6&6>?/48;;?;RK; ?!.'WI 4MO 66>!9 66+&((    ) ))+68 8F @sH() rrrrrrrrdrr ) r FNNNNr rNFN) rXrYrZr[r\r%r8r^rrs@r$rrqs>&Z  }@~  r'rcUR5RU5=(a [RR U5$)zCheck if a filename refers to a valid file. Args: filename: String, absolute path to a file white_list_formats: Set, allowed file extensions Returns: A boolean value indicating if the filename is valid or not )rorprirzisfile)filenamer]s r$validate_filenamer-=s6 >>  $ $%7 8 RWW^^>r'c^\rSrSrSr1SkrS U4SjjrSrSr\ S5r Sr \ S 5r \ S 5r\ S 5rS rU=r$)DataFrameIteratoriKa`Iterator capable of reading images from a directory as a dataframe. Args: dataframe: Pandas dataframe containing the filepaths relative to `directory` (or absolute paths if `directory` is None) of the images in a string column. It should include other column/s depending on the `class_mode`: - if `class_mode` is `"categorical"` (default value) it must include the `y_col` column with the class/es of each image. Values in column can be string/list/tuple if a single class or list/tuple if multiple classes. - if `class_mode` is `"binary"` or `"sparse"` it must include the given `y_col` column with class values as strings. - if `class_mode` is `"raw"` or `"multi_output"` it should contain the columns specified in `y_col`. - if `class_mode` is `"input"` or `None` no extra column is needed. directory: string, path to the directory to read images from. If `None`, data in `x_col` column should be absolute paths. image_data_generator: Instance of `ImageDataGenerator` to use for random transformations and normalization. If None, no transformations and normalizations are made. x_col: string, column in `dataframe` that contains the filenames (or absolute paths if `directory` is `None`). y_col: string or list, column/s in `dataframe` that has the target data. weight_col: string, column in `dataframe` that contains the sample weights. Default: `None`. target_size: tuple of integers, dimensions to resize input images to. color_mode: One of `"rgb"`, `"rgba"`, `"grayscale"`. Color mode to read images. classes: Optional list of strings, classes to use (e.g. `["dogs", "cats"]`). If None, all classes in `y_col` will be used. class_mode: one of "binary", "categorical", "input", "multi_output", "raw", "sparse" or None. Default: "categorical". Mode for yielding the targets: - `"binary"`: 1D numpy array of binary labels, - `"categorical"`: 2D numpy array of one-hot encoded labels. Supports multi-label output. - `"input"`: images identical to input images (mainly used to work with autoencoders), - `"multi_output"`: list with the values of the different columns, - `"raw"`: numpy array of values in `y_col` column(s), - `"sparse"`: 1D numpy array of integer labels, - `None`, no targets are returned (the generator will only yield batches of image data, which is useful to use in `model.predict()`). batch_size: Integer, size of a batch. shuffle: Boolean, whether to shuffle the data between epochs. seed: Random seed for data shuffling. data_format: String, one of `channels_first`, `channels_last`. save_to_dir: Optional directory where to save the pictures being yielded, in a viewable format. This is useful for visualizing the random transformations being applied, for debugging purposes. save_prefix: String prefix to use for saving sample images (if `save_to_dir` is set). save_format: Format to use for saving sample images (if `save_to_dir` is set). subset: Subset of data (`"training"` or `"validation"`) if validation_split is set in ImageDataGenerator. interpolation: Interpolation method used to resample the image if the target size is different from that of the loaded image. Supported methods are "nearest", "bilinear", and "bicubic". If PIL version 1.1.3 or newer is installed, "lanczos" is also supported. If PIL version 3.4.0 or newer is installed, "box" and "hamming" are also supported. By default, "nearest" is used. keep_aspect_ratio: Boolean, whether to resize images to a target size without aspect ratio distortion. The image is cropped in the center with target aspect ratio before resizing. dtype: Dtype to use for the generated arrays. validate_filenames: Boolean, whether to validate image filenames in `x_col`. If `True`, invalid images will be ignored. Disabling this option can lead to speed-up in the instantiation of this class. Default: `True`. >Nrrrrrrc >[TU]UUUUUUUUUU5 UR5nU=(d SUlXlUUlUR UXEXi5 U(aURUU5nU S;aLURUXY5unn [U 5n[[U [[U 5555Ul UR(aV[U5n[URSU-5n[URSU-5nUR UU2SS24nU S;aUR#UU5UlUUR'5UlU(aUUR*OSUlU S:Xa=UVs/sH*n[.R0"UUR'55PM, snUlU S:XaUUR*Ul[UR(5UlU(aSOSnU S;a([6R8"S UR4S US 35 O*[6R8"S UR4S US WS 35 UR(Vs/sH-n[:R<R?URU5PM/ snUl [TU]UR4XU 5 gs snfs snf)Nr )rrrNrr4rr validatedz non-validatedr z image filenames.z image filenames belonging to r)"rrrrsrr _check_params_filter_valid_filepaths_filter_classesr5rrrrrr}iloc get_classesrtolistrvalues_sample_weightr*array_targetsrrrrirzrrr%) r# dataframersrx_coly_col weight_colrrrrrrrrrrrrrrrvalidate_filenamesdfrrrrcolvalidated_stringrwrs r$r%DataFrameIterator.__init__s2 $          ^^ "b$  2uZA --b%8B C C..r5BKBg,K!%c'5W3F&G!HD  ::BI 1 12Etzz!}y01DtQ'B C C++B6DLE))+7Abn33t  'CHI5CRXXbgnn&675IDM  uI,,DM4>>* -K?  ? ?   a(8'99JK    a(8'9: +}I7  >B^^ =KEBGGLL /^  zDA'J  s 1J>&4Kc^URUR;a/[SRURUR55eURS:XaM[ U[ 5(d8[ SRUR[U5R55e[XRS55(d[ SUS35eURS;aG[XRS55(d%[ S RURU55eURS :XaU(a>[U5n[U5S :wa#[S R[U555eO@XR5S :wa*[S RXR555eURS:Xa[[[ [4m[XRU4Sj55(d%[ SRURU55eU(a?URS;a/[ R""SRUR55 U(aE[%XR&R[(R*5(d[ SUS35egg)Nrrz6If class_mode="{}", y_col must be a list. Received {}.c"[U[5$r)rrrcs r$re1DataFrameIterator._check_params..s Z3-?r'zAll values in column x_col=z must be strings.>rrc"[U[5$r)rHrcs r$rerI s As1Cr'z=If class_mode="{}", y_col="{}" column values must be strings.rzGIf class_mode="binary" there must be 2 classes. {} class/es were given.zAIf class_mode="binary" there must be 2 classes. Found {} classes.rc>[UT5$r))r)rdtypess r$rerI!s Au1Er'zPIf class_mode="{}", y_col="{}" column values must be type string, list or tuple.>Nrrrz3`classes` will be ignored given the class_mode="{}"zColumn weight_col=z must be numeric.)rrr6r7rr| TypeErrorrrXallapplysetr5nuniquerrrqrr issubclassrr*number)r#rBr>r?r@rrMs @r$r3DataFrameIterator._check_paramssZ ??$":": :=DDOOT%=%=  OO~ -z%7N7NHOOOOT%[%9%9  29??#?@AA-eW4EF  ??2 2ry'CDEE..4fT__e.L ??h &g,w<1$$;;A6#g,;O% ""$) ((.ry/@/@/B(C ??m +$&Ery'EFGGAAGB t+  MMELLOO  j)=)=)B)BBIINN0 [U[[45(a$UVs/sH o"U;dM UPM nnU=(d S$[U[5(a X;aU$S$[ SR [ U5T55es snf)Nz7Expect string, list or tuple but found {} in {} column )rr|rrrNr7r)rrclsr?s r$remove_classes9DataFrameIterator._filter_classes..remove_classesEs{&4-00)/B#'>#B~%FC((!'!2v<<117V e1L Cs BBc>T"UT5$r)rH)rdrr]s r$re3DataFrameIterator._filter_classes..Ts .G2Lr')r)rr| collections OrderedDictfromkeyskeysrPrQrrupdateaddrhdropna)rBr?rvr]s `` @r$r5!DataFrameIterator._filter_classesAs WWY  ;22;;GDIIKLG5 (LMBuIeGYa$//NN1%KKN  WoGyyy('11r'c^XRU4Sj5nUR[TR4S9nU)R 5nU(a%[ R "SRXR55 X$)zKeep only dataframe rows with valid filenames. Args: df: Pandas dataframe containing filenames in a column x_col: string, column in `df` that contains the filenames or filepaths Returns: absolute paths to image files cX>[RRTRU5$r))rirzrrs)rwr#s r$re;DataFrameIterator._filter_valid_filepaths..js"'',,t~~u=r')rMzTFound {} invalid image filename(s) in x_col="{}". These filename(s) will be ignored.)maprPr-r]sumrqrrr7)r#rBr>rmask n_invalids` r$r4)DataFrameIterator._filter_valid_filepaths_sqIMM =  T%<%<$> UKKM  MM55;VI5M xr'cUR$r)rr.s r$rDataFrameIterator.filepathswrr'cRURS;a UR$UR$)N>rr)rr<rr.s r$rDataFrameIterator.labels{s# ??5 5== << r'cUR$r))r:r.s r$rDataFrameIterator.sample_weights"""r') rr:r<rrrrsrrr)NNr,classNr rNrr TNrNr rNrFfloat32T)rXrYrZr[r\rr%r3r7 staticmethodr5r4rrrrr^rrs@r$r/r/KsFP!  #/TBlBPH22:0  ##r'r/c[R"U5RUS5nUSSS2S4nURSU5nU$)Nr.)r*rswapaxes)rdaxiss r$ flip_axisrsB 1 tQ'A $B$) A 1dA Hr'z,keras.preprocessing.image.ImageDataGeneratorc\rSrSrSrSSjrSSjrSSjrSSjrSr SS jr S r SS jr SS jr S rg)ImageDataGeneratoria4Generate batches of tensor image data with real-time data augmentation. Deprecated: `tf.keras.preprocessing.image.ImageDataGenerator` is not recommended for new code. Prefer loading images with `tf.keras.utils.image_dataset_from_directory` and transforming the output `tf.data.Dataset` with preprocessing layers. For more information, see the tutorials for [loading images]( https://www.tensorflow.org/tutorials/load_data/images) and [augmenting images]( https://www.tensorflow.org/tutorials/images/data_augmentation), as well as the [preprocessing layer guide]( https://www.tensorflow.org/guide/tf_keras/preprocessing_layers). The data will be looped over (in batches). Args: featurewise_center: Boolean. Set input mean to 0 over the dataset, feature-wise. samplewise_center: Boolean. Set each sample mean to 0. featurewise_std_normalization: Boolean. Divide inputs by std of the dataset, feature-wise. samplewise_std_normalization: Boolean. Divide each input by its std. zca_epsilon: epsilon for ZCA whitening. Default is 1e-6. zca_whitening: Boolean. Apply ZCA whitening. rotation_range: Int. Degree range for random rotations. width_shift_range: Float, 1-D array-like or int - float: fraction of total width, if < 1, or pixels if >= 1. - 1-D array-like: random elements from the array. - int: integer number of pixels from interval `(-width_shift_range, +width_shift_range)` - With `width_shift_range=2` possible values are integers `[-1, 0, +1]`, same as with `width_shift_range=[-1, 0, +1]`, while with `width_shift_range=1.0` possible values are floats in the interval [-1.0, +1.0). height_shift_range: Float, 1-D array-like or int - float: fraction of total height, if < 1, or pixels if >= 1. - 1-D array-like: random elements from the array. - int: integer number of pixels from interval `(-height_shift_range, +height_shift_range)` - With `height_shift_range=2` possible values are integers `[-1, 0, +1]`, same as with `height_shift_range=[-1, 0, +1]`, while with `height_shift_range=1.0` possible values are floats in the interval [-1.0, +1.0). brightness_range: Tuple or list of two floats. Range for picking a brightness shift value from. shear_range: Float. Shear Intensity (Shear angle in counter-clockwise direction in degrees) zoom_range: Float or [lower, upper]. Range for random zoom. If a float, `[lower, upper] = [1-zoom_range, 1+zoom_range]`. channel_shift_range: Float. Range for random channel shifts. fill_mode: One of {"constant", "nearest", "reflect" or "wrap"}. Default is 'nearest'. Points outside the boundaries of the input are filled according to the given mode: - 'constant': kkkkkkkk|abcd|kkkkkkkk (cval=k) - 'nearest': aaaaaaaa|abcd|dddddddd - 'reflect': abcddcba|abcd|dcbaabcd - 'wrap': abcdabcd|abcd|abcdabcd cval: Float or Int. Value used for points outside the boundaries when `fill_mode = "constant"`. horizontal_flip: Boolean. Randomly flip inputs horizontally. vertical_flip: Boolean. Randomly flip inputs vertically. rescale: rescaling factor. If None or 0, no rescaling is applied, otherwise we multiply the data by the value provided (after applying all other transformations). Defaults to `None`. preprocessing_function: function that will be applied on each input. The function will run after the image is resized and augmented. The function should take one argument: one image (Numpy tensor with rank 3), and should output a Numpy tensor with the same shape. data_format: Image data format, either "channels_first" or "channels_last". "channels_last" mode means that the images should have shape `(samples, height, width, channels)`, "channels_first" mode means that the images should have shape `(samples, channels, height, width)`. When unspecified, uses `image_data_format` value found in your TF-Keras config file at `~/.keras/keras.json` (if exists) else 'channels_last'. Defaults to "channels_last". validation_split: Float. Fraction of images reserved for validation (strictly between 0 and 1). dtype: Dtype to use for the generated arrays. Raises: ValueError: If the value of the argument, `data_format` is other than `"channels_last"` or `"channels_first"`. ValueError: If the value of the argument, `validation_split` > 1 or `validation_split` < 0. Examples: Example of using `.flow(x, y)`: ```python (x_train, y_train), (x_test, y_test) = cifar10.load_data() y_train = utils.to_categorical(y_train, num_classes) y_test = utils.to_categorical(y_test, num_classes) datagen = ImageDataGenerator( featurewise_center=True, featurewise_std_normalization=True, rotation_range=20, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True, validation_split=0.2) # compute quantities required for featurewise normalization # (std, mean, and principal components if ZCA whitening is applied) datagen.fit(x_train) # fits the model on batches with real-time data augmentation: model.fit(datagen.flow(x_train, y_train, batch_size=32, subset='training'), validation_data=datagen.flow(x_train, y_train, batch_size=8, subset='validation'), steps_per_epoch=len(x_train) / 32, epochs=epochs) # here's a more "manual" example for e in range(epochs): print('Epoch', e) batches = 0 for x_batch, y_batch in datagen.flow(x_train, y_train, batch_size=32): model.fit(x_batch, y_batch) batches += 1 if batches >= len(x_train) / 32: # we need to break the loop by hand because # the generator loops indefinitely break ``` Example of using `.flow_from_directory(directory)`: ```python train_datagen = ImageDataGenerator( rescale=1./255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) test_datagen = ImageDataGenerator(rescale=1./255) train_generator = train_datagen.flow_from_directory( 'data/train', target_size=(150, 150), batch_size=32, class_mode='binary') validation_generator = test_datagen.flow_from_directory( 'data/validation', target_size=(150, 150), batch_size=32, class_mode='binary') model.fit( train_generator, steps_per_epoch=2000, epochs=50, validation_data=validation_generator, validation_steps=800) ``` Example of transforming images and masks together. ```python # we create two instances with the same arguments data_gen_args = dict(featurewise_center=True, featurewise_std_normalization=True, rotation_range=90, width_shift_range=0.1, height_shift_range=0.1, zoom_range=0.2) image_datagen = ImageDataGenerator(**data_gen_args) mask_datagen = ImageDataGenerator(**data_gen_args) # Provide the same seed and keyword arguments to the fit and flow methods seed = 1 image_datagen.fit(images, augment=True, seed=seed) mask_datagen.fit(masks, augment=True, seed=seed) image_generator = image_datagen.flow_from_directory( 'data/images', class_mode=None, seed=seed) mask_generator = mask_datagen.flow_from_directory( 'data/masks', class_mode=None, seed=seed) # combine generators into one which yields image and masks train_generator = zip(image_generator, mask_generator) model.fit( train_generator, steps_per_epoch=2000, epochs=50) ``` Nc0Uc[R"5nUc[R"5nXlX lX0lX@lXPlX`lXpl Xl Xl Xl Xl XlXlXlUUlUUlUUlUUlUUlUUlUS;a[/SU-5eUUlUS:XaSUlSUlSUlUS:XaSUlSUlSUlU(aSUs=:aS:dO [/S U-5eUUlSUlSUlSUl[AU [B[D45(aSU - SU -/Ul OE[GU 5S:Xa'[IS U 55(aU SU S/Ul O[/S U <35eU(aHU(dS Ul[JRL"S 5 U(aSUl[JRL"S5 U(a$U(dS Ul[JRL"S5 U(a$U(dS Ul[JRL"S5 U b9[AU [N[P45(a[GU 5S:wa[/SU <35eXl)g)N>rchannels_firstz`data_format` should be `"channels_last"` (channel after row and column) or `"channels_first"` (channel before row and column). Received: %srr4rKrrrzB`validation_split` must be strictly between 0 and 1. Received: %sc3N# UHn[U[[45v M g7fr))rfloatr})rvals r$r.ImageDataGenerator.__init__..s!* 5?cJsUCL ) )Zs#%zK`zoom_range` should be a float or a tuple or list of two floats. Received: TzcThis ImageDataGenerator specifies `zca_whitening`, which overrides setting of `featurewise_center`.FzlThis ImageDataGenerator specifies `zca_whitening` which overrides setting of`featurewise_std_normalization`.zsThis ImageDataGenerator specifies `featurewise_std_normalization`, which overrides setting of `featurewise_center`.zqThis ImageDataGenerator specifies `samplewise_std_normalization`, which overrides setting of `samplewise_center`.C`brightness_range should be tuple or list of two floats. Received: )*rrrfeaturewise_centersamplewise_centerfeaturewise_std_normalizationsamplewise_std_normalization zca_whitening zca_epsilonrotation_rangewidth_shift_rangeheight_shift_range shear_range zoom_rangechannel_shift_range fill_modecvalhorizontal_flip vertical_fliprescalepreprocessing_functionrinterpolation_orderr6r channel_axisrow_axiscol_axisrmeanstdzca_whitening_matrixrrr}r5rOrqrrrr|brightness_range)r#rrrrrrrrrrrrrrrrrrrrrrrs r$r%ImageDataGenerator.__init__Fs4  !335K =NN$E"4!2-J*,H)*&,!2"4&$#6 " .* &<# #6 A A"--  ' * * !D DMDM / ) !D DMDM A(8$<1$< "23 "2 $(! j5#, / / :~q:~>DO _ !c* 5?* ' '  *!}jmr?r@rrrrrrrrrrrrrrAr)rqrrDeprecationWarningr/rr)r#r=rsr>r?r@rrrrrrrrrrrrrArNs r$flow_from_dataframe&ImageDataGenerator.flow_from_dataframesY\   MM8"  V  MM##    MM&"  J  & MMH"  !        "  $ "  " (( "   $ $! "$# $% &(' ( 2) ***+  r'crUR(aURU5nUR(aXR-nUR(aU[R"USS9-nUR (aU[R "USS9S--nUR(a2URbXR-nO[R"S5 UR(a5UR bXR S--nO[R"S5 UR(aURbcURS[R"URSS55nX R-n[R"X1R5nU$[R"S 5 U$) aApplies the normalization configuration in-place to a batch of inputs. `x` is changed in-place since the function is mainly used internally to standardize images and feed them to your network. If a copy of `x` would be created instead it would have a significant performance cost. If you want to apply this method without changing the input in-place you can call the method creating a copy before: standardize(np.copy(x)) Args: x: Batch of inputs to be normalized. Returns: The inputs, normalized. T)keepdimsư>NzThis ImageDataGenerator specifies `featurewise_center`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.zThis ImageDataGenerator specifies `featurewise_std_normalization`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.r|zThis ImageDataGenerator specifies `zca_whitening`, but it hasn't been fit on any training data. Fit it first by calling `.fit(numpy_data)`.)rrrr*rrrrrqrrrrrreshapeprodr)r#rdflat_xwhite_xs r$rImageDataGenerator.standardize'sQ$  & &++A.A <<  A  ! ! T* *A  , , D)D0 0A  " "yy$YY ;  - -xx#XX_$ ;   ((42rwwqwwrs|'<= #<#<<JJw0  ; r'c URS- nURS- nUb[RR U5 UR (a6[RR UR *UR 5nOSnUR(az[RRUR5nU[RRSS/5-n[R"UR5S:aXaU-nOSnUR(az[RRUR5nU[RRSS/5-n[R"UR5S:aXqU-nOSnUR(a6[RR UR*UR5nOSnURSS:XaURSS:XaSupO=[RR URSURSS5up[RR5S:UR-n [RR5S:UR-n Sn UR S:wa5[RR UR *UR 5n SnUR"b:[RR UR"SUR"S5nUUUUU U U U U US. nU$![a9 [RR UR*UR5nGNf=f![a9 [RR UR*UR5nGNbf=f) aGenerates random parameters for a transformation. Args: img_shape: Tuple of integers. Shape of the image that is transformed. seed: Random seed. Returns: A dictionary containing randomly chosen parameters describing the transformation. r4Nrr|r4r4rK?) thetatxtyshearzxzyflip_horizontal flip_verticalchannel_shift_intensity brightness)rrr*r,rruniformrchoicer6maxrrrrrrr)r# img_shaper img_row_axis img_col_axisrrrrrrrrrrtransform_parameterss r$r'ImageDataGenerator.get_random_transformes>}}q( }}q(   IINN4   II%%t':':&:Dbii&&Aw// vvd--.2 --B  ! ! YY%%d&<&<=bii&&Aw// vvd,,-1 --B   II%%t'7'7&79I9IJEE ??1  "tq'9Q'>FBYY&&"DOOA$6FB99++-3t7K7KK))+c1T5G5GG "&  # #q (&(ii&7&7)))4+C+C' #  ,**%%a($*?*?*BJ .*'>$ $#} YY&&,,,d.E.E  YY&&+++T-C-C s&A M)A N?NN?OOcURS- nURS- nURS- n[UUR SS5UR SS5UR SS5UR SS5UR SS5UR SS5UUUUR UR URS 9 nUR S 5b[UUS U5nUR S S 5(a [X5nUR S S 5(a [X5nUR S5b[XSS 5nU$)aApplies a transformation to an image according to given parameters. Args: x: 3D tensor, single image. transform_parameters: Dictionary with string - parameter pairs describing the transformation. Currently, the following parameters from the dictionary are used: - `'theta'`: Float. Rotation angle in degrees. - `'tx'`: Float. Shift in the x direction. - `'ty'`: Float. Shift in the y direction. - `'shear'`: Float. Shear angle in degrees. - `'zx'`: Float. Zoom in the x direction. - `'zy'`: Float. Zoom in the y direction. - `'flip_horizontal'`: Boolean. Horizontal flip. - `'flip_vertical'`: Boolean. Vertical flip. - `'channel_shift_intensity'`: Float. Channel shift intensity. - `'brightness'`: Float. Brightness shift intensity. Returns: A transformed version of the input (same shape). r4rrrrrrr)rrrrrorderrrFrr) rrrapply_affine_transformrrrrapply_channel_shiftrapply_brightness_shift)r#rdrrrimg_channel_axiss r$r"ImageDataGenerator.apply_transformsT0}}q( }}q( ,,q0 " $ $Wa 0 $ $T1 - $ $T1 - $ $Wa 0 $ $T1 - $ $T1 -!!)nn**  # #$= > J#$%>? A # #$5u = =!*A  # #OU ; ;!*A  # #L 1 =& 5uAr'c\URURU5nURX5$)zApplies a random transformation to an image. Args: x: 3D tensor, single image. seed: Random seed. Returns: A randomly transformed version of the input (same shape). )rrr)r#rdrrs r$random_transform#ImageDataGenerator.random_transforms+**177D9##A..r'c[R"XRS9nURS:wa![ S[ UR 5-5eUR URS;a[R"SUR-S-[ UR5-S-[ UR5-S-[ UR 5-S -[ UR UR5-S -5 Ub[RRU5 [R"U5nUR(aXR-nU(a[R"[!X1R S -/[#UR 5S S -5URS9n[%U5HIn[%UR S 5H*nUR'X5XWXaR S --'M, MK UnUR((a[R*"US UR,UR.4S9Ul/SQnUR URXRS - '[R0"UR*U5UlXR*-nUR2(a[R4"US UR,UR.4S9Ul/SQnUR URXRS - '[R0"UR4U5UlXR4S--nUR6(a[9U5n [R0"XS45n [R:R=U R>SS9upn [R@"U 5XRB-- nX-REU R>5Ul#g g )aFits the data generator to some sample data. This computes the internal data stats related to the data-dependent transformations, based on an array of sample data. Only required if `featurewise_center` or `featurewise_std_normalization` or `zca_whitening` are set to True. When `rescale` is set to a value, rescaling is applied to sample data before computing the internal data stats. Args: x: Sample data. Should have rank 4. In case of grayscale data, the channels axis should have value 1, in case of RGB data, it should have value 3, and in case of RGBA data, it should have value 4. augment: Boolean (default: False). Whether to fit on randomly augmented samples. rounds: Int (default: 1). If using data augmentation (`augment=True`), this is how many augmentation passes over the data to use. seed: Int (default: None). Random seed. rrz)*+#A  " "DMM4==(IJDI'O56WWT=N=N5OO--1 2 499o>DI NA  - -vvaq$--&GHDH'O56WWT=N=N5OO--1 2zz$((O@ /T=r'rz)keras.preprocessing.image.random_rotationc h[RRU*U5n[UUUUUUUUS9nU$)aPerforms a random rotation of a Numpy image tensor. Deprecated: `tf.keras.preprocessing.image.random_rotation` does not operate on tensors and is not recommended for new code. Prefer `tf.keras.layers.RandomRotation` which provides equivalent functionality as a preprocessing layer. For more information, see the tutorial for [augmenting images]( https://www.tensorflow.org/tutorials/images/data_augmentation), as well as the [preprocessing layer guide]( https://www.tensorflow.org/guide/tf_keras/preprocessing_layers). Args: x: Input tensor. Must be 3D. rg: Rotation range, in degrees. row_axis: Index of axis for rows in the input tensor. col_axis: Index of axis for columns in the input tensor. channel_axis: Index of axis for channels in the input tensor. fill_mode: Points outside the boundaries of the input are filled according to the given mode (one of `{'constant', 'nearest', 'reflect', 'wrap'}`). cval: Value used for points outside the boundaries of the input if `mode='constant'`. interpolation_order: int, order of spline interpolation. see `ndimage.interpolation.affine_transform` Returns: Rotated Numpy image tensor. )rrrrrrrr*r,rr) rdrgrrrrrrrs r$random_rotationrdsFN II  rc2 &E ! ! A Hr'z&keras.preprocessing.image.random_shiftc URUURUp[RRU*U5U -n [RRU*U5U -n [ UU U UUUUUUS9 nU$)aPerforms a random spatial shift of a Numpy image tensor. Deprecated: `tf.keras.preprocessing.image.random_shift` does not operate on tensors and is not recommended for new code. Prefer `tf.keras.layers.RandomTranslation` which provides equivalent functionality as a preprocessing layer. For more information, see the tutorial for [augmenting images]( https://www.tensorflow.org/tutorials/images/data_augmentation), as well as the [preprocessing layer guide]( https://www.tensorflow.org/guide/tf_keras/preprocessing_layers). Args: x: Input tensor. Must be 3D. wrg: Width shift range, as a float fraction of the width. hrg: Height shift range, as a float fraction of the height. row_axis: Index of axis for rows in the input tensor. col_axis: Index of axis for columns in the input tensor. channel_axis: Index of axis for channels in the input tensor. fill_mode: Points outside the boundaries of the input are filled according to the given mode (one of `{'constant', 'nearest', 'reflect', 'wrap'}`). cval: Value used for points outside the boundaries of the input if `mode='constant'`. interpolation_order: int, order of spline interpolation. see `ndimage.interpolation.affine_transform` Returns: Shifted Numpy image tensor. )rrrrrrrr)rr*r,rr) rdwrghrgrrrrrrhwrrs r$ random_shiftrsR 778 aggh/q   C4 % )B   C4 % )B ! ! A Hr'z&keras.preprocessing.image.random_shearc h[RRU*U5n[UUUUUUUUS9nU$)aPerforms a random spatial shear of a Numpy image tensor. Args: x: Input tensor. Must be 3D. intensity: Transformation intensity in degrees. row_axis: Index of axis for rows in the input tensor. col_axis: Index of axis for columns in the input tensor. channel_axis: Index of axis for channels in the input tensor. fill_mode: Points outside the boundaries of the input are filled according to the given mode (one of `{'constant', 'nearest', 'reflect', 'wrap'}`). cval: Value used for points outside the boundaries of the input if `mode='constant'`. interpolation_order: int, order of spline interpolation. see `ndimage.interpolation.affine_transform` Returns: Sheared Numpy image tensor. )rrrrrrrr) rd intensityrrrrrrrs r$ random_shearrsE< II  yj) 4E ! ! A Hr'z%keras.preprocessing.image.random_zoomc [U5S:wa[SU<35eUSS:XaUSS:XaSupO)[RR USUSS5up[ UUU UUUUUUS9 nU$)aPerforms a random spatial zoom of a Numpy image tensor. Deprecated: `tf.keras.preprocessing.image.random_zoom` does not operate on tensors and is not recommended for new code. Prefer `tf.keras.layers.RandomZoom` which provides equivalent functionality as a preprocessing layer. For more information, see the tutorial for [augmenting images]( https://www.tensorflow.org/tutorials/images/data_augmentation), as well as the [preprocessing layer guide]( https://www.tensorflow.org/guide/tf_keras/preprocessing_layers). Args: x: Input tensor. Must be 3D. zoom_range: Tuple of floats; zoom range for width and height. row_axis: Index of axis for rows in the input tensor. col_axis: Index of axis for columns in the input tensor. channel_axis: Index of axis for channels in the input tensor. fill_mode: Points outside the boundaries of the input are filled according to the given mode (one of `{'constant', 'nearest', 'reflect', 'wrap'}`). cval: Value used for points outside the boundaries of the input if `mode='constant'`. interpolation_order: int, order of spline interpolation. see `ndimage.interpolation.affine_transform` Returns: Zoomed Numpy image tensor. Raises: ValueError: if `zoom_range` isn't a tuple. rKz@`zoom_range` should be a tuple or list of two floats. Received: rr4r)rrrrrrrr)r5r6r*r,rr) rdrrrrrrrrrs r$ random_zoomrsT :!   !}jmq0B"":a=*Q-C ! ! A Hr'z-keras.preprocessing.image.apply_channel_shiftcF[R"XS5n[R"U5[R"U5pCUVs/sHn[R"XQ-X45PM nn[R "USS9n[R"USUS-5nU$s snf)zPerforms a channel shift. Args: x: Input tensor. Must be 3D. intensity: Transformation intensity. channel_axis: Index of axis for channels in the input tensor. Returns: Numpy image tensor. rrr4)r*rollaxisminrclipstack)rdrrmin_xmax_x x_channelchannel_imagess r$rrA s AQ'A66!9bffQi5FGFG %u4a a(A Aq,*+A H s#Bz.keras.preprocessing.image.random_channel_shiftcX[RRU*U5n[XUS9$)zPerforms a random channel shift. Args: x: Input tensor. Must be 3D. intensity_range: Transformation intensity. channel_axis: Index of axis for channels in the input tensor. Returns: Numpy image tensor. )r)r*r,rr)rdintensity_rangerrs r$random_channel_shiftrW s* !!?"2ODI q, GGr'z0keras.preprocessing.image.apply_brightness_shiftc[c [S5e[R"U5[R"U5pCUS:=(d US:n[ R "X=(d US9n[R"U5=pURU5n[ R"U5nU(dU(a US- XC- -U-nU$)aKPerforms a brightness shift. Args: x: Input tensor. Must be 3D. brightness: Float. The new brightness value. scale: Whether to rescale the image such that minimum and maximum values are 0 and 255 respectively. Default: True. Returns: Numpy image tensor. Raises: ImportError: if PIL is not available. z?A!-!8!8!;;A&&z2A  #A [ Gu} % - Hr'z+keras.preprocessing.image.random_brightnessc[U5S:wa[SU<35e[RR USUS5n[ XU5$)a<Performs a random brightness shift. Deprecated: `tf.keras.preprocessing.image.random_brightness` does not operate on tensors and is not recommended for new code. Prefer `tf.keras.layers.RandomBrightness` which provides equivalent functionality as a preprocessing layer. For more information, see the tutorial for [augmenting images]( https://www.tensorflow.org/tutorials/images/data_augmentation), as well as the [preprocessing layer guide]( https://www.tensorflow.org/guide/tf_keras/preprocessing_layers). Args: x: Input tensor. Must be 3D. brightness_range: Tuple of floats; brightness range. scale: Whether to rescale the image such that minimum and maximum values are 0 and 255 respectively. Default: True. Returns: Numpy image tensor. Raises: ValueError if `brightness_range` isn't a tuple. rKrrr4)r5r6r*r,rr)rdrrrs r$random_brightnessr sX2 !. 1  *1-/?/BCA !! ..r'c([U5S- S- n[U5S- S- n[R"SSU/SSU//SQ/5n[R"SSU*/SSU*//SQ/5n[R"[R"XP5U5nU$)NrKrr4rrrr4)rr*r;r)matrixrdr o_xo_y offset_matrix reset_matrixtransform_matrixs r$transform_matrix_offset_centerr s (Q, C (Q, CHHq!SkAq#; BCM88aSD\Aq3$<CDLvvbff];\J r'z0keras.preprocessing.image.apply_affine_transformc ^[c [S5e[R"XxU /5RS:wa [ S5e[ /SQ5n [ XxU /5nX:wa[ SX- 35eURS:wa [ S5eU S;a [ S 5eSnUS :wa[R"U5n[R"[R"U5[R"U5*S /[R"U5[R"U5S //S Q/5nUnUS :wdUS :wa>[R"S S U/S S U//S Q/5nUcUnO[R"UU5nUS :wa}[R"U5n[R"S [R"U5*S /S [R"U5S //S Q/5nUcUnO[R"UU5nUS :wdUS :wa>[R"US S /S US //S Q/5nUcUnO[R"UU5nUbURUURUnn[UUU5n[R"X S 5nX:a USS2S S /4USS2S S /4'US S /US S /'USS 2SS 24nUSS 2S 4nUVs/sH%n[ R"R%UUUU U U S9PM' nn[R&"US S9n[R"US U S -5nU$s snf)aApplies an affine transformation specified by the parameters given. Args: x: 3D numpy array - a 2D image with one or more channels. theta: Rotation angle in degrees. tx: Width shift. ty: Heigh shift. shear: Shear angle in degrees. zx: Zoom in x direction. zy: Zoom in y direction row_axis: Index of axis for rows (aka Y axis) in the input image. Direction: left to right. col_axis: Index of axis for columns (aka X axis) in the input image. Direction: top to bottom. channel_axis: Index of axis for channels in the input image. fill_mode: Points outside the boundaries of the input are filled according to the given mode (one of `{'constant', 'nearest', 'reflect', 'wrap'}`). cval: Value used for points outside the boundaries of the input if `mode='constant'`. order: int, order of interpolation Returns: The transformed version of the input. Raises: ImportError: if SciPy is not available. Nz3Image transformations require SciPy. Install SciPy.rz;'row_axis', 'col_axis', and 'channel_axis' must be distinct)rr4rKzInvalid axis' indices: z-Input arrays must be multi-channel 2D images.)rrKz7Channels are allowed and the first and last dimensions.rrr4rK)rmoderr)scipyr r*rsizer6rQrdeg2radr;cossinrrrrr raffine_transformr)rdrrrrrrrrrrrr valid_indicesactual_indicesrrotation_matrix shift_matrix shear_matrix zoom_matrixrrfinal_affine_matrix final_offsetrrs r$rr sUX }OPP  yy(l3499Q> I   NM(l;r1s"   )*':  23w"z""w"4w"t":/dz z z;<l+Xl=l^<=HH>HV y#+Xy#x  <=R=R=>R=j9:  1 ;1 h67   6 86 r67  ( 8( V56  > 7> B=> ? *>? H@ H@A B <;</=/D@A     L BL CL  Ls#F F FFF&%F&