Подход к обучению большого набора данных изображений с использованием керас, нехватка памяти

Question

Я новичок в области компьютерного зрения и ML. Я пытаюсь разработать модель распознавания изображений, которую я тренирую, с большим набором данных изображений (50 000 изображений, размером 18 ГБ), но на ноутбуке. как Acer Predator с 16 ГБ памяти и процессором Core i7 7-го поколения, GTX 1060 Nvidia, у меня не хватает памяти, хотя я использую графический процессор на tenorflow.

Если я тренирую эту модель с несколькими изображениями, такими как 2000, до 4000, то она работает нормально. Кажется, есть какой-то неправильный подход, который я использую для обучения этой модели, но я не могу понять правильный подход. Я думаю, что если я загружаю изображения небольшими партиями, а затем тренируюсь, это может помочь, но я не знаю, как этого добиться.

Ниже приведен фрагмент кода моего запроса модели поезда.

Мой train.py как показано ниже

import matplotlib
matplotlib.use("Agg")
from keras.preprocessing.image import ImageDataGenerator
from keras.optimizers import Adam
from keras.preprocessing.image import img_to_array
from keras.preprocessing import image
from sklearn.preprocessing import MultiLabelBinarizer
from sklearn.model_selection import train_test_split
from pyimagesearch.smallervggnet import SmallerVGGNet
import matplotlib.pyplot as plt
from imutils import paths
import numpy as np
import random
import pickle
import os
import json
import tensorflow as tf
with tf.device('/device:CPU:0'):
a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name='a')
b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name='b')
c = tf.matmul(a, b)
#config = tf.ConfigProto(log_device_placement=True)

session = tf.Session(config=tf.ConfigProto(log_device_placement=True))
print(session.run(c))

with open('conf/conf.json') as f:
config = json.load(f)

# config variables
dataset     = config["dataset"]
model_path      = config["model"]
labelbin   = config["labelbin"]
plot   = config["plot"]
test_image     = config["test_image"]
print('dataset: %s '+dataset)

EPOCHS = 75
INIT_LR = 1e-3
BS = 32
IMAGE_DIMS = (96, 96, 3)

# grab the image paths and randomly shuffle them
print("[INFO] loading images...")
imagePaths = sorted(paths.list_images(dataset))
random.seed(42)
random.shuffle(imagePaths)

# initialize the data and labels
data = []
labels = []
for imagePath in imagePaths:
 img = image.load_img(imagePath,target_size=(IMAGE_DIMS[1], IMAGE_DIMS[0]))     
 img = img_to_array(img)
 data.append(img)
 l = label = imagePath.split(os.path.sep)[-2].split("_")
 labels.append(l)

print("[INFO] images loading done...")

# scale the raw pixel intensities to the range [0, 1]
data = np.array(data, dtype="float") / 255.0
labels = np.array(labels)
print("[INFO] data matrix: {} images ({:.2f}MB)".format(
len(imagePaths), data.nbytes / (1024 * 1000.0)))

# binarize the labels using scikit-learn's special multi-label
# binarizer implementation
print("[INFO] class labels:")
mlb = MultiLabelBinarizer()
labels = mlb.fit_transform(labels)

# loop over each of the possible class labels and show them
for (i, label) in enumerate(mlb.classes_):
print("{}. {}".format(i + 1, label))

# partition the data into training and testing splits using 80% of
# the data for training and the remaining 20% for testing
(trainX, testX, trainY, testY) = train_test_split(data,
labels, test_size=0.2, random_state=42)

# construct the image generator for data augmentation
aug = ImageDataGenerator(rotation_range=25, width_shift_range=0.1,
 height_shift_range=0.1, shear_range=0.2, zoom_range=0.2,
 horizontal_flip=True, fill_mode="nearest")

 # initialize the model using a sigmoid activation as the final layer
 # in the network so we can perform multi-label classification
 print("[INFO] compiling model...")
 model = SmallerVGGNet.build(
 width=IMAGE_DIMS[1], height=IMAGE_DIMS[0],
 depth=IMAGE_DIMS[2], classes=len(mlb.classes_),
 finalAct="sigmoid")

 # initialize the optimizer (SGD is sufficient)
  opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)

 # compile the model using binary cross-entropy rather than
 # categorical cross-entropy -- this may seem counterintuitive for
 # multi-label classification, but keep in mind that the goal here
 # is to treat each output label as an independent Bernoulli
 # distribution
   model.compile(loss="binary_crossentropy", optimizer=opt,
   metrics=["accuracy"])

 # train the network
   print("[INFO] training network...")
 H = model.fit_generator(
   aug.flow(trainX, trainY, batch_size=BS),
   validation_data=(testX, testY),use_multiprocessing=True,
   steps_per_epoch=len(trainX) // BS,
   epochs=EPOCHS, verbose=1)

 # save the model to disk
  print("[INFO] serializing network...")
  model.save(model_path)

 # save the multi-label binarizer to disk
 print("[INFO] serializing label binarizer...")
 f = open(labelbin, "wb")
 f.write(pickle.dumps(mlb))
 f.close()

Conf.json :

{
"dataset"         : "data-images",
"model"         : "output/fashion.model",
"labelbin"         : "output/mlb.pickle",
"plot"           :  "output/plot.png",
"test_image"           :  "examples/example_01.jpg"
}