Keras：使用生成器输出训练集批次和目标，以及不用于训练的辅助数据

我需要使用生成器（因为数据集太大）将训练数据和目标生成给CNN进行训练。但是，每个数据样本都是标准化的（/maxVal），我需要在loss函数之前取消标准化/反标准化。我不知道如何在从生成器输出一批（X，Y）的同时输出这些辅助数据

这非常类似于：

---

因此，如果我正确理解了您的需求，您需要做什么：

在整个目标（y）数据集上安装

MinMaxScaler

（如果可能）

每批

调整批次的目标

实现您的批次目标

创建一个以定标器为参数的自定义丢失函数

在您的

y\u-true

上调用您的定标器的

逆变换

，在您的自定义丢失中调用

y\u-pred

在非标准化的

y\u true

和

y\u pred

上调用您最喜欢的损失函数并返回其值

---

你能展示你的代码，让我们更好地了解你想要实现的目标吗？我会尝试展示一些东西，但由于保密原因，我无法展示所有东西。这非常类似于：使用你提供的代码，我发现有点难以看到你的数据在哪里规范化（当您从磁盘加载样本时，样本是否已经标准化）以及您希望在何处对其进行反标准化。此外，要反标准化数据，您需要知道原始平均值和标准偏差，您是否有此信息？是的，抱歉-我添加了返回X/np.max（X），y/np.max（y）这就是我想要做的，几乎和我想要的一样，但是：训练数据（x）还必须对网络进行规范化，以便在规范化域中学习，我不明白逆_变换如何知道如何对y_true和y_pred进行反规范化？Keras可以将其存储在一种不用于训练的辅助变量中吗？还是其他什么？（因为在现实中，每个训练示例都有不同的最大值，这些不会是介于0和255之间的图像，而是其他的东西…）你必须使用两个定标器：一个用于你的样本，一个用于你的目标。我只包括了必须为目标所做的事情，因为我不明白为什么你要对样本进行反规范化，因为它们不用于计算损失。是的，我确实不需要对样本进行反规范化，这是正确的，但它们必须进行规范化，然后是y_pred必须使用相同的最大值进行反规范化，你不同意吗？我不明白的是，如何/在何处存储这些最大值，用于反规范化-对于每个y_pred，y_true？关于“存储”呢？

import numpy as np
import cv2
from tensorflow.keras.utils import Sequence


class DataGenerator(Sequence):
    """Generates data for Keras
    Sequence based data generator. Suitable for building data generator for training and prediction.
    """
    def __init__(self, list_IDs, labels, image_path, mask_path,
                 to_fit=True, batch_size=32, dim=(256, 256),
                 n_channels=1, n_classes=10, shuffle=True):
        """Initialization
        :param list_IDs: list of all 'label' ids to use in the generator
        :param labels: list of image labels (file names)
        :param image_path: path to images location
        :param mask_path: path to masks location
        :param to_fit: True to return X and y, False to return X only
        :param batch_size: batch size at each iteration
        :param dim: tuple indicating image dimension
        :param n_channels: number of image channels
        :param n_classes: number of output masks
        :param shuffle: True to shuffle label indexes after every epoch
        """
        self.list_IDs = list_IDs
        self.labels = labels
        self.image_path = image_path
        self.mask_path = mask_path
        self.to_fit = to_fit
        self.batch_size = batch_size
        self.dim = dim
        self.n_channels = n_channels
        self.n_classes = n_classes
        self.shuffle = shuffle
        self.on_epoch_end()

    def __len__(self):
        """Denotes the number of batches per epoch
        :return: number of batches per epoch
        """
        return int(np.floor(len(self.list_IDs) / self.batch_size))

    def __getitem__(self, index):
        """Generate one batch of data
        :param index: index of the batch
        :return: X and y when fitting. X only when predicting
        """
        # Generate indexes of the batch
        indexes = self.indexes[index * self.batch_size:(index + 1) * self.batch_size]

        # Find list of IDs
        list_IDs_temp = [self.list_IDs[k] for k in indexes]

        # Generate data
        X = self._generate_X(list_IDs_temp)

        if self.to_fit:
            y = self._generate_y(list_IDs_temp)
            return X/np.max(X), y/np.max(y)
        else:
            return X

    def on_epoch_end(self):
        """Updates indexes after each epoch
        """
        self.indexes = np.arange(len(self.list_IDs))
        if self.shuffle == True:
            np.random.shuffle(self.indexes)

    def _generate_X(self, list_IDs_temp):
        """Generates data containing batch_size images
        :param list_IDs_temp: list of label ids to load
        :return: batch of images
        """
        # Initialization
        X = np.empty((self.batch_size, *self.dim, self.n_channels))

        # Generate data
        for i, ID in enumerate(list_IDs_temp):
            # Store sample
            X[i,] = self._load_grayscale_image(self.image_path + self.labels[ID])

        return X

    def _generate_y(self, list_IDs_temp):
        """Generates data containing batch_size masks
        :param list_IDs_temp: list of label ids to load
        :return: batch if masks
        """
        y = np.empty((self.batch_size, *self.dim), dtype=int)

        # Generate data
        for i, ID in enumerate(list_IDs_temp):
            # Store sample
            y[i,] = self._load_grayscale_image(self.mask_path + self.labels[ID])

        return y

    def _load_grayscale_image(self, image_path):
        """Load grayscale image
        :param image_path: path to image to load
        :return: loaded image
        """
        img = cv2.imread(image_path)
        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        img = img / 255
        return img