YOLO-NAS Bilder mit detections weiterverarbeiten

[Fredddd]

Hallo,
mit YOLO-NAS kann man Bilder durchlaufen lassen dieser erkennen Personen, Hund und Katze etc.

Das funktioniert auch soweit gut , nur werden zb. auch jene Bilder abgespeichert die keine Erkennungen haben.

Jetzt habe ich nach langem suchen gefunden das man mit Hilfe der Labels (denke ich) oder auch BBox diese weiterverarbeiten kann.

Hier habe ich aus verschiedenen Codes schon etwas zusammengestellt das funktioniert, bei der Weiterverarbeitung hänge ich leider.

Es scheint alle Bilder werden in ein Array gespeichert und dann auf einmal ausgegeben. Diese werden in einen Ordner gespeichert und mit 1 beginnend nummeriert.
Muss ich diese aus dem Array löschen? oder nur erkannte in ein neues schreiben und dann speichern?

Ich würde gerne nur Bilder speichern(mit original Namen) bei dem etwas erkannt wurde.
Später würde ich gerne anstelle des abspeichern das Originalbild (oder Video) im original Ordner löschen .
Leider findet man sehr wenig Dokumentation , bzw. ich finde diese nicht . zb. um zu sehen wie die Ordner verarbeitet werden.

Code: Alles auswählen

import gc
import os
import torch
from torchinfo import summary
from super_gradients.training import models
import argparse



def detect_objects(image):
    device = torch.device("cpu")
    model = models.get("yolo_nas_s", pretrained_weights="coco").to(device)
    out = model.predict(image, conf=0.6)

    for image_prediction in out:
        class_names = image_prediction.class_names
        labels = image_prediction.prediction.labels
        confidence = image_prediction.prediction.confidence
        bboxes = image_prediction.prediction.bboxes_xyxy
	out.save("predictions");


        for i, (label, conf, bbox) in enumerate(zip(labels, confidence, bboxes)):
            print("prediction: ", i)
            print("label_id: ", label)
            print("label_name: ", class_names[int(label)])
            print("confidence: ", conf)
            print("bbox: ", bbox)
            print("--" * 10)
           
            # You can use the detection results for various tasks, such as:
            # - Filtering objects based on confidence scores or labels
            # - Analyzing object distributions within the images
            # - Calculating object dimensions or areas
            # - Implementing custom visualization techniques
            # - ...

   	

    del model
    gc.collect()
    torch.cuda.empty_cache()


if __name__ == "__main__":
    os.makedirs("predictions", exist_ok=True)

    ap = argparse.ArgumentParser()
    ap.add_argument("-i", "--image", required = True, help = "Path to input file")
    args = vars(ap.parse_args())

    detect_objects(args["image"])

Der ganze Codes stammt von https://dev.to/ethand91/object-detectio ... lo-nas-831 und von https://docs.deci.ai/super-gradients/do ... ple-images

Leider kenne ich mich nicht so gut aus und bitte um Nachsicht.

[__blackjack__]

@Fredddd: Für Dateioperationen gibt es das `pathlib`-Modul in der Standardbibliothek. Das ist selbstverständlich auch dokumentiert. Ebenfalls in der Dokumentation gibt ein Python-Tutorial für Einsteiger das man mal durchgearbeitet haben sollte.

Anmerkungen zum Quelltext: Das Hauptprogramm sollte auch in einer Funktion stehen.

``del model`` und ``gc.collect()`` am Ende der Funktion ist unsinniges Voodoo. Da hofft jemand was zu erreichen was entweder so nicht erreichbar ist, oder sowieso schon passiert. Das Semikolon an dem einen Zeilenende lässt vermuten, dass da in einer anderen Programmiersprache gedacht wird, wo man sich selbst um die Speicherverwaltung kümmern muss. Der `cuda.empty_cache()`-Aufruf macht vielleicht auch nicht so viel Sinn wenn man die CPU rechnen lässt, statt der GPU.

Gewöhne Dir gar nicht erst an irgendwelche kryptischen Abkürzungen in Namen zu verwenden. Also Beispielsweise `parser` statt `ap`. Man muss auch nicht jedes kleine Zwischenergebnis noch mal an einen eigenen Namen binden.

`required` ist bei *Optionen* die dem Namen nach ja *optional* sind, irgendwie ein Widerspruch. Man kann sich `argparse` hier also ganz sparen. Was auch keinen Sinn macht ist der `vars()`-Aufruf. Man hätte da einfach ganz normal auf das Attribut zugegriffen statt erst ein Wörterbuch mit den Attributen zu erstellen und da dann auf den Attributwert über den Namen als Schlüssel zuzugreifen.

Zwischenstand (ungetestet):

Code: Alles auswählen

#!/usr/bin/env python3
import sys
from pathlib import Path

import torch
from super_gradients.training import models
from torchinfo import summary


def detect_objects(image):
    predictions = (
        models.get("yolo_nas_s", pretrained_weights="coco")
        .to(torch.device("cpu"))
        .predict(image, conf=0.6)
    )
    predictions.save("predictions")
    for prediction in predictions:
        for i, (label, confidence, bbox) in enumerate(
            zip(
                prediction.prediction.labels,
                prediction.prediction.confidence,
                prediction.prediction.bboxes_xyxy,
            )
        ):
            print("prediction:", i)
            print("label_id:", label)
            print("label_name:", prediction.class_names[int(label)])
            print("confidence:", confidence)
            print("bbox:", bbox)
            print("--" * 10)

            # You can use the detection results for various tasks, such as:
            # - Filtering objects based on confidence scores or labels
            # - Analyzing object distributions within the images
            # - Calculating object dimensions or areas
            # - Implementing custom visualization techniques
            # - ...


def main():
    Path("predictions").mkdir(exist_ok=True)

    if len(sys.argv) < 2:
        print(f"Usage: {sys.argv[0]} IMAGE")
        sys.exit(1)

    detect_objects(sys.argv[1])


if __name__ == "__main__":
    main()

Edit: Nachträglich aufgefallen: *In* der Schleife immer wieder alle `predictions` zu speichern macht keinen Sinn, das gehört vor die Schleife.

[Sirius3]

Es macht wenig Sinn für jede Prediction nochmals save aufzurufen, das ja alle Predictions in einem Bild speichert.
Du darfst halt nicht bedingungslos immer save aufrufen, sondern mußt je nachdem, was Du willst, nur das speichern, was Dich auch interessiert.

[Fredddd]

ich werde versuchen Eure Hilfe zu interpretieren und zu verdauen. ich komme aus dem Zeitalter Modulo, Pascal, Maschinencode 8086 und das alles nicht so gut
Objekt orientiert zu programmieren ist mir anscheinend zu hoch....Wahnsinn wie weit ich daneben stehe.

Ich werde versuchen mir `pathlib`-Modul anzusehen..und Eure Antworten zu verstehen. Einige Kurse habe ich bei linkedin learning schon gemacht...python object oriented programming, using python for automation, learning Python, Yolov3
trotzdem OO programmieren ist fuer mich sehr schwer.

[__deets__]

Da ist doch nix gross OO dabei, die Frage, ob etwas getan werden soll, ist in allen genannten Sprachen ein "if bedingung, dann tuwas" - natuerlich syntaktisch etwas anders, aber nicht fundamental anders.

[__blackjack__]

Wenn ich die Ausgangsfrage richtig verstanden habe, dann kannst Du mit der `save()`-Methode nicht so viel anfangen wenn eigentlich Bilddateien gelöscht werden sollen. Und die Schleife über die `predictions` ist ganz nett als Info, aber eigentlich interessiert ja nur ob überhaupt welche gefunden wurden. Da das neben Iteration auch Indexzugriff bietet, nehme ich mal stark an, dass man mit `len()` auch die Länge abfragen kann, womit `predictions` direkt als Bedingung verwendet werden kann, beziehungsweise mit ``not`` negiert werden kann.

Vorsicht, das hier löscht gegebenenfalls die angegebene Datei, falls etwas auf dem Bild erkannt wird! (untetestet):

Code: Alles auswählen

#!/usr/bin/env python3
import sys
from pathlib import Path

import torch
from super_gradients.training import models


def main():
    if len(sys.argv) < 2:
        print(f"Usage: {sys.argv[0]} IMAGE")
        sys.exit(1)

    image_file_path = Path(sys.argv[1])
    if (
        models.get("yolo_nas_s", pretrained_weights="coco")
        .to(torch.device("cpu"))
        .predict(str(image_file_path), conf=0.6)
    ):
        image_file_path.unlink()


if __name__ == "__main__":
    main()

Du solltest übrigens mit dem Begriff „Array“ vorsichtig sein. In Python gibt es eine ganze Menge Sequenztypen, allen voran die Liste, aber auch alle möglichen spezialisiertere Typen in anderen Modulen. Es gibt auch Array-Typen. Damit sind in der Regel Numpy-Arrays gemeint, oder der eingebaute `bytearray`-Typ.

Edit: Bei TurboPascal gab's ab 1989 auch OOP. War mein erster Kontakt mit dem Konzept.

[Fredddd]

Hallo nochmal.
@__blackjack__ Danke ich habe diesen code studiert und hoffe auch verstanden. Ich glaube auch das dein Code alles loescht darum siehe weiter unten habe es so aehnlich schon probiert da wurden entweder alle gespeicher oder keines.
Also Array meinte ich, weil ich mir nicht sicher war, ich nahm an es ist ein NUMPY array.(eine Definition des bytearreys habe ich nicht gefunden)

Die Version in meinem ersten Post mag ja für euch total falsch sein.
Habe sie nochmal laufen lassen um euch zu zeigen was dabei raus kommt.
Ich würde gerne auch den Filenamen sehen. Ihr seht ich habe bei so einfachen Dingen schon ein Problem wo ich die Info finde wo das beschrieben steht was ich da abfragen muss.

Code: Alles auswählen

Predicting Images: 100%|██████████████████████████| 4/4 [00:00<00:00,  5.85it/s]
prediction:  0
label_id:  0.0
label_name:  person
confidence:  0.92187285
bbox:  [2014.1775   293.81778 4927.728   3502.6714 ]
--------------------
prediction:  1
label_id:  16.0
label_name:  dog
confidence:  0.8887098
bbox:  [ 892.2528   722.57587 2237.5776  2621.0347 ]
--------------------
prediction:  2
label_id:  63.0
label_name:  laptop
confidence:  0.81550175
bbox:  [1126.4446 1904.3103 2129.3315 2835.8726]
--------------------
prediction:  3
label_id:  0.0
label_name:  person
confidence:  0.75204164
bbox:  [1970.322    850.12335 3460.2668  2972.9885 ]
--------------------
prediction:  4
label_id:  63.0
label_name:  laptop
confidence:  0.7405947
bbox:  [ 677.17126 1951.5002  2526.3433  3222.5566 ]
--------------------
prediction:  5
label_id:  0.0
label_name:  person
confidence:  0.7187135
bbox:  [4461.1953     36.758224 5323.004    3505.6003  ]
--------------------
prediction:  0
label_id:  16.0
label_name:  dog
confidence:  0.9367625
bbox:  [1239.5007 1717.034  2386.0566 3875.7498]
--------------------
prediction:  1
label_id:  16.0
label_name:  dog
confidence:  0.9157715
bbox:  [1.7212931e+00 2.3367742e+03 1.0089992e+03 4.0435928e+03]
--------------------
prediction:  2
label_id:  0.0
label_name:  person
confidence:  0.7366132
bbox:  [ 348.86942 1114.1796  2033.4965  4178.9624 ]
--------------------
prediction:  0
label_id:  58.0
label_name:  potted plant
confidence:  0.8515952
bbox:  [  0.74313956 229.66447    184.51521    477.8348    ]
--------------------
prediction:  1
label_id:  58.0
label_name:  potted plant
confidence:  0.7260069
bbox:  [328.75952 260.1549  368.02267 314.9783 ]
--------------------
prediction:  2
label_id:  58.0
label_name:  potted plant
confidence:  0.66263354
bbox:  [419.3816  258.03506 481.37643 309.36545]

gestartet mit : python image.py -i /home/user1/Pictures/


Wie man sieht 3 Bilder haben Eintraege , eines nicht , wird aber auch gespeichert. Ich dachte man müsste diesen "ARRAY Eintrag" löschen und dann out.save machen?

Code: Alles auswählen

pred_0.jpg  pred_1.jpg  pred_2.jpg  pred_3.jpg

Was ich bei anderen gelesen habe ist das diese nach bbox entscheiden ob was gefunden wurde oder nicht. Denke Label id muesste auch gehen.

[__blackjack__]

Ein schönes Beispiel warum Namen wichtig sind. Das was Du da `image` genannt hast ist also gar kein einzelnes Bild sondern ein Pfad wo mehrere Bilder liegen. Ich ging davon aus es wäre ein Einzelbild.

Die Dateinameninformation für die Einzelbilder muss irgendwo im Ergebnis von `predict()` vorhanden sein — sonst hast Du ein Problem. Schau in die Dokumentation von der Funktion was die zurück gibt, und welche Informationen da alle enthalten sind. Notfalls untersuche die Objekte ”live” in einer Python-Shell.

[Fredddd]

@__blackjack__ Cool, jetzt sind wir dort...also haben wir aneinander vorbeigeredet. Tut mir leid!!!!!!!
Die URLs habe ich dazugegeben von welchen ich das ganze nahm, das ganze habe nicht ich so genannt, aber es macht es jetzt klar, falscher Namen.

Ich redeted von Bildern in Pfaden

Diese Dokumentation der Predict() https://github.com/Deci-AI/super-gradie ... ictions.md

Ich dachte mir ich mache einen Fehler weil ich nirgends einen Filenamen finde...auch nicht dokumentiert.

[__blackjack__]

@Freddd: Da sieht man ja, dass man statt eines Pfades als Zeichenkette auch eine Liste mit konkreten Dateinamen übergeben kann. *das* müsste man dann machen wenn man die hinterher auch benutzen möchte um etwas mit der ursprünglichen Datei zu machen. In den einzelnen `prediction`-Objekten ist das Bild nur noch als Numpy-Array mit den Pixeldaten vorhanden, ohne einen Hinweis woher das ursprünglich mal kam.

Die Dokumentation ist da ein bisschen sehr oberflächlich. Man muss sich durch den Quelltext lesen was erwartet und zurückgegeben wird.

In `super_gradients.training.utils.media.image` gibt es eine `list_images_in_folder()`-Funktion, wenn man sich das nicht selbst schreiben will.

[Fredddd]

ok, das würde gehen...hatte schon vor alle Ordner mit Bildern abzuspeichern um nur die neuen die hinzukommen zu nehmen. damit könnte ich auch die Filenamen verwenden..

Ich habe das einmal bei chatgpt probiert mit YOLOV4, aber dann wollte ich es doch selbst machen .


Keine Gewaehr ob das ueberhaupt geht ..war nur ein Versuch:

Code: Alles auswählen

import cv2
import os
import shutil

def detect_and_rename(file_path, output_path, model_path):
    # Load YOLOv4 model
    net = cv2.dnn.readNetFromDarknet(model_path + "/yolov4.cfg", model_path + "/yolov4.weights")
    net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
    net.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)

    # Load COCO class names
    with open(model_path + "/coco.names", "r") as f:
        classes = [line.strip() for line in f.readlines()]

    # Get the list of files with detection already done
    detected_files = set()
    for root, _, files in os.walk(output_path):
        for file_name in files:
            if file_name.lower().startswith("detected_"):
                detected_files.add(file_name[9:])  # Remove the "detected_" prefix

    # Iterate through the files in the directory and its subdirectories
    for root, _, files in os.walk(file_path):
        for file_name in files:
            if file_name.lower().endswith(('.jpg', '.jpeg', '.png', '.bmp')) or file_name.lower().endswith(('.mp4', '.avi', '.mov')):
                file_full_path = os.path.join(root, file_name)

                # Check if the file has already been detected
                if file_name not in detected_files:
                    # Perform object detection
                    image = cv2.imread(file_full_path)
                    height, width = image.shape[:2]
                    blob = cv2.dnn.blobFromImage(image, 0.00392, (416, 416), swapRB=True, crop=False)
                    net.setInput(blob)
                    outs = net.forward(net.getUnconnectedOutLayersNames())

                    # Extract detections
                    class_ids = []
                    confidences = []
                    boxes = []
                    for out in outs:
                        for detection in out:
                            scores = detection[5:]
                            class_id = np.argmax(scores)
                            confidence = scores[class_id]
                            if confidence > 0.5:  # Threshold for confidence
                                center_x = int(detection[0] * width)
                                center_y = int(detection[1] * height)
                                w = int(detection[2] * width)
                                h = int(detection[3] * height)
                                x = int(center_x - w / 2)
                                y = int(center_y - h / 2)
                                class_ids.append(class_id)
                                confidences.append(float(confidence))
                                boxes.append([x, y, w, h])

                    # Apply non-maximum suppression to remove duplicate detections
                    indices = cv2.dnn.NMSBoxes(boxes, confidences, score_threshold=0.5, nms_threshold=0.4)

                    # Check if any of the detected objects are in the specified classes
                    detected_classes = [classes[class_ids[i]] for i in indices.flatten()]
                    if any(class_name in detected_classes for class_name in ['person', 'car', 'dog']):
                        # Rename the file
                        new_file_name = "detected_" + file_name
                        new_file_full_path = os.path.join(output_path, new_file_name)
                        shutil.move(file_full_path, new_file_full_path)
                        print(f"Detected objects in '{file_full_path}'. Renamed as '{new_file_full_path}'.")

    # Delete files with no detection
    for root, _, files in os.walk(file_path):
        for file_name in files:
            if file_name.lower().endswith(('.jpg', '.jpeg', '.png', '.bmp')) or file_name.lower().endswith(('.mp4', '.avi', '.mov')):
                file_full_path = os.path.join(root, file_name)
                detected_file_name = "detected_" + file_name
                detected_file_full_path = os.path.join(output_path, detected_file_name)
                if not os.path.exists(detected_file_full_path):
                    os.remove(file_full_path)
                    print(f"No detection in '{file_full_path}'. File deleted.")


if __name__ == "__main__":
    input_directory = "/path/to/input/directory"
    output_directory = "/path/to/output/directory"
    yolov4_model_directory = "/path/to/yolov4/model"

    detect_and_rename(input_directory, output_directory, yolov4_model_directory)

[Fredddd]

Hallo,
also mit YOLOv8 gibt es die Moeglichkeit den file namen und den Pfad einzugeben.
Es heisst wenn man den namen des files angibt und nicht nur den Pfad dann wird es auch unter diesem namen auch gespeichert.
jetzt ist die Frage ob man die Namen einlesen kann des ganzen Pfades in ein Array und es dann uebergeben.

Code: Alles auswählen

from ultralytics import YOLO

model = YOLO()
model(source='ultralytics/assets/bus.jpg', save=True, project='PROJECT', name='NAME')

Wuensche Euch ein schoenes Wochenende.

[__blackjack__]

@Fredddd: In ein Array macht nicht wirklich Sinn, aber mit einer Liste würde ich es einfach mal versuchen. Auch *die* Dokumentation ist da nicht so wirklich toll.

[Fredddd]

Hallo nochmal,
also so funktioniert das ....

Code: Alles auswählen

from super_gradients.common.object_names import Models
from super_gradients.training import models
import ntpath
import torch


device = torch.device("cpu")

model = models.get(Models.YOLO_NAS_L, pretrained_weights="coco")

IMAGES = [
    "/home/user1/Pictures/dogs.jpeg",
    "/home/user1/Pictures/home.jpg",
    "/home/user1/Pictures/terasse.png",]




images_predictions = model.predict(IMAGES, iou=0.5, conf=0.7)
#images_predictions = model.predict(MEDIA_PATH, conf=0.7)



for i, prediction in enumerate(images_predictions):
    image_output_path = ntpath.join("/home/user1/predictions/", f"{ntpath.basename(IMAGES[i])}")
    prediction.save(output_path=image_output_path)

dh. ich muss meine Ordner mit Bildern in eine Liste einlesen (file) und dann verarbeiten...

[Sirius3]

woher hast Du ntpath? Das ist nichtmal direkt in der Python-Dokumentation beschrieben.
Niemand verwendet das, weil man wenn schon dann os.path benutzt.
Zudem bist Du offensichtlich auf einem Posix-System, da ist ntpath falsch.
Ein f-String der nur dazu da ist einen String wieder in einen String zu verwandeln, ist unsinn.
Wie schonmal hier gesagt, benutzt man heutzutage pathlib.
Wenn man über zwei Listen gleichzeitig iterieren möchte, benutzt man keinen Index, sondern zip.

Code: Alles auswählen

from super_gradients.common.object_names import Models
from super_gradients.training import models
import torch
from pathlib import Path

IMAGE_PATH = Path.home() / "Pictures"
PREDICTIONS_PATH = Path.home() / "predictions"

IMAGES = [
    IMAGE_PATH / "dogs.jpeg",
    IMAGE_PATH / "home.jpg",
    IMAGE_PATH / "terasse.png",
]

def main():
    device = torch.device("cpu")
    model = models.get(Models.YOLO_NAS_L, pretrained_weights="coco")
    images_predictions = model.predict(IMAGES, iou=0.5, conf=0.7)
    for image, prediction in zip(IMAGES, images_predictions)
        image_output_path = PREDICTIONS_PATH / image.name
        prediction.save(output_path=image_output_path)

if __name__ == "__main__":
    main()

[Fredddd]

https://github.com/Deci-AI/super-gradie ... 1684863271

nachdem ich gefunden habe das es bei YOLOv8 geht dachte ich frag mal bei github nach.https://github.com/ultralytics/ultralytics/issues/3021

ich werde einfach ein files.txt file machen alle directories durchlaufen die files sammeln
dann einzeln aufrufen und durchlaufen lassen .
je nach gefundenen label abspeichern bzw.

wie gesagt ich bin ein schlechter Programmierer und muss mir so etwas zusammenstoppeln.

das mit dem zip habe ich hier gefunden.https://github.com/Deci-AI/super-gradie ... redictions..aber wie das genau bei meinem beispiel sein sollte..

habt ihr fuer linux einen einfachen python editor ? pycharm ist kompliziert

habe einfach viel auf einmal zu lernen..

[Fredddd]

wenn ich das richtig verstanden habe brauch ich gar kein files.txt sondern kann das mit pahtlib machen.

pathlib — Object-oriented filesystem paths, ja hab es schon vorher geschrieben...OO ist fuer mich schwer

[Fredddd]

Hi, also ich wollt euch teilhaben lassen...Dank super-gradients und chatgpt hab ich es geschafft.

es funktioniert soweit mal das ich es verwenden kann.

Code: Alles auswählen

from super_gradients.common.object_names import Models
from super_gradients.training import models
from pathlib import Path
import torch

device = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu")
model = models.get(Models.YOLO_NAS_L, pretrained_weights="coco").to(device)

def dummy_function(file_name, file_path, file_name_without_extension):
    # Replace this with your desired logic for processing the file details
    modified_name = file_name_without_extension
    print("Processing:", file_name)
    images_predictions = model.predict([str(file_path)], iou=0.5, conf=0.7)
    print("File Path:", file_path)
    print("File Name without Extension:", file_name_without_extension)
    print()
    has_labels = False  # Flag to check if any labels were found
    has_person_label = False  # Flag to check if "person" label was found
    for image_prediction in images_predictions:
        class_names = image_prediction.class_names
        labels = image_prediction.prediction.labels
        confidence = image_prediction.prediction.confidence
        bboxes = image_prediction.prediction.bboxes_xyxy

        for i, (label, conf, bbox) in enumerate(zip(labels, confidence, bboxes)):
            print("prediction: ", i)
            print("label_id: ", label)
            print("label_name: ", class_names[int(label)])
            print("confidence: ", conf)
            print("bbox: ", bbox)
            print("--" * 10)
            modified_name = modified_name + "_" + class_names[int(label)]
            has_labels = True  # Set the flag to True since labels were found
            if class_names[int(label)] == "person":
                has_person_label = True  # Set the "person" flag to True
    
    if has_labels:
        if has_person_label:
          #  person_output_path = file_path.parent / "person" / (modified_name + file_path.suffix)
            person_output_path = Path("/media/user1/201B-562B/detected") / "person" / (modified_name + file_path.suffix)
            image_prediction.save(output_path=person_output_path)
        else:
          #  image_output_path = file_path.parent / (modified_name + file_path.suffix)
            image_output_path = Path("/media/user1/201B-562B/detected") / (modified_name + file_path.suffix)
            image_prediction.save(output_path=image_output_path)

def process_files(directory_path):
    directory = Path(directory_path)
    
    if directory.is_dir():
        for file_path in directory.glob('*'):
            if file_path.is_file() and file_path.suffix.lower() in ['.jpg', '.jpeg', '.png']:
                file_name = file_path.name
                file_name_without_extension = file_path.stem
                dummy_function(file_name, file_path, file_name_without_extension)
            elif file_path.is_dir():
                process_files(file_path)
    else:
        print("Invalid directory path.")

if __name__ == "__main__":
    target_directory = input("Enter the target directory path: ")
    process_files(target_directory)

Danke nochmal !!

[Sirius3]

Warum wird an `dummy_function` (bescheuerter Name) file_path, file_name und file_name_without_extension übergeben, wo doch der Pfad ausreichen würde?
Wie `modified_name` modifiziert wird, ist total unübersichtlich. Warum gerade der Klassenname des zuletzt gefundenen Objekts?
`device` und `model` dürfen keine globalen Variablen sein, sondern müssen an dummy_function übergeben werden.
Der Ausgabepfad sollte nicht mitten im Code versteckt werden und dann auch nicht zweimal dort stehen.

In process_files würde man statt Rekursion rglob verwenden.

[Fredddd]

Hi,
also dummy_function , weil ich chatgpt erst nur den pfad auslesen habe lassen und iterieren dann mit print mir die Pfade, File Namen etc. angesehen habe.
Spaeter kam predict hinzu.

Dies soll ja fuer mich auch zum lernen sein.

Device und Model ist Global weil ich nicht wusste wo ich es hinschreiben sollte

Also ich bin kein Profi