Lerninhalte finden
Schule 
Studium 
Ausbildung Features
Karteikarten 
StudySmarter AI 
Notizen 
Lernplan 
Spaced Repetition 
Lernsets Entdecke
Lerninhalte finden
Features
Entdecke
© StudySmarter 2024, all rights reserved.
Du arbeitest als Softwareentwickler in der Bildverarbeitung. Das Unternehmen, für das Du arbeitest, entwickelt eine Anwendung, die digitale Bilder analysiert und verarbeitet. Deine Aufgabe ist es, sicherzustellen, dass die Anwendung Bilder korrekt darstellt, verarbeitet und verschiedene Bildformate unterstützt. Die Anwendung muss auch in der Lage sein, Bilder zu filtern und Bildmetadaten zu verarbeiten. Bei der Implementierung dieser Funktionen stößt Du auf verschiedene Begriffe und Technologien der digitalen Bilddarstellung, die Du verstehen und korrekt anwenden musst.
Beschreibe die verschiedenen Farbräume (RGB, CMYK, YUV). Erkläre, in welchen Anwendungen sie bevorzugt verwendet werden und warum.
Lösung:
Ein Bild hat eine Auflösung von 1920x1080 Pixeln und eine Farbtiefe von 24 Bit. Berechne die ungefähre Speichergröße dieses Bildes in Megabyte (MB). Ermittle auch die Größe nach Anwendung einer verlustfreien PNG-Kompression, wenn die Kompression ein Verhältnis von 3:1 ergibt.
Lösung:
Die Implementierung von Filtern und Transformationen ist ein wesentlicher Teil Deines Projekts. Erläutere, wie die Fourier-Transformation in der Bildverarbeitung verwendet wird, und gib ein Beispiel, wie sie auf ein Bild angewendet wird.
Lösung:
Finde einen Job 
Ausbildungen 
Magazine 
Mobile App 
Für Unternehmen import numpy as np import cv2 import matplotlib.pyplot as plt # Bild laden und in Graustufen umwandeln image = cv2.imread('image_path.jpg', cv2.IMREAD_GRAYSCALE) # Fourier-Transformation durchführen f = np.fft.fft2(image) fshift = np.fft.fftshift(f) # Magnitudenspektrum berechnen magnitude_spectrum = 20*np.log(np.abs(fshift)) # Magnitudenspektrum anzeigen plt.subplot(121),plt.imshow(image, cmap = 'gray') plt.title('Original Bild'), plt.xticks([]), plt.yticks([]) plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray') plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([]) plt.show() # Frequenzbereich filtern (z.B. Tiefpassfilter) rows, cols = image.shape crow, ccol = rows // 2 , cols // 2 fshift[crow-30:crow+30, ccol-30:ccol+30] = 0 # Inverse Fourier-Transformation f_ishift = np.fft.ifftshift(fshift) img_back = np.fft.ifft2(f_ishift) img_back = np.abs(img_back) # Ergebnis anzeigen plt.subplot(121),plt.imshow(image, cmap = 'gray') plt.title('Original Bild'), plt.xticks([]), plt.yticks([]) plt.subplot(122),plt.imshow(img_back, cmap = 'gray') plt.title('Gefiltertes Bild'), plt.xticks([]), plt.yticks([]) plt.show() Bildmetadaten enthalten wichtige Informationen über ein Bild. Ein Kunde fragt, wie die EXIF-Daten aus einem JPEG-Bild gelesen und verarbeitet werden können. Welche Informationen können aus EXIF-Daten extrahiert werden, und gib ein Beispiel in Python, wie man EXIF-Daten aus einem Bild liest.
Lösung:
Pillow (eine Erweiterung von PIL - Python Imaging Library) können EXIF-Daten aus einem Bild gelesen werden. from PIL import Image from PIL.ExifTags import TAGS, GPSTAGS def get_exif_data(image_path): # Bild öffnen image = Image.open(image_path) # EXIF-Daten extrahieren exif_data = image._getexif() # EXIF-Daten in einem lesbaren Format speichern exif_dict = {} if exif_data is not None: for tag, value in exif_data.items(): tag_name = TAGS.get(tag, tag) exif_dict[tag_name] = value return exif_dict # Pfad zum Bild image_path = 'dein_bild.jpg' # EXIF-Daten abrufen exif_info = get_exif_data(image_path) # EXIF-Daten anzeigen for tag, value in exif_info.items(): print(f'{tag}: {value}') _getexif() extrahiert die EXIF-Daten aus dem Bild.TAGS-Konstanten in lesbare Strings umgewandelt.In der Bildverarbeitung spielen Bildvorverarbeitungsmethoden eine entscheidende Rolle bei der Verbesserung und Vorbereitung von Bildern für weitere Analysen. Dabei werden Techniken wie Filterung und Normalisierung angewendet.
Beschreibe den Unterschied zwischen Tiefpassfilter und Hochpassfilter. Gib an, in welchen Situationen jeder dieser Filter bevorzugt angewendet wird.
Lösung:
Ein Grundverständnis der Filterung in der Bildverarbeitung ist entscheidend, um die Unterschiede zwischen Tiefpassfilter und Hochpassfilter zu erkennen und zu verstehen, wann jeder Filter angewendet werden sollte.
Der mathematische Hintergrund eines Tiefpassfilters kann beispielsweise durch die Faltung des Bildes mit einem Glättungskern beschrieben werden. Ein üblicher Glättungskern könnte so aussehen:
\[ F'(x, y) = \frac{1}{9} \begin{bmatrix} 1 & 1 & 1 \ 1 & 1 & 1 \ 1 & 1 & 1 \end{bmatrix} \times F(x, y) \] Der mathematische Hintergrund eines Hochpassfilters kann durch die Faltung des Bildes mit einem Kantenverstärkungskern dargestellt werden. Ein üblicher Kantenverstärkungskern könnte so aussehen:
\[ F'(x, y) = \begin{bmatrix} -1 & -1 & -1 \ -1 & 8 & -1 \ -1 & -1 & -1 \end{bmatrix} \times F(x, y) \] Anwendung:
Erkläre den Medianfilter und wie er zur Rauschreduzierung in Bildern beiträgt. Implementiere eine einfache Python-Funktion, die einen Medianfilter auf ein 2D-Bild anwendet.
def median_filter(image, filter_size): # Dein Code hier
Lösung:
Der Medianfilter ist eine nichtlineare digitale Filtertechnik, die verwendet wird, um Rauschen aus Bildern zu entfernen. Im Gegensatz zu linearen Filtern, die den Mittelwert der Pixelwerte im Filterfenster berechnen, ersetzt ein Medianfilter jeden Pixelwert in einem Bild durch den Median der Pixelwerte in seinem Nachbarschaftsfenster. Dadurch werden Extremwerte, die typischerweise durch Rauschen verursacht werden, effektiver entfernt, während die Kanten im Bild besser erhalten bleiben.
Funktionsweise des Medianfilters:
import numpy as npdef median_filter(image, filter_size): # Bilddimensionen auslesen m, n = image.shape # Pad die Ränder des Bildes pad_size = filter_size // 2 padded_image = np.pad(image, pad_size, mode='edge') # Ergebnisbild initialisieren filtered_image = np.zeros_like(image) # Medianfilter anwenden for i in range(m): for j in range(n): # Extrahiere das aktuelle Filterfenster window = padded_image[i:i+filter_size, j:j+filter_size] # Berechne den Median im Fenster median_value = np.median(window) # Setze den Medianwert in das Ergebnisbild filtered_image[i, j] = median_value return filtered_image
In der Vorlesung Computational Visual Perception hast Du gelernt, wie Bilddaten für maschinelle Lernmodelle vorbereitet werden. Ein entscheidender Schritt in diesem Prozess ist die Feature-Extraktion und -Selektion. Du wirst gebeten, verschiedene Techniken zur Feature-Extraktion zu erklären und deren Anwendung zu demonstrieren. Außerdem wirst Du Methoden zur Feature-Selektion anwenden, um die Relevanz der extrahierten Merkmale zu evaluieren und nur die wichtigsten Merkmale für Dein Modell zu wählen. Nutze hierfür die Algorithmen und mathematischen Konzepte aus der Vorlesung.
Erkläre die Feature-Extraktionstechniken SIFT und HOG. Gehe auf die grundlegenden Prinzipien ein und beschreibe, wie sie jeweils Bildmerkmale extrahieren. Führe zudem die Unterschiede zwischen diesen beiden Techniken aus.
Lösung:
Erklärung der Feature-Extraktionstechniken SIFT und HOGIm Folgenden werden die Feature-Extraktionstechniken SIFT und HOG erläutert. Dabei gehe ich auf die grundlegenden Prinzipien und die Extraktion von Bildmerkmalen ein und beschreibe die Unterschiede zwischen diesen Techniken.
Schreibe in Python ein kurzes Beispielskript, das den SIFT-Algorithmus zur Feature-Extraktion verwendet. Lade ein Bild, wende den SIFT-Algorithmus an und visualisiere die extrahierten Merkmale.
import cv2import matplotlib.pyplot as plt# Laden eines Beispielsbildesdef img = cv2.imread('example.jpg')# Konvertiere das Bild in Graustufengray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)# Initialisiere den SIFT-Detektorsift = cv2.SIFT_create()# Extrahiere die Schlüsselmerkmale und Deskriptorenkeypoints, descriptors = sift.detectAndCompute(gray, None)# Zeichne die Schlüsselmerkmale auf dem Bildimg_with_keypoints = cv2.drawKeypoints(gray, keypoints, img)# Visualisiere das Ergebnisplt.imshow(img_with_keypoints)plt.show() Lösung:
Hier ist ein kurzes Beispielskript in Python, das den SIFT-Algorithmus zur Feature-Extraktion verwendet. Das Skript lädt ein Bild, wendet den SIFT-Algorithmus an und visualisiert die extrahierten Merkmale.
import cv2import matplotlib.pyplot as plt# Laden eines Beispielsbildesimg = cv2.imread('example.jpg')# Konvertiere das Bild in Graustufengray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)# Initialisiere den SIFT-Detektorsift = cv2.SIFT_create()# Extrahiere die Schlüsselmerkmale und Deskriptorenkeypoints, descriptors = sift.detectAndCompute(gray, None)# Zeichne die Schlüsselmerkmale auf dem Bildimg_with_keypoints = cv2.drawKeypoints(gray, keypoints, img)# Visualisiere das Ergebnisplt.imshow(cv2.cvtColor(img_with_keypoints, cv2.COLOR_BGR2RGB))plt.show()Erklärung des Skripts:Du hast eine Bilddatenbank mit zahlreichen Features. Verwende die Chi-Quadrat Feature-Selektion, um die wichtigsten Features auszuwählen.
from sklearn.feature_selection import SelectKBest, chi2import pandas as pd# Beispieldatensatz ladendata = pd.read_csv('data.csv')X = data.drop('target', axis=1)y = data['target']# Chi-Quadrat Feature-Selektionchi2_selector = SelectKBest(chi2, k=5)X_kbest = chi2_selector.fit_transform(X, y)# Ausgabe der ausgewählten Featuresselected_features = X.columns[chi2_selector.get_support()]print('Ausgewählte Features:', selected_features) Lösung:
Mathematische Grundlage der Chi-Quadrat Feature-SelektionDie Chi-Quadrat Feature-Selektion ist eine statistische Methode, um die Relevanz von Features (Merkmalen) zu bestimmen. Sie basiert auf dem Chi-Quadrat-Test, der prüft, ob eine signifikante Assoziation zwischen den unabhängigen Variablen (Features) und der abhängigen Variablen (Target) besteht. Die grundlegenden Schritte sind:
import pandas as pd from sklearn.feature_selection import SelectKBest, chi2# Beispieldatensatz laden data = pd.read_csv('data.csv') X = data.drop('target', axis=1) y = data['target']# Chi-Quadrat Feature-Selektion chi2_selector = SelectKBest(chi2, k=5) X_kbest = chi2_selector.fit_transform(X, y)# Ausgabe der ausgewählten Features selected_features = X.columns[chi2_selector.get_support()] print('Ausgewählte Features:', selected_features) Erklärung des Codes:Integriere die ausgewählten Features in ein maschinelles Lernmodell und evaluiere seine Leistung. Schreibe einen Python-Code, der die gewählten Features für ein logistisches Regressionsmodell verwendet. Vergleiche die Modellleistung mit einem Modell, das alle Features nutzt.
from sklearn.linear_model import LogisticRegressionfrom sklearn.metrics import accuracy_score, precision_score, recall_score, f1_scorefrom sklearn.model_selection import train_test_split# Aufteilen der Daten in Trainings- und TestdatensatzX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)# Modell mit allen Features trainierenmodel_all = LogisticRegression()model_all.fit(X_train, y_train)# Modell mit ausgewählten Features trainierenX_train_selected = chi2_selector.transform(X_train)X_test_selected = chi2_selector.transform(X_test)model_selected = LogisticRegression()model_selected.fit(X_train_selected, y_train)# Vorhersagen macheny_pred_all = model_all.predict(X_test)y_pred_selected = model_selected.predict(X_test_selected)# Evaluationsmetriken berechnenmetrics_all = { 'accuracy': accuracy_score(y_test, y_pred_all), 'precision': precision_score(y_test, y_pred_all, average='macro'), 'recall': recall_score(y_test, y_pred_all, average='macro'), 'f1': f1_score(y_test, y_pred_all, average='macro')}metrics_selected = { 'accuracy': accuracy_score(y_test, y_pred_selected), 'precision': precision_score(y_test, y_pred_selected, average='macro'), 'recall': recall_score(y_test, y_pred_selected, average='macro'), 'f1': f1_score(y_test, y_pred_selected, average='macro')}# Ausgabe der Ergebnisseprint('Metriken mit allen Features:', metrics_all)print('Metriken mit ausgewählten Features:', metrics_selected) Lösung:
Um die ausgewählten Features in ein maschinelles Lernmodell zu integrieren und dessen Leistung zu evaluieren, führen wir einen Vergleich zwischen einem Modell, das alle Features nutzt, und einem Modell, das nur die ausgewählten Features nutzt. Hier ist der vollständige Python-Code zur Durchführung des Experiments:
import pandas as pdfrom sklearn.feature_selection import SelectKBest, chi2from sklearn.linear_model import LogisticRegressionfrom sklearn.metrics import accuracy_score, precision_score, recall_score, f1_scorefrom sklearn.model_selection import train_test_split# Beispieldatensatz ladendata = pd.read_csv('data.csv')X = data.drop('target', axis=1)y = data['target']# Chi-Quadrat Feature-Selektionchi2_selector = SelectKBest(chi2, k=5)X_kbest = chi2_selector.fit_transform(X, y)# Aufteilen der Daten in Trainings- und TestdatensatzX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)# Modell mit allen Features trainierenmodel_all = LogisticRegression()model_all.fit(X_train, y_train)# Modell mit ausgewählten Features trainierenX_train_selected = chi2_selector.transform(X_train)X_test_selected = chi2_selector.transform(X_test)model_selected = LogisticRegression()model_selected.fit(X_train_selected, y_train)# Vorhersagen macheny_pred_all = model_all.predict(X_test)y_pred_selected = model_selected.predict(X_test_selected)# Evaluationsmetriken berechnenmetrics_all = { 'accuracy': accuracy_score(y_test, y_pred_all), 'precision': precision_score(y_test, y_pred_all, average='macro'), 'recall': recall_score(y_test, y_pred_all, average='macro'), 'f1': f1_score(y_test, y_pred_all, average='macro')}metrics_selected = { 'accuracy': accuracy_score(y_test, y_pred_selected), 'precision': precision_score(y_test, y_pred_selected, average='macro'), 'recall': recall_score(y_test, y_pred_selected, average='macro'), 'f1': f1_score(y_test, y_pred_selected, average='macro')}# Ausgabe der Ergebnisseprint('Metriken mit allen Features:', metrics_all)print('Metriken mit ausgewählten Features:', metrics_selected)Erklärung des Codes:
In der Vorlesung 'Computational Visual Perception' hast Du verschiedene Klassifikationsmethoden wie k-Nearest Neighbors (k-NN), Support Vector Machines (SVM) und neuronale Netze (NN) kennengelernt. Diese Methoden sind wesentlich zur Lösung von Klassifikationsaufgaben in der computergestützten visuellen Wahrnehmung. In der folgenden Aufgabe sollst Du dein Wissen über diese Methoden anwenden und vertiefen.
(a) k-Nearest Neighbors: Angenommen Du hast einen Datensatz mit 2D-Merkmalen \((x_1, y_1), (x_2, y_2), ..., (x_n, y_n)\) und dazugehörigen Klassenlabels \(c_1, c_2, ..., c_n\). Beschreibe die Schritte, die nötig sind, um einen neuen Punkt \(x_{new}, y_{new}\) mit k-NN zu klassifizieren. Gehe dabei insbesondere auf die Wahl von k und die möglichen Probleme, die bei einer sehr kleinen bzw. sehr großen Wahl von k auftreten, ein.
Lösung:
(a) k-Nearest Neighbors: Um einen neuen Punkt \(x_{new}, y_{new}\) mit k-Nearest Neighbors (k-NN) zu klassifizieren, gehe wie folgt vor:
\[ d((x_i, y_i), (x_j, y_j)) = \sqrt{(x_i - x_j)^2 + (y_i - y_j)^2} \]
Wahl von k:
(b) Support Vector Machines: Erläutere den 'Kernel-Trick' in Support Vector Machines. Gehe darauf ein, warum dieser Trick nützlich ist und wie er die Klassifikation erleichtert. Zeige anhand eines Beispiels, wie der Kernel-Trick angewendet wird und wie sich dadurch die Berechnung der Trennlinie verändert. Verwende dafür den Polynomkernel \(K(x_i, x_j) = (x_i^T x_j + 1)^d\).
Lösung:
(b) Support Vector Machines: Der 'Kernel-Trick' in Support Vector Machines (SVM) ist ein mathematisches Verfahren, um die Berechnung von inneren Produkten in einem höherdimensionalen Raum zu ermöglichen, ohne die Punkte tatsächlich in diesen Raum zu transformieren. Dies ist besonders nützlich, weil es die Rechenkomplexität reduziert und dennoch ermöglicht, nichtlineare Trennlinien zu finden.
Nützlichkeit des Kernel-Tricks:
Beispiel des Kernel-Tricks mit Polynomkernel:
Betrachten wir einen Polynomkernel der Form:
\[K(x_i, x_j) = (x_i^T x_j + 1)^d\]
Hier steht \(x_i^T x_j\) für das innere Produkt der Vektoren \(x_i\) und \(x_j\), und \(d\) ist der Grad des Polynoms.
Anwendung des Polynomkernels:
Stell Dir vor, wir haben zwei Datenpunkte \(x_1 = [1, 2]\) und \(x_2 = [3, 4]\). Das innere Produkt \(x_1^T x_2\) ist:
\[x_1^T x_2 = 1 \times 3 + 2 \times 4 = 3 + 8 = 11\]
Wenn wir nun den Polynomkernel mit \(d = 2\) anwenden, erhalten wir:
\[K(x_1, x_2) = (11 + 1)^2 = 12^2 = 144\]
Veränderung der Berechnung der Trennlinie:
Durch den Kernel-Trick müssen wir die Punkte nicht explizit in einen höherdimensionalen Raum transformieren. Stattdessen arbeiten wir direkt mit den Kernelwerten, die effektiv die inneren Produkte im höherdimensionalen Raum darstellen.
In praktischen SVM-Berechnungen würde die Trennlinie in der Form \(w^T \tilde{x} + b = 0\) gefunden werden, wobei \(\tilde{x}\) die höherdimensional transformierten Datenpunkte repräsentiert. Die Koeffizienten \(w\) und \(b\) werden durch Optimierung über die Kernelmatrix berechnet, ohne die Transformation explizit durchzuführen.
(c) Neuronale Netze: Ein einfaches neuronales Netz besteht aus einer Input-Schicht, einer versteckten Schicht mit nichtlinearer Aktivierungsfunktion und einer Output-Schicht. Gegeben sei ein neuronales Netz mit einer Input-Schicht aus 3 Neuronen, einer versteckten Schicht mit 4 Neuronen und einer Output-Schicht mit 2 Neuronen. Zeichne dieses Netz und erkläre die Vorwärtspropagation in diesem Netz. Formuliere die mathematischen Gleichungen, die die Berechnungen in jeder Schicht beschreiben. Verwende dabei die Sigmoid-Aktivierungsfunktion \( \text{sigmoid}(z) = \frac{1}{1+e^{-z}} \).
Lösung:
(c) Neuronale Netze: Ein einfaches neuronales Netz besteht aus einer Input-Schicht, einer versteckten Schicht mit nichtlinearer Aktivierungsfunktion und einer Output-Schicht. Gegeben sei ein neuronales Netz mit einer Input-Schicht aus 3 Neuronen, einer versteckten Schicht mit 4 Neuronen und einer Output-Schicht mit 2 Neuronen.
Zeichnung des Netzwerks:
Vorwärtspropagation: In der Vorwärtspropagation werden die Eingabedaten durch das Netzwerk von der Input-Schicht zur Output-Schicht propagiert. Hier sind die Berechnungen in jeder Schicht beschrieben.
1. Input-Schicht zu versteckter Schicht:
Seien die Eingaben \(x_1, x_2, x_3\). Die Gewichte zwischen Input- und versteckter Schicht werden als Matrix \(W_{1} \) und die Biases als Vektor \(b_{1} \) dargestellt. Die Berechnungen der Aktivierungen \(a_{1}^1, a_{1}^2, a_{1}^3, a_{1}^4\) in der versteckten Schicht sind wie folgt:
Linearer Schritt:
\[ z_{1} = W_{1} \begin{pmatrix} x_1 \ x_2 \ x_3 \ \end{pmatrix} + b_{1}\]
\[ z_{1} = \begin{pmatrix} z_{1}^1 \ z_{1}^2 \ z_{1}^3 \ z_{1}^4 \ \end{pmatrix} = \begin{pmatrix} w_{11}^1 & w_{12}^1 & w_{13}^1 \ w_{21}^1 & w_{22}^1 & w_{23}^1 \ w_{31}^1 & w_{32}^1 & w_{33}^1 \ w_{41}^1 & w_{42}^1 & w_{43}^1 \ \end{pmatrix} \begin{pmatrix} x_1 \ x_2 \ x_3 \ \end{pmatrix} + \begin{pmatrix} b_{1}^1 \ b_{1}^2 \ b_{1}^3 \ b_{1}^4 \ \end{pmatrix}\]
Nichtlinearer Schritt (Sigmoid-Aktivierungsfunktion):
\[ a_{1} = \text{sigmoid}(z_{1}) = \begin{pmatrix} a_{1}^1 \ a_{1}^2 \ a_{1}^3 \ a_{1}^4 \ \end{pmatrix} = \begin{pmatrix} \frac{1}{1+e^{-z_1^1}} \ \frac{1}{1+e^{-z_1^2}} \ \frac{1}{1+e^{-z_1^3}} \ \frac{1}{1+e^{-z_1^4}} \ \end{pmatrix}\]
2. Versteckte Schicht zu Output-Schicht:
Die Gewichte zwischen der versteckten und der Output-Schicht werden als Matrix \(W_{2}\) und die Biases als Vektor \(b_{2}\) dargestellt. Die Berechnungen der Ausgaben \(a_{2}^1, a_{2}^2\) in der Output-Schicht sind wie folgt:
Linearer Schritt:
\[ z_{2} = W_{2} a_{1} + b_{2}\]
\[ z_{2} = \begin{pmatrix} z_{2}^1 \ z_{2}^2 \ \end{pmatrix} = \begin{pmatrix} w_{11}^2 & w_{12}^2 & w_{13}^2 & w_{14}^2 \ w_{21}^2 & w_{22}^2 & w_{23}^2 & w_{24}^2 \ \end{pmatrix} \begin{pmatrix} a_{1}^1 \ a_{1}^2 \ a_{1}^3 \ a_{1}^4 \ \end{pmatrix} + \begin{pmatrix} b_{2}^1 \ b_{2}^2 \ \end{pmatrix}\]
Nichtlinearer Schritt (Sigmoid-Aktivierungsfunktion):
\[ a_{2} = \text{sigmoid}(z_{2}) = \begin{pmatrix} a_{2}^1 \ a_{2}^2 \ \end{pmatrix} = \begin{pmatrix} \frac{1}{1+e^{-z_2^1}} \ \frac{1}{1+e^{-z_2^2}} \ \end{pmatrix}\]
Die Ausgabe des Netzwerks sind die Aktivierungen \(a_{2}^1\) und \(a_{2}^2\) in der Output-Schicht.
Mit unserer kostenlosen Lernplattform erhältst du Zugang zu Millionen von Dokumenten, Karteikarten und Unterlagen.
Kostenloses Konto erstellenDu hast bereits ein Konto? Anmelden