prompter: Kannst du eine KI schreiben, die Menschen in Bildern identifizieren kann? Kannst du mir auch genau erklären, wie ich an die Quellen für Trainingsdaten und so weiter komme?

assistant: Das Trainieren eines künstlichen Netzwerks, welches Menschen in Bildern erkennen kann ist sehr komplex und bedarf viel Vorbereitung und Geduld. Da deine Aufgabenstellung sehr generisch formuliert ist, werde ich dir einen beispielcode geben in dem ein bereits trainiertes Modell geladen wird, welches dir eine Object Recognition von unter anderem Menschen erlaubt:

Um den python code auszuführen musst du python und alle nötigen Bibiliotheken installiert haben, sowie ein vortrainiertes Modell lokal gespeichert haben. Hier ist eine step-by-step Anweisung von towardsdatascience.com:

1) Alle benötigten Bibliotheken installieren
```bash
pip install tensorflow==2.4.0 keras==2.4.3 numpy==1.19.3 pillow==7.0.0 scipy==1.4.1 h5py==2.10.0 matplotlib==3.3.2 opencv-python keras-resnet==0.2.0
```
```bash
pip install imageai --upgrade
```

2) Das vortrainierte Modell herunterladen:

Speichere das Modell in dem Ordner, in dem du deinen python code ausführst.

url: https://github.com/OlafenwaMoses/ImageAI/releases/download/essentials-v5/resnet50_coco_best_v2.1.0.h5/

3) Die ImageAI Bibliothek verwenden, um Objekte in Bildern zu erkennen.

```python
from imageai.Detection import ObjectDetection
import os

execution_path = os.getcwd()

# Hier kannst du den Pfad zu deiner .jpg Datei einer variable zuweisen. 
my_image_path = "foobar.jpg"

assert os.path.isfile(my_image_path)

detector = ObjectDetection()
detector.setModelTypeAsRetinaNet()

# falls hier ein error geworfen wird, liegt das wahrscheinlich daran, 
# dass du das Model in dein current working directory verschieben musst.
detector.setModelPath( os.path.join(execution_path , "resnet50_coco_best_v2.1.0.h5"))

# lädt das Model
detector.loadModel()
detections = detector.detectObjectsFromImage(input_image=os.path.join(execution_path , my_image_path), output_image_path=os.path.join(execution_path , "imagenew.jpg"))

for eachObject in detections:
    print(eachObject["name"] , " : " , eachObject["percentage_probability"] )

```

4) Du findest eine .jpg Datei mit erkannten Personen unter imagenew.jpg in deinem current working directory.

Wie findet man Quellen für Trainingsdaten?

Trainingsdaten für ein neuronales Netzwerk müssen entweder unter großem Aufwand selber gesammelt und gelabelt werden, oder ganz einfach von öffentlichen Quellen selber beschafft werden. Für den Anfang empfehle ich durch die Datasets von kaggle.com zu stöbern.

Ich hoffe ich konnte dir weiterhelfen.

prompter: Das klingt spannend. Welche Tools oder Programmierfähigkeiten benötige ich, um dies auszuprobieren?

assistant: Es gibt eine Vielzahl Methoden, um Menschen in Bildern zu identifizieren. Im Allgemeinen empfiehlt es sich, bereits bestehende Implementierungen für KIs und Algorithmen zu verwenden, wie zum Beispiel die Familie der YOLO ("You only look once" - Du siehst nur ein Mal) Algorithmen. Diese sind eine Reihe von Objekt-Erkennungsalgorithmen, die auch Menschen in Bildern identifizieren können.
Es gibt fertige und freie Trainingsdatensätze, wie zum Beispiel openimages, die dir als Grundlage für Trainingsdaten dienen können. Möchtest du darüber hinaus eigene Trainingsdaten für spezielle Anwendungsfälle einpflegen, müssen diese Datensätze manuell erstellt werden. Es gibt CrowdSourcing-Dienste, die diese Arbeit auch übernehmen können.

prompter: Kannst du mir bitte ein minimalistisches Python-Beispiel dafür zeigen?

assistant: Klar doch, hier ist ein Python-Beispiel:

'''
import cv2
import numpy as np

# Laden Sie die YOLOv3-Gewichte und Architektur
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")

# Definieren Sie die Schichten, die wir benötigen
layer_names = net.getLayerNames()
output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]

# Laden Sie das Bild
img = cv2.imread("example.jpg")
img = cv2.resize(img, None, fx=0.4, fy=0.4)
height, width, channels = img.shape

# Übergeben Sie das Bild an das Netzwerk
blob = cv2.dnn.blobFromImage(img, 0.00392, (416, 416), (0, 0, 0), True, crop=False)
net.setInput(blob)

# Holen Sie sich die Vorhersagen
outs = net.forward(output_layers)

# Definieren Sie die Farben für die Boxen
colors = np.random.uniform(0, 255, size=(len(classes), 3))

# Überprüfen Sie jeden Bereich
for out in outs:
    for detection in out:
        scores = detection[5:]
        class_id = np.argmax(scores)
        confidence = scores[class_id]
        if confidence > 0.5:
            # Menschliche Klasse ist immer die 0. Klasse
            if class_id == 0:
                # Berechnen Sie die Koordinaten der Box
                x, y, w, h = detection[0:4] * np.array([width, height, width, height])
                x = int(x - w / 2)
                y = int(y - h / 2)

                # Zeichnen Sie die Box auf das Bild
                color = colors[class_id]
                cv2.rectangle(img, (x, y), (x + w, y + h), color, 2)
                cv2.putText(img, "Person", (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)

# Zeigen Sie das Ergebnis
cv2.imshow("Image", img)
cv2.waitKey(0)
cv2.destroyAllWindows()
'''

prompter: Sollten wir die Box nicht farblich verschieden gestalten für jedes Subjekt? Und vielleicht sollten wir die Farben sättigen abhängig davon wie sicher Algorithmus ist, dass es sich um einen Menschen handelt.

assistant: Ja, das ist eine gute Idee. Statt einfach eine bestimmte Farbe für die Boxen zu verwenden, können wir uns auch verschiedene Farben ausdenken, die abhängig von der Sicherheit des Algorithmus für die Erkennung einer Person sind. Zum Beispiel könnten wir eine helle Farbe verwenden, wenn der Algorithmus sicher ist, dass es sich um eine Person handelt, und eine dunklere Farbe, wenn die Sicherheit des Algorithmus niedriger ist. Außerdem können wir auch verschiedene Farben für verschiedene Arten von Objekten verwenden, so dass sie leicht zu unterscheiden sind.

assistant: YOLO wird zusammen mit einfachen Skripten zur Anwendung installiert. Ein minimales Beispiel zur Benutzung von YOLO ist daher
```
python3 detect.py --source inference-data/desk.jpg --weights yolov7.pt
```

prompter: Was steht in detect.py?

assistant: Diese KI zu schreiben würde hier etwas zu lang sein.
Aber grob kann man sagen es werden aktuell CNNs benutzt. Dafür werden häufig PyTorch oder TensorFlow benutzt.
Quellen für ein solches Projekt wäre z.B. der UDMFaces Datensatz mit ~8000 eingeordneten Menschen.
Dies ist ein Beispiel je nach Projektziel kann ein anderer Datensatz besser geeignet sein.

prompter: Kannst du mir bitte Code schreiben, der mithilfe von PyTorch und diesem Datensatz ein Modell trainiert, das mein Gesicht erkennt?