08.05.2024 KI Grundlagen
Streaming #2: KI verstehen & anwenden
KI Grundlagen
Im zweiten Stream widmen wir uns der facettenreichen Welt der Künstlichen Intelligenz. Interaktiv wird eine Mindmap erarbeitet, auf der wichtige Begriffe zum Verständnis und zur Einordnung von KI systematisch erklärt und visualisiert werden. Darüber hinaus sprechen wir über die vielfältigen Einsatzmöglichkeiten und die Bedeutung von KI, insbesondere in der medienpädagogischen Bildungs- und Jugendarbeit. Mit Hilfe der Hugging-Face-Community werden praktische und aktuell häufig genutzte KI-Tools vorgestellt und im Kontext von Nachhaltigkeit sowie Niederschwelligkeit diskutiert. Die gewonnen Erkenntnisse werden in der Mindmap festgehalten, die im Anschluss zur weiteren Nutzung zu Verfügung gestellt wird.
Streaming Folge:
https://video.notonlytesting.org/w/gH7mAxLZdA2MkpWcLj33vC
Musik
Text
Listensuchen
Video
Pädagogisch
- Are You You? Beat the face recognition algorithm!
- Say What You See by By Jack Wild, Artist In Residence at Google Arts & Culture Lab - Experiments with Google
Bild
- Ai Logo Maker - Generate your free logo online in minutes! - LogoAI.com
- Playground AI - free-to-use online AI image creator
- DALL·E 2 | OpenAI
- Midjourney
KI kurz erklärt
In den 1940er Jahren begannen Mathematiker und Ingenieure, die Grundlagen für die Künstliche Intelligenz (KI) zu legen. Einer der einflussreichsten Denker dieser Zeit war Alan Turing, ein britischer Mathematiker, der die Frage stellte, ob Maschinen denken können. Turing entwickelte den nach ihm benannten Turing-Test, um zu überprüfen, ob eine Maschine menschenähnliches Denken zeigen kann. 1956 fand am Dartmouth College in den USA eine Konferenz statt, die als Geburtsstunde der KI gilt. Wissenschaftler wie John McCarthy, Marvin Minsky und Claude Shannon diskutierten dort erstmals intensiv über die Idee, Maschinen zu bauen, die intelligentes Verhalten zeigen können. In den folgenden Jahren gab es einige Fortschritte, wie z.B. Schachprogramme und einfache Chatbots, doch die Erwartungen übertrafen oft die tatsächlichen Fähigkeiten der Programme. Dies führte zu Enttäuschungen und einem Rückgang der Finanzierung, einem Phänomen, das als "KI-Winter" bekannt wurde. Ab den 1980er Jahren erlebte die KI einen erneuten Aufschwung, vor allem durch verbesserte Computerhardware und neue Methoden wie maschinelles Lernen. Besonders seit den 2000er Jahren hat die Entwicklung von KI durch die Verfügbarkeit großer Datenmengen und leistungsfähigerer Computer stark an Fahrt gewonnen. Heute ist KI in vielen Bereichen des täglichen Lebens präsent: von Sprachassistenten wie Siri und Alexa über selbstfahrende Autos bis hin zu medizinischer Diagnostik und personalisierter Werbung. Die Technologie hat sich kontinuierlich weiterentwickelt und beeinflusst nun viele Aspekte unseres modernen Lebens.
Methoden des Maschinellen Lernen
Die Grundidee des Maschinellen Lernen besteht darin einem Computer nicht wie üblich Schritt für Schritt zu sagen, was er tun soll, sondern viele Daten zusammenstellen und dem Computer selbst Muster und Regeln erkennen lässt. Der Computer bekommt so viele Beispiele. Zum Beispiel, wenn der Computer lernen soll, Katzen auf Bildern zu erkennen, zeigen wir ihm Tausende von Bildern, auf denen Katzen zu sehen sind, und auch Bilder ohne Katzen. Der Computer analysiert diese Bilder und sucht nach gemeinsamen Merkmalen, die typisch für Katzen sind, wie Formen, Farben und Texturen. Maschinelles Lernen bedeutet, dass Computer aus vielen Beispielen lernen, um Aufgaben besser zu erledigen, anstatt dass wir ihnen jede einzelne Regel vorschreiben.
Das Grundprinzip
Supervised Learning (Überwachtes Lernen)
Idee |
Der Computer lernt aus Beispielen, bei denen die richtigen Antworten bereits bekannt sind. |
Funktion |
Wir geben dem Computer viele Beispiele mit den richtigen Antworten. Zum Beispiel: Bilder von Hunden und Katzen, bei denen jedes Bild beschriftet ist (Hund oder Katze). Der Computer lernt, diese Beispiele zu analysieren und Regeln zu entwickeln, um neue, unbekannte Bilder richtig zu erkennen. |
Beispiel |
Wenn du dem Computer 100 Bilder von Hunden und Katzen zeigst und ihm sagst, welche Bilder Hunde und welche Katzen sind, kann er lernen, neue Bilder zu identifizieren. |
Zusammenfassung |
Supervised Learning: Lernen mit bekannten Antworten. |
import tensorflow as tf
from tensorflow.keras import layers
# Daten laden
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Daten normalisieren
x_train, x_test = x_train / 255.0, x_test / 255.0
# Modell aufbauen
model = tf.keras.models.Sequential([
layers.Flatten(input_shape=(28, 28)), # Eingabeschicht, die die Bilder flach drückt
layers.Dense(128, activation='relu'), # Dicht verbundene Schicht mit 128 Neuronen
layers.Dropout(0.2), # Dropout-Schicht zur Reduzierung von Overfitting
layers.Dense(10, activation='softmax') # Ausgabeschicht mit 10 Neuronen für 10 Klassen
])
# Modell konfigurieren
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# Modell trainieren
model.fit(x_train, y_train, epochs=5, validation_split=0.1)
# Modell evaluieren
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Test Accuracy: {test_acc:.4f}')
Unsupervised Learning (Unüberwachtes Lernen)
Idee |
Der Computer bekommt Daten ohne die richtigen Antworten und muss selbst Muster oder Gruppen finden. |
Funktion |
Der Computer analysiert die Daten und sucht nach Gemeinsamkeiten oder Gruppen, ohne dass wir ihm sagen, was er suchen soll. Er findet beispielsweise heraus, dass bestimmte Bilder ähnlich sind und bildet daraus Gruppen. |
Beispiel |
Wenn du dem Computer viele Bilder gibst, ohne zu sagen, ob es Hunde oder Katzen sind, wird er versuchen, die Bilder in Gruppen zu sortieren, die sich ähneln, z.B. eine Gruppe mit Hunden und eine Gruppe mit Katzen. |
Zusammenfassung |
Unsupervised Learning: Finden von Mustern ohne bekannte Antworten. |
from sklearn.cluster import KMeans
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
# Daten laden
data = load_iris()
X = data.data
# Daten standardisieren
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# KMeans Modell erstellen
kmeans = KMeans(n_clusters=3, random_state=0) # 3 Cluster, entspricht der Anzahl der Iris-Arten
# Modell auf Daten anwenden
kmeans.fit(X_scaled)
# Cluster-Zentren und Labels
centers = kmeans.cluster_centers_
labels = kmeans.labels_
# Ergebnisse visualisieren
plt.figure(figsize=(10, 6))
colors = ['red', 'green', 'blue']
for i in range(3):
plt.scatter(X_scaled[labels == i, 0], X_scaled[labels == i, 1], color=colors[i], label=f'Cluster {i+1}')
plt.scatter(centers[:, 0], centers[:, 1], s=100, color='yellow', label='Centroids', edgecolors='black')
plt.title('KMeans Clustering of Iris Dataset')
plt.xlabel('Sepal Length (standardized)')
plt.ylabel('Sepal Width (standardized)')
plt.legend()
plt.show()
Reinforcement Learning (Bestärkendes Lernen)
Idee |
Der Computer lernt durch Ausprobieren und Belohnung oder Bestrafung. |
Funktion |
Der Computer führt Aktionen aus und erhält Feedback, ob diese gut oder schlecht waren. Er versucht, Belohnungen zu maximieren und Bestrafungen zu minimieren, indem er aus seinen Erfahrungen lernt. |
Beispiel |
Stell dir ein Computerspiel vor. Der Computer versucht, das Spiel zu spielen und erhält Punkte (Belohnung) für gute Züge und verliert Punkte (Bestrafung) für schlechte Züge. Mit der Zeit lernt er, wie man das Spiel am besten spielt. |
Zusammenfassung |
Reinforcement Learning: Lernen durch Ausprobieren und Feedback. |
import gym
import numpy as np
# Umgebung erstellen
env = gym.make('CartPole-v1')
# Q-Tabelle initialisieren
Q = np.zeros([env.observation_space.shape[0], env.action_space.n])
# Lernparameter
learning_rate = 0.8
discount_factor = 0.95
episodes = 1000
# Funktion zur Wahl der Aktion
def choose_action(state):
action = np.argmax(Q[state, :] + np.random.randn(1, env.action_space.n) * (1. / (i + 1)))
return action
# Training des Modells
for i in range(episodes):
state = env.reset()
done = False
while not done:
action = choose_action(state)
new_state, reward, done, info = env.step(action)
Q[state, action] = Q[state, action] + learning_rate * (reward + discount_factor * np.max(Q[new_state, :]) - Q[state, action])
state = new_state
# Modell evaluieren
rewards = []
for _ in range(100):
state = env.reset()
total_reward = 0
for _ in range(200):
action = np.argmax(Q[state, :])
state, reward, done, _ = env.step(action)
total_reward += reward
if done:
break
rewards.append(total_reward)
print(f'Durchschnittliche Belohnung nach dem Training: {np.mean(rewards)}')
# Umgebung schließen
env.close()