मैं जिस आर्किटेक्चर को लागू करने की कोशिश कर रहा हूं वह यहां है: रोगी-डेटा अनुकूलित मॉडल आर्किटेक्चर: ResNet-50। मेरी छवियों को लेबल द्वारा फ़ोल्डरों में विभाजित किया गया है:

root/
    ├── train/
    │   ├── class1/
    │   ├── class2/
    │   ...
    │
    └── validation/
       ├── class1/
       ├── class2/
       ...

मेरे पास एक CSV फ़ाइल भी है जिसमें छवि का नाम, छवि लेबल (एक छवि में कई वर्ग लेबल हो सकते हैं) और अतिरिक्त जानकारी शामिल है:

+--------+---------------+-------+------+
| File  |    Labels     | Info1 | Info2 |
+-------+---------------+-------+-------+
| 1.png | class1        | 0.512 |     1 |
| 2.png | class2        |   0.4 |     0 |
| 3.png | class1|class2 |  0.64 |     1 |
+-------+---------------+-------+-------+

मेरे नेटवर्क मॉडल में दो इनपुट हैं, एक जिसका उपयोग छवि को संसाधित करने के लिए किया जाएगा और दूसरा जो घने परत से पहले अंतिम परत से जुड़ा होगा:

input_shape = (img_height, img_width, 1)

img_input= Input(input_shape)
vec_input = Input((2,))

res = ZeroPadding2D((3, 3))(img_input)

# Processing ...

res = Flatten()(res)
res = Concatenate()([res, vec_input])
res = Dense(classes, activation='softmax', name='fc' + str(classes))(res)

छवियों को प्राप्त करने के लिए मैं Flow_from_directory के साथ ImageDataGenerator का उपयोग कर रहा हूं, जो केवल छवि डेटा प्राप्त करने के लिए ठीक काम करता है:

validation_datagen = ImageDataGenerator(rescale=1. / 255)
validation_generator = validation_datagen.flow_from_directory(
        validation_dir,
        target_size=(target_size, target_size),
        batch_size=batch_size,
        class_mode=class_mode,
        color_mode=color_mode)

# Similarly for the train data generator ...

# Train the model using above defined data generators
history = model.fit_generator(
    train_generator,
    epochs=epochs,
    validation_data=validation_generator)

अब मुझे अपने मॉडल में vec_input के रूप में प्रत्येक छवि के लिए अतिरिक्त जानकारी का उपयोग करने की आवश्यकता है। मैंने Flow_from_dataframe का उपयोग करने और कस्टम जेनरेटर बनाने पर ध्यान दिया है, लेकिन मुझे यकीन नहीं है कि इस बारे में कैसे जाना है। यदि आवश्यक हो तो मैं छवियों को उसी फ़ोल्डर में डालकर पुन: व्यवस्थित कर सकता हूं, हालांकि मुझे लगता है कि मैं Flow_from_directory का उपयोग नहीं कर सकता। मैं इसे कैसे प्राप्त कर सकता हूं इस पर कोई विचार?

संपादित करें:

अगर किसी को समाधान की आवश्यकता है, तो मैं इसके साथ आने में सक्षम हूं:

class CustomSequenceGenerator(Sequence):

    def __init__(self, image_dir, csv_file_path, label_path, dim=448, batch_size=8,
                 n_classes=15, n_channels=1, vec_size=3, shuffle=True):
        # Keras generator
        self.image_dir = image_dir
        self.image_file_list = os.listdir(image_dir)
        self.batch_size = batch_size
        self.csv_file = pd.read_csv(csv_file_path)
        self.n_classes = n_classes
        self.dim = dim
        self.n_channels = n_channels
        self.shuffle = shuffle
        self.vec_size = vec_size
        self.labels = get_class_labels(label_path)
        self.labels_dict = dict(zip(self.labels, range(0, len(self.labels))))

        self.csv_file.set_index('File', inplace=True, drop=True)

    def __len__(self):
        """It is mandatory to implement it on Keras Sequence"""
        return int(np.ceil(len(self.image_file_list) / float(self.batch_size)))

    def __getitem__(self, index):

        # Generate indexes of the batch
        samples = self.image_file_list[index * self.batch_size:(index + 1) * self.batch_size]

        x, y = self.__data_generation(samples, index)
        return x, y

    def __data_generation(self, samples, start_index):

        x_batch_image = np.empty((self.batch_size, self.dim, self.dim, self.n_channels))
        x_batch_vector = np.empty((self.batch_size, self.vec_size))
        y_batch = np.empty((self.batch_size, self.n_classes))
        self.csv_file.reindex()
        for i, sample in enumerate(samples):
            image_file_path = self.image_dir + "/" + sample
            image = self.preprocess_image(Image.open(image_file_path), 448)

            features, labels = self.preprocess_csv(self.csv_file, sample, self.labels_dict, self.n_classes)
            x_batch_image[i] = image
            x_batch_vector[i] = features
            y_batch[i] = labels

        return [x_batch_image, x_batch_vector], y_batch
1
Predrag Antanasijevic 29 सितंबर 2019, 10:08

1 उत्तर

सबसे बढ़िया उत्तर

मुझे लगता है कि इसे हासिल करने का सबसे अच्छा तरीका एक कस्टम Sequence ऑब्जेक्ट लागू करना होगा, संभावित रूप से ImageDataGenerator के तरीकों को विरासत में मिला है। हो सकता है कि आपको जो चाहिए वह ImageDataGenerator (यानी यादृच्छिक परिवर्तन, छवि बचत, इंटरपोलेशन) की सभी जटिलताओं की आवश्यकता नहीं है और इस मामले में आपको इसे प्राप्त करने की आवश्यकता नहीं होगी।

0
Zaccharie Ramzi 29 सितंबर 2019, 13:05