Plot einer ROC-Kurve erzeugen CNN

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Antworten
uLocked
User
Beiträge: 27
Registriert: Dienstag 9. Februar 2021, 10:29

Hallo,

Wie plottet man eine ROC-Kurve? Bei allen Anleitungen, die ich gefunden habe, da habe ich nicht erkannt, wie ich das für meinen Code anpassen muss.
Ich will zu mehreren Modellen eine ROC Curve plotten.

Code: Alles auswählen

import tensorflow as tf
from tensorflow.keras.optimizers import RMSprop
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
from keras.preprocessing import image
from keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.callbacks import TensorBoard
from PIL import ImageFile
from output import output_aufbereiten
from sklearn.metrics import confusion_matrix
from sklearn.metrics import roc_curve, auc

from tensorflow.python.client import device_lib
print(device_lib.list_local_devices())

ImageFile.LOAD_TRUNCATED_IMAGES = True

CUSTOM_EARLY_STOPPING = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss',
    mode='min',
    restore_best_weights=True,
    verbose=1,
    patience=3
)

# Namen der Kategorien
CLASS_NAME = ["Klasse1", "Klasse2", "Klasse3"]

# Vorverarbeiten der Trainingsdaten
TRAIN_DATAGEN = ImageDataGenerator(rescale=1 / 255, rotation_range=360, zoom_range=0.2, shear_range=0.2)

# Vorverarbeiten der Testdaten
TEST_DATAGEN = ImageDataGenerator(rescale=1 / 255, rotation_range=360, zoom_range=0.2, shear_range=0.2)

BS = 32  # Batch Size
IMG_SIZE = 150  # Image Size

# Trainingsdaten generieren
TRAINING_SET = TRAIN_DATAGEN.flow_from_directory(r"C:/Bilder/Train",
                                                 target_size=(IMG_SIZE, IMG_SIZE),
                                                 batch_size=BS,
                                                 classes=CLASS_NAME,
                                                 class_mode="categorical")
# Testdaten generieren
TEST_SET = TEST_DATAGEN.flow_from_directory(r"C:/Bilder/Test",
                                            target_size=(IMG_SIZE, IMG_SIZE),
                                            batch_size=BS,
                                            classes=CLASS_NAME,
                                            class_mode="categorical")

# Konfiguration des Modells
DENSE_LAYERS = [0]  # Dense Layer = Anzahl Layer vor dem Output-Layer
LAYER_SIZES = [128]  # Anzahl der Neuronen in den Layern
CONV_LAYERS = [3]  # Anzahl der faltenden Layer

DURCHGANG = 1
J = 0

for dense_layer in DENSE_LAYERS:
    for layer_size in LAYER_SIZES:
        for conv_layer in CONV_LAYERS:

            # Erzeugen eines eindeutigen Namens für das Modell
            NAME = f'CNN-{IMG_SIZE}-CONV-{conv_layer}-SIZE-{layer_size}-DENSE-{dense_layer}-BATCH-{BS}-TEST'

            print(NAME)

            # Erzeugen der Logfiles im Ordner logs
            TENSORBOARD = TensorBoard(log_dir=f"logs2/{NAME}")

            MODEL = Sequential()
            # Input Layer / Eingabeschicht (1. ConLayer)
            MODEL.add(Conv2D(layer_size, (3, 3), activation="relu", input_shape=(IMG_SIZE, IMG_SIZE, 3)))  # Ursprung 16
            MODEL.add(MaxPooling2D(2, 2))
            # Convolutional Layer / Faltende Schicht
            for l in range(conv_layer - 1):
                MODEL.add(Conv2D(layer_size, (3, 3), activation="relu"))
                MODEL.add(MaxPooling2D(2, 2))

            MODEL.add(Flatten())
            # Hiddenlayer / Versteckte Schichten
            for l in range(dense_layer):
                MODEL.add(Dense(layer_size, activation="relu"))

            # Dense Layer / Ausgabeschicht
            MODEL.add(Dense(3, activation="softmax"))

            MODEL.summary()  # Zusammenfassung des Modells ausgeben
            OPT = tf.keras.optimizers.Adam(learning_rate=0.001, decay=1e-6)
            # OPT = RMSprop(learning_rate=0.001)  # Festlegen des Optimizers und der Learning_rate
            # Festlegen wie der Loss berechnet wird und welche Metriken verwendet werden
            MODEL.compile(loss="categorical_crossentropy",
                          optimizer=OPT,
                          metrics=[tf.keras.metrics.Recall(),
                                   tf.keras.metrics.Precision(),
                                   "accuracy",
                                   tf.keras.metrics.TruePositives(),
                                   tf.keras.metrics.TrueNegatives(),
                                   tf.keras.metrics.FalseNegatives(),
                                   tf.keras.metrics.FalsePositives(),
                                   tf.keras.metrics.AUC()
                                   ])

            # Trainieren des Modells
            GOKU = MODEL.fit(TRAINING_SET, batch_size=BS, epochs=10, callbacks=[TENSORBOARD, CUSTOM_EARLY_STOPPING], validation_data=TEST_SET)

            # Speichern des Models
            MODEL.save('Modelle/' + NAME + '.model')

Bitte um Hilfe
Antworten