image_dataset_from_directory
functiontf.keras.preprocessing.image_dataset_from_directory(
directory,
labels="inferred",
label_mode="int",
class_names=None,
color_mode="rgb",
batch_size=32,
image_size=(256, 256),
shuffle=True,
seed=None,
validation_split=None,
subset=None,
interpolation="bilinear",
follow_links=False,
)
Generates a tf.data.Dataset
from image files in a directory.
If your directory structure is:
main_directory/
...class_a/
......a_image_1.jpg
......a_image_2.jpg
...class_b/
......b_image_1.jpg
......b_image_2.jpg
Then calling image_dataset_from_directory(main_directory, labels='inferred')
will return a tf.data.Dataset
that yields batches of images from
the subdirectories class_a
and class_b
, together with labels
0 and 1 (0 corresponding to class_a
and 1 corresponding to class_b
).
Supported image formats: jpeg, png, bmp, gif. Animated gifs are truncated to the first frame.
Arguments
labels
is "inferred", it should contain
subdirectories, each containing images for a class.
Otherwise, the directory structure is ignored.os.walk(directory)
in Python).sparse_categorical_crossentropy
loss).
- 'categorical' means that the labels are
encoded as a categorical vector
(e.g. for categorical_crossentropy
loss).
- 'binary' means that the labels (there can be only 2)
are encoded as float32
scalars with values 0 or 1
(e.g. for binary_crossentropy
).
- None (no labels).(256, 256)
.
Since the pipeline processes batches of images that must all have
the same size, this must be provided.validation_split
is set.bilinear
. Supports bilinear
, nearest
, bicubic
,
area
, lanczos3
, lanczos5
, gaussian
, mitchellcubic
.Returns
A tf.data.Dataset
object.
- If label_mode
is None, it yields float32
tensors of shape
(batch_size, image_size[0], image_size[1], num_channels)
,
encoding images (see below for rules regarding num_channels
).
- Otherwise, it yields a tuple (images, labels)
, where images
has shape (batch_size, image_size[0], image_size[1], num_channels)
,
and labels
follows the format described below.
Rules regarding labels format:
- if label_mode
is int
, the labels are an int32
tensor of shape
(batch_size,)
.
- if label_mode
is binary
, the labels are a float32
tensor of
1s and 0s of shape (batch_size, 1)
.
- if label_mode
is categorial
, the labels are a float32
tensor
of shape (batch_size, num_classes)
, representing a one-hot
encoding of the class index.
Rules regarding number of channels in the yielded images:
- if color_mode
is grayscale
,
there's 1 channel in the image tensors.
- if color_mode
is rgb
,
there are 3 channel in the image tensors.
- if color_mode
is rgba
,
there are 4 channel in the image tensors.
load_img
functiontf.keras.preprocessing.image.load_img(
path, grayscale=False, color_mode="rgb", target_size=None, interpolation="nearest"
)
Loads an image into PIL format.
Usage:
image = tf.keras.preprocessing.image.load_img(image_path)
input_arr = keras.preprocessing.image.img_to_array(image)
input_arr = np.array([input_arr]) # Convert single image to a batch.
predictions = model.predict(input_arr)
Arguments
color_mode="grayscale"
.None
(default to original size)
or tuple of ints (img_height, img_width)
.Returns
A PIL Image instance.
Raises
img_to_array
functiontf.keras.preprocessing.image.img_to_array(img, data_format=None, dtype=None)
Converts a PIL Image instance to a Numpy array.
Usage:
from PIL import Image
img_data = np.random.random(size=(100, 100, 3))
img = tf.keras.preprocessing.image.array_to_img(img_data)
array = tf.keras.preprocessing.image.img_to_array(img)
Arguments
None
, in which case the global setting
tf.keras.backend.image_data_format()
is used (unless you changed it,
it defaults to "channels_last").None
, in which case the global setting
tf.keras.backend.floatx()
is used (unless you changed it, it defaults
to "float32")Returns
A 3D Numpy array.
Raises
img
or data_format
is passed.ImageDataGenerator
classtf.keras.preprocessing.image.ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
zca_epsilon=1e-06,
rotation_range=0,
width_shift_range=0.0,
height_shift_range=0.0,
brightness_range=None,
shear_range=0.0,
zoom_range=0.0,
channel_shift_range=0.0,
fill_mode="nearest",
cval=0.0,
horizontal_flip=False,
vertical_flip=False,
rescale=None,
preprocessing_function=None,
data_format=None,
validation_split=0.0,
dtype=None,
)
Generate batches of tensor image data with real-time data augmentation.
The data will be looped over (in batches).
Arguments
(-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, +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).[lower, upper] = [1-zoom_range, 1+zoom_range]
.fill_mode = "constant"
.(samples, height, width, channels)
,
"channels_first" mode means that the images should have shape
(samples, channels, height, width)
.
It defaults to the image_data_format
value found in your
Keras config file at ~/.keras/keras.json
.
If you never set it, then it will be "channels_last".Examples
Example of using .flow(x, y)
:
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
y_train = np_utils.to_categorical(y_train, num_classes)
y_test = np_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)
# 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),
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)
:
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.
# 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)
flow
methodImageDataGenerator.flow(
x,
y=None,
batch_size=32,
shuffle=True,
sample_weight=None,
seed=None,
save_to_dir=None,
save_prefix="",
save_format="png",
subset=None,
)
Takes data & label arrays, generates batches of augmented data.
Arguments
''
). Prefix to use for filenames of saved
pictures (only relevant if save_to_dir
is set).save_to_dir
is set). Default: "png"."training"
or "validation"
) if
validation_split
is set in ImageDataGenerator
.Returns
An Iterator
yielding tuples of (x, y)
where x
is a numpy array of image data
(in the case of a single image input) or a list
of numpy arrays (in the case with
additional inputs) and y
is a numpy array
of corresponding labels. If 'sample_weight' is not None,
the yielded tuples are of the form (x, y, sample_weight)
.
If y
is None, only the numpy array x
is returned.
flow_from_dataframe
methodImageDataGenerator.flow_from_dataframe(
dataframe,
directory=None,
x_col="filename",
y_col="class",
weight_col=None,
target_size=(256, 256),
color_mode="rgb",
classes=None,
class_mode="categorical",
batch_size=32,
shuffle=True,
seed=None,
save_to_dir=None,
save_prefix="",
save_format="png",
subset=None,
interpolation="nearest",
validate_filenames=True,
**kwargs
)
Takes the dataframe and the path to a directory + generates batches.
The generated batches contain augmented/normalized data.
A simple tutorial can be found here.
Arguments
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.None
,
data in x_col
column should be absolute paths.dataframe
that contains the filenames (or
absolute paths if directory
is None
).dataframe
that has the target data.dataframe
that contains the sample
weights. Default: None
.(height, width)
, default: (256, 256)
.
The dimensions to which all images found will be resized.['dogs', 'cats']
). Default is
None. If not provided, the list of classes will be automatically
inferred from the y_col
, which will map to the label indices, will
be alphanumeric). The dictionary containing the mapping from class
names to class indices can be obtained via the attribute
class_indices
."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()
).save_to_dir
is set).save_to_dir
is set). Default: "png"."training"
or "validation"
) if
validation_split
is set in ImageDataGenerator
."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.x_col
. If True
, invalid images will be ignored. Disabling this
option can lead to speed-up in the execution of this function.
Defaults to True
.Returns
A DataFrameIterator
yielding tuples of (x, y)
where x
is a numpy array containing a batch
of images with shape (batch_size, *target_size, channels)
and y
is a numpy array of corresponding labels.
flow_from_directory
methodImageDataGenerator.flow_from_directory(
directory,
target_size=(256, 256),
color_mode="rgb",
classes=None,
class_mode="categorical",
batch_size=32,
shuffle=True,
seed=None,
save_to_dir=None,
save_prefix="",
save_format="png",
follow_links=False,
subset=None,
interpolation="nearest",
)
Takes the path to a directory & generates batches of augmented data.
Arguments
(height, width)
, defaults to (256,
256)
. The dimensions to which all images found will be resized.['dogs', 'cats']
). Default: None. If not provided, the list
of classes will be automatically inferred from the subdirectory
names/structure under directory
, where each subdirectory will be
treated as a different class (and the order of the classes, which
will map to the label indices, will be alphanumeric). The
dictionary containing the mapping from class names to class
indices can be obtained via the attribute class_indices
.model.predict()
). Please note that in case of
class_mode None, the data still needs to reside in a subdirectory
of directory
for it to work correctly.save_to_dir
is set).save_to_dir
is set). Default: "png"."training"
or "validation"
) if
validation_split
is set in ImageDataGenerator
."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.Returns
A DirectoryIterator
yielding tuples of (x, y)
where x
is a numpy array containing a batch
of images with shape (batch_size, *target_size, channels)
and y
is a numpy array of corresponding labels.