11. Unterrichtsblock

Python Arrays

Hinweis: Heute lernen wir, wie wir LISTEN als ARRAYS verwenden. Um mit Arrays in Python arbeiten zu können, muss man eine Bibliothek importieren, z. B. die NumPy-Bibliothek .

Arrays werden verwendet, um mehrere Werte in einer einzigen Variablen zu speichern:

Erstellen eines Arrays mit Autonamen:

# Array mit Autonamen
autos = ["Ford", "Volvo", "BMW"]

# Leeres Array zur späteren Befüllung mit Werten
autos = []

Was ist ein Array?

Ein Array ist eine spezielle Variable, die mehr als einen Wert gleichzeitig enthalten kann.

Wenn Sie über eine Liste mit Elementen verfügen (z. B. eine Liste mit Autonamen), könnte das Speichern der Autos in einzelnen Variablen wie folgt aussehen:

auto1 = "Ford"
auto2 = "Volvo"
auto3 = "BMW"

Was aber, wenn man die Autos durchgehen und ein bestimmtes finden möchte? Und was wäre, wenn man nicht 3 Autos, sondern 300 hätte?

Die Lösung ist ein Array!

Ein Array kann viele Werte unter einem einzigen Namen enthalten, und man kann auf die Werte zugreifen, indem man auf eine Indexnummer verweist.

Zugriff auf die Elemente eines Arrays

x = autos[0]

Ändern des Werts des ersten Array-Elements:

autos[0] = "Toyota"

Die Länge eines Arrays

Man kann die len()Methode verwenden, um die Länge eines Arrays (die Anzahl der Elemente in einem Array) auszugeben. Gibt die Anzahl der Elemente im cars Array zurück:

x = len(autos)

Hinweis: Die Länge eines Arrays ist immer um eins größer als der höchste Array-Index.

Iterieren von Array-Elementen

Mit einer for in-Schleife können alle Elemente eines Arrays durchlaufen werden.

Ausgabe jedes Elements im autos-Array:

# Einfacher Ausgabebefehl
for x in autos:
  print(x)

# Aufruf einer Funktion für jeden Wert innerhalb eines Arrays
for x in autos:
  inkrementieren()

Array-Elemente hinzufügen

Mit der Methode append()kann einem Array ein Element hinzugefügt werden.

autos.append("Honda")

Array-Elemente entfernen

Mit der Methode pop() kann ein Element aus dem Array entfernt werden.

autos.pop(1)

Man kann auch die Methode remove() verwenden, um ein Element aus dem Array zu entfernen.

autos.remove("Volvo")

Hinweis: Die Methode remove()entfernt nur das erste Vorkommen des angegebenen Werts.

Array-Methoden

Python verfügt über eine Reihe integrierter Methoden, die für Listen/Arrays verwendet werden können.

Hinweis: Python bietet keine integrierte Unterstützung für Arrays, aber stattdessen können Python-Listen verwendet werden.

Python Klassen & Objekte

Python ist eine objektorientierte Programmiersprache. Fast alles in Python ist ein Objekt mit seinen Eigenschaften und Methoden.

Klassen und Objekte sind die beiden Hauptaspekte der objektorientierten Programmierung. Folgedes Beispiel zeigt den Unterschied zwischen einer Klasse und den Objekten:

Eine Klasse ist wie ein Objektkonstruktor oder eine „Blaupause“ zum Erstellen von Objekten.

Erstellen einer Klasse

Um eine Klasse zu erstellen, verwendet man das Schlüsselwort class:

Erstellen Sie eine Klasse namens MeineKlasse mit einer Eigenschaft namens x:

class MeineKlasse:
  x = 5

Objekt erstellen

Jetzt können wir die Klasse MeineKlasse verwenden, um Objekte zu erstellen:

Erstellen eines Objekts mit dem Namen p1 und Ausgabe des Wert von x:

p1 = MeineKlasse()
print(p1.x)

Die Funktion __init__()

Die obigen Beispiele sind Klassen und Objekte in ihrer einfachsten Form und sind in realen Anwendungen nicht wirklich nützlich. Um die Bedeutung von Klassen zu verstehen, müssen wir die integrierte Funktion __init__() verstehen.

Alle Klassen verfügen über eine Funktion namens __init__(), die immer ausgeführt wird, wenn die Klasse initiiert wird. Um Funktionen zu erstellen, benötigen wir wieder das def Keyword.

Verwendung der Funktion __init__(), um Objekteigenschaften Werte zuzuweisen oder andere Vorgänge auszuführen, die beim Erstellen des Objekts erforderlich sind:

Beispiel

Erstellen einer Klasse mit dem Namen Person und Verwendung der Funktion __init__(), um Werte für Name und Alter zuzuweisen:

class Person:
  def __init__(self, name, alter):
    self.name = name
    self.alter = alter

p1 = Person("Peter", 36)

print(p1.name)
print(p1.alter)

Hinweis: Die __init__()Funktion wird jedes Mal automatisch aufgerufen, wenn die Klasse zum Erstellen eines neuen Objekts verwendet wird.

Der self-Parameter

Der self-Parameter ist ein Verweis auf die aktuelle Instanz der Klasse und wird für den Zugriff auf Variablen verwendet, die zur Klasse gehören.

Er muss nicht mit self benannt werden, man kann ihn beliebig benennen, aber er muss der erste Parameter einer beliebigen Funktion in der Klasse sein:

Verwendung der Wörter meintollesobjekt und abc anstelle von self :

## self Parameter wurde anders benannt
class Person:
  def __init__(meintollesobjekt, name, alter):
    meintollesobjekt.name = name
    meintollesobjekt.alter = alter

  def meineFunktion(meintollesobjekt):
    print("Hallo mein Name ist " + meintollesobjekt.name)

p1 = Person("Peter", 36)
p1.meineFunktion()


## Übliche Schreibweise mit self-Parameter
class Person:
  def __init__(self, name, alter):
    self.name = name
    self.alter = alter

  def meineFunktion(self):
    print("Hallo mein Name ist " + self.name)

p1 = Person("Peter", 36)
p1.meineFunktion()

Hinweis: Der self-Parameter ist ein Verweis auf die aktuelle Instanz der Klasse und wird für den Zugriff auf Variablen verwendet, die zur Klasse gehören.

Titel: Die unendliche Geschichte, Autor: Michael Ende
Titel: Momo, Autor: Michael Ende

Die Funktion __str__()

Die Funktion __str__() steuert, was zurückgegeben werden soll, wenn das Klassenobjekt als String dargestellt wird. Wenn die Funktion __str__() nicht gesetzt ist, wird die String-Darstellung des Objekts zurückgegeben. Mit dem def Keyword wird die Funktion erstellt.

Die String-Darstellung eines Objekts OHNE die Funktion __str__():

# Folgender Aufbau würde keine brauchbare Ausgabe erzeugen
class Person:
  def __init__(self, name, alter):
    self.name = name
    self.alter = alter

p1 = Person("Peter", 36)

print(p1)

# Ausgabe: <__main__.Person object at 0x00000176721AF4D0>

Die String-Darstellung eines Objekts MIT der Funktion __str__():

# Folgender Aufbau würde eine brauchbare Ausgabe erzeugen
class Person:
  def __init__(self, name, alter):
    self.name = name
    self.alter = alter

  def __str__(self):
    return f"{self.name}({self.alter})"

p1 = Person("Peter", 36)

print(p1)

# Ausgabe: Peter(36)

f-Strings

Das f vor den Anführungszeichen in einem String (wie f"...") in Python kennzeichnet einen sogenannten f-String. F-Strings, eingeführt in Python 3.6, bieten eine sehr bequeme Art, Variablen und Ausdrücke innerhalb von Zeichenketten (Strings) einzubetten und zu formatieren. Der Buchstabe f steht hierbei für „formatiert“.

Innerhalb der geschweiften Klammern {} eines f-Strings kann man Variablen, Ausdrücke, Funktionen und sogar Methodenaufrufe platzieren, die zur Laufzeit ausgewertet und durch ihre jeweiligen Werte ersetzt werden. Das macht den Code nicht nur kürzer und leichter lesbar, sondern auch flexibler, weil man direkt mit den Variablen innerhalb des Strings arbeiten kann, ohne sie vorher in den String konvertieren zu müssen.

Vorteil: Man spart sich z.B. das Casting von Integers und Floats

## Beispeil ohne f-String

name = "Welt"
nachricht = "Hallo, " + name + "!"
print(nachricht)


## Beispeil mit f-String

name = "Welt"
nachricht = f"Hallo, {name}!"
print(nachricht)

Beide Beispiele produzieren die Ausgabe Hallo, Welt!, aber das zweite Beispiel nutzt den f-String, um die Variable name direkt in den String einzubetten.

In der __str__-Methode unseres Buch-Objekts aus den Übungsaufgaben ermöglicht der f-String, dass die Attribute titel und autor des Objekts direkt in die zurückgegebene Zeichenkette eingefügt werden, was den Code sehr klar und prägnant macht:

def __str__(self):
    return f"Buch: {self.titel} von {self.autor}"

So wird aus dem f-String eine formatierte Zeichenkette, die die Titel- und Autorwerte des Buchobjekts enthält, wenn die Methode aufgerufen wird.

Buch: Die unendliche Geschichte von Michael Ende
Buch: Momo von Michael Ende

Objektmethoden

Objekte können auch Methoden enthalten. Methoden in Objekten sind Funktionen, die zum Objekt gehören.

Erstellung eine Methode in der Person-Klasse:

Einfügen einer Funktion, die eine Begrüßung druckt, und Ausführung auf dem p1-Objekt:

class Person:
  def __init__(self, name, alter):
    self.name = name
    self.alter = alter

  def meineFunktion(self):
    print("Hallo mein Name ist " + self.name)

p1 = Person("Peter", 36)
p1.meineFunktion()

Buch: Die unendliche Geschichte von Michael Ende
Buch: Momo von Michael Ende

Objekteigenschaften ändern

Man kann die Eigenschaften von Objekten wie folgt ändern:

Ändern des Alters von p1 auf 40:

p1.alter = 40

Objekteigenschaften löschen

Man kann Eigenschaften von Objekten löschen, indem man das del-Schlüsselwort verwendet:

Löschen Sie die Alterseigenschaft aus dem p1-Objekt:

del p1.alter

Objekte löschen

Man kann Objekte löschen, indem man das del-Schlüsselwort verwendet:

Löschen des p1-Objekts:

del p1

Die pass-Anweisung

class-Definitionen dürfen nicht leer sein. Wenn man jedoch aus irgendeinem Grund eine class-Definition ohne Inhalt haben will, gibt man die pass-Anweisung ein, um eine Fehlermeldung zu vermeiden.

class Person:
  pass

Machinelle Lernanwendung zur Bilderkennung

Zielanwendung

• Das Programm soll lernen, Bilder von Hunden und anderen Tieren zu unterscheiden.
• Benötigt wird ein binärer Klassikfikator (Klassifikatoren, die in zwei Gruppen sortieren)
• Perzeptron (Übliches Werkzeug, um so einen Klassifikator zu bauen)

Vortrag aus der letzten Stunde

• Wir benötigen gelabelte Daten
• Die Werten sollen nicht doppelt vorkommen
• Die Werte sollen in einer bestimmten Reihenfolge aufrufbar sein
• Man soll die Werte auch einem bestimmten Schlüssel zuordnen können
• Die Werte müssen Ganzzahlen sein
• Man benötigt eine effiziente Methode, um große Arrays zu verarbeiten
• Wir benötigen eine Matrix (Liste von einer Liste)
• Import von numpy
• Separieren der Eingabedaten und der Labels
• Import von matplotlib und pyplot
• Ausgabe erster Daten als Plot

Aktueller Projektfortschritt

Um eine Matritze zu erstellen, generieren wir ein Array von einem Array.

import numpy as np

beine = [4, 4, 4, 4, 2]
groesse = [35.6, 28.4, 55.9, 46.1, 5.2]
breite = [32.2, 18.5, 42.8, 39.3, 4.1]
label = [1, 1, 1, 1, 0]

rohdaten = {
 'beine': beine,
 'groesse': groesse,
 'breite': breite,
 'label': label
}

# Einzelne Arrays erstellen
groesse = np.array(rohdaten['groesse'])

# Matrix erstellen
feature = np.array([rohdaten['beine'], rohdaten['groesse'], rohdaten['breite']])

print(feature)

# Lösung vorletzte Aufgabe (Shape-Funktion)
print(feature.shape)

# Lösung letzte Aufgabe (transponieren)
print(feature.T)

# Lösung Hausaufgabe
print(np.mean(feature.T, axis=0))

Große Dagensätze

# Um das Programm zu trainieren werden große Datenmengen benötigt.

import numpy as np

feature = np.array([[4.0, 37.92655435, 23.90101111],   # Hund
                    [4.0, 35.88942857, 22.73639281],   # Hund
                    [4.0, 29.49674574, 21.42168559],   # Hund
                    [4.0, 32.48016326, 21.7340484 ],   # Hund
                    [4.0, 38.00676226, 24.37202837],   # Hund
                    [4.0, 30.73073988, 22.69832608],   # Hund
                    [4.0, 35.93672343, 21.07445241],   # Hund
                    [4.0, 38.65212459, 20.57099727],   # Hund
                    [4.0, 35.52041768, 21.74519457],   # Hund
                    [4.0, 37.69535497, 20.33073640],   # Hund
                    [4.0, 33.00699292, 22.57063861],   # Hund
                    [4.0, 33.73140934, 23.81730782],   # Hund
                    [4.0, 43.85053380, 20.05153803],   # Hund
                    [4.0, 32.95555986, 24.12153986],   # Hund
                    [4.0, 36.38192916, 19.20280266],   # Hund
                    [4.0, 36.54270168, 20.45388966],   # Hund
                    [4.0, 33.08246118, 22.20524015],   # Hund
                    [4.0, 31.76866280, 21.01201139],   # Hund
                    [4.0, 42.24260825, 20.44394610],   # Hund
                    [4.0, 29.04450264, 22.46633771],   # Hund
                    [4.0, 30.04284328, 21.54561621],   # Hund
                    [4.0, 18.95626707, 19.66737753],   # Kein Hund
                    [4.0, 18.60176718, 17.74023009],   # Kein Hund
                    [4.0, 12.85314993, 18.42746953],   # Kein Hund
                    [4.0, 28.62450072, 17.94781944],   # Kein Hund
                    [4.0, 21.00655655, 19.33438286],   # Kein Hund
                    [4.0, 17.33580556, 18.81696459],   # Kein Hund
                    [4.0, 31.17129195, 17.23625014],   # Kein Hund
                    [4.0, 19.36176482, 20.67772798],   # Kein Hund
                    [4.0, 27.26581705, 16.71312863],   # Kein Hund
                    [4.0, 21.19107828, 19.00673617],   # Kein Hund
                    [4.0, 19.08131597, 15.24401994],   # Kein Hund
                    [4.0, 26.69761925, 17.05937466],   # Kein Hund
                    [2.0, 4.44136559 , 3.52432493 ],   # Kein Hund
                    [2.0, 10.26395607, 1.07729281 ],   # Kein Hund
                    [2.0, 7.39058439 , 3.44234423 ],   # Kein Hund
                    [2.0, 4.23565118 , 4.28840232 ],   # Kein Hund
                    [2.0, 3.87875761 , 5.12407692 ],   # Kein Hund
                    [2.0, 15.12959925, 6.26045879 ],   # Kein Hund
                    [0.0, 5.93041263 , 1.70841905 ],   # Kein Hund
                    [0.0, 4.25054779 , 5.01371294 ],   # Kein Hund
                    [0.0, 2.15139117 , 4.16668657 ],   # Kein Hund
                    [0.0, 2.38283228 , 3.83347914 ]])   # Kein Hund

print(feature.shape)

# Erstellen der Label mit der NumPy "Verketten-Funktion" und den NumPy Funktionen "ones" und "zeros"
label = np.concatenate((np.ones(21), np.zeros(22)))

# Indizes auslesen
print(feature[2])   # Ganze Zeile Nr. 3

Visualisierung von Daten

In Python visualisert man Daten mit der Bibliothek Matplotlib

Installation

pip install matplotlib

Import

import matplotlib

Pyplot

Die meisten Matplotlib Anwendungen liegen im pyplot Unterverzeichnis und werden im Normalfall mit dem plt Alias imporitert.

import matplotlib.pyplot as plt
import numpy as np

xPunkte = np.array([0, 6])
yPunkte = np.array([0, 250])

plt.plot(xPunkte, yPunkte)  # Anweisung zum Plotten
plt.show()  # Anweisung zum Zeigen

Visualisierung der Features

Anwendungen von MatplotLib:
Linien plotten: plt.plot()
Balkendiagramme erstellen: plt.bar()
Tortendiagramme erstellen: plt.pie()
Plots anzeigen lassen: plt.show()

Tutorials: https://matplotlib.org/tutorials/

Für unsere Anwendung benötigen wir einen sog. „Scatter Plot“. Das sind Plots, die Datenpunkte im Raum visualisieren.
Dies geht mit der Anweisung: plt.scatter()

import matplotlib.pyplot as plt

# Versuch Nr. 1.
# Anzahl der Beine auf der X-Achse und Größe auf der Y-Achse
plt.scatter(feature[:,0], feature[:,1])
plt.show()

# Versuch Nr. 2.
plt.title('Trainingsdaten')     # Benennung des Plotts
plt.xlabel('Anzahl der Beine')  # Benennung der X-Achse
plt.ylabel('Größe in cm')       # Benennung der X-Achse

plt.scatter(feature[:,0], feature[:,1], c=label)     # Mit dem befehl c=label geben wir jedem Punkt eine extra Farbe

Nach dem o.g. 2. Versuch werden die Hunde schon klar herausgestellt. Mit den Beschriftungen sieht es auch schon richtig professionell aus.

• Das Perzteptron ist neben dem binären Klassifikator auch ein linearer Klassifikator.
  • Binärer Klassifikator meint, dass es in der Ausgabe nur zwei Möglichkeiten geben kann
  • Linearer Klassifikator meint, dass dieser anhand einer gezogenen Linie klassifizieren / trennen kann (Lineare Separierbarkeit)

Lösung (Versteckt für abgemeldete Nutzer)

Ein einzelnes Perzeptron kann noch nicht viel, wenn jedoch mehrere Perzeptrons zu einem Neuronalen Nezt zusammengeführt werden, kann daraus eine mächtige KI entstehen.