Dass Pfauenfedern im Licht aufregend schimmern, ist vielen bekannt. Doch dass die Federn nach einer gezielten Anregung Laserlicht ausstrahlen, ist eine Neuheit. Ein Team um Forscher der Florida Polytechnic University demonstrierte, dass winzige, reflektierende Strukturen im Auge von Pfauenfedern Licht zu einem Laserstrahl bündeln können. Die Ergebnisse erschienen im Fachmagazin Scientific Reports.

Grundbausteine eines Lasers

Grundbaustein für einen Laser ist ein sogenanntes optisch aktives Medium, also ein Material, dessen Atome oder Moleküle durch Licht in einen energetisch höheren Zustand angeregt werden können. Bei sogenannten Farbstofflasern sind das meist fluoreszierende Farbstoffe.

Das aktive Medium wird mithilfe einer geeigneten Lichtquelle angeregt: Die Elektronen wechseln dabei gezielt von einem energiearmen in einen energiereicheren Zustand. Ziel ist die sogenannte Besetzungsinversion – ein Zustand, in dem sich mehr Elektronen auf dem höheren Energieniveau befinden als auf dem niedrigeren.

Kehren die Teilchen in ihren energetisch günstigeren Zustand zurück, geben sie die überschüssige Energie in Form von Photonen ab. Diese regen weitere Teilchen dazu an, ebenfalls Photonen auszusenden. Ein Resonator verstärkt diesen Prozess und bündelt die entstehende Lichtlawine zu einem fokussierten Laserstrahl.

Ein Resonator der Natur

In einem herkömmlichen Laser besteht der Resonator aus gezielt angeordneten Spiegeln. In der Natur können jedoch auch mikroskopische Strukturen einen ähnlichen Effekt hervorrufen. Das ist der Fall in Pfauenfedern. Schillernde Farbtöne werden hier nicht mithilfe von Pigmenten erzeugt, sondern entstehen aufgrund geordneter Mikrostrukturen im Innern der Feder, die das Licht auf bestimmte Weise reflektieren. So entstehen leuchtende Blau- und Grüntöne.

Das Forschungsteam färbte die Federn mehrfach mit dem Farbstoff Rhodamin 6G ein – einem bekannten Lasermedium für Farbstofflaser – und regte sie anschließend mit einem Festkörperlaser an.

Die Forscher konnten beobachten, dass verschiedenfarbige Regionen der Feder Laserstrahlung in zwei Wellenlängen emittieren und so einen gelb-grünlichen Laserstrahl erzeugen. Dieser war zwar nicht mit bloßem Auge erkennbar, konnte aber mit Messgeräten detektiert werden.

Mechanismus unklar

Obwohl die verschiedenen Stellen der Feder in unterschiedlichen Farben schillerten und sich daher vermutlich in ihrer Mikrostruktur unterschieden, strahlten sie Laserlicht der gleichen Wellenlänge aus. „Die Ergebnisse deuten auf eine kritische Struktur im Inneren der Federn hin, die über verschiedene Farbregionen des Augenflecks fortbesteht“, schreiben die Autoren in der Studie. Das seien vermutlich nicht dieselben Strukturen, die für die schillernden Farben im Pfauenauge verantwortlich sind.

Wie die Makrostrukturen genau aussehen, die als Laserresonator agieren, konnte das Team nicht identifizieren. Somit fehlt bislang eine schlüssige Erklärung für den beobachteten Effekt. Nathan Dawson, Mitautor der Studie, schlug gegenüber Science vor, dass Proteinkörnchen oder ähnliche kleine Strukturen im Inneren der Federn als Laserhohlraum fungieren könnten.

Matjaž Humar, Biophotonik-Forscher an der Universität Ljubljana, sagte ebenfalls in Science, das Experiment sei „ein faszinierendes und elegantes Beispiel dafür, wie komplexe biologische Strukturen die Erzeugung von kohärentem Licht unterstützen können.“

Dawson und sein Kollege glauben, dass ihre Arbeit eines Tages zur Entwicklung von biokompatiblen Lasern führen könnte, die sicher in den menschlichen Körper für Sensor-, Bildgebungs- und Therapiezwecke eingebaut werden könnten.

(spa)

Der Markt für Testmanagementtools ist eng verknüpft mit der Entwicklung moderner Softwareprojekte. Ob klassische Software- oder cloudnative Applikationsentwicklung: Die Anforderungen an Tests und Qualitätssicherung werden immer komplexer. Damit wächst auch der Anspruch an die Werkzeuge, die diese Prozesse unterstützen sollen. Applikationen sind dabei oft schlankere, nutzerorientierte Lösungen, die sich beispielsweise mobil oder webbasiert betreiben lassen. Für das Testmanagement spielt diese begriffliche Unterscheidung allerdings zunächst nur eine untergeordnete Rolle. Wichtiger ist die Frage, wie systematisch und umfassend getestet wird. Moderne Testmanagementlösungen setzen hier an und helfen, strukturierte Prozesse über verschiedene Entwicklungsansätze hinweg sicherzustellen.

Denn die Auswahl der passenden Teststrategie, der eingesetzten Tools und der nötigen Testtiefe richtet sich letztlich danach, wie komplex ein System ist und welche Anforderungen es erfüllen muss. Wer dabei ungenau arbeitet oder falsche Annahmen trifft, übersieht leicht kritische Aspekte in der Qualitätssicherung, sei es durch unzureichende Abdeckung, mangelnde Automatisierung oder fehlende Nachvollziehbarkeit.

Weitere Faktoren treiben die Teststrategie und den Markt für Testmanagementtools voran: strengere regulatorische Sicherheitsanforderungen bei DevOps und DevSecOps, die weiter zunehmende Etablierung von Cloud-Technologien sowie der Einsatz dynamischer Containerumgebungen und KI. Alles zusammen führt einerseits zu einer wachsenden Anzahl von Anbietern auf dem Markt, andererseits etablieren sich gleichzeitig funktionale und spezialisierte Standards, die auf spezifische Entwicklungsszenarien und Umgebungen zugeschnitten sind.

Das war die Leseprobe unseres heise-Plus-Artikels „Software für Testmanagement in der Marktübersicht“.
Mit einem heise-Plus-Abo können Sie den ganzen Artikel lesen.

Neuronale Netze sind der Motor vieler Anwendungen in Künstlicher Intelligenz (KI) und GenAI. Diese Artikelserie gibt einen Einblick in die einzelnen Elemente. Nach der Vorstellung der Neuronen im ersten Teil widmet sich der zweite Teil den Schichten des Netzwerks.

Wenn mehrere künstliche Neuronen so gruppiert sind, dass sie alle denselben Satz von Eingaben erhalten und ihre Ausgaben parallel erzeugen, bezeichnen wir diese Sammlung als Schicht. In einer einzelnen Schicht wendet jedes Neuron seinen eigenen Gewichtsvektor und seinen eigenen Bias-Term auf das eingehende Signal an, aber alle Neuronen teilen sich dieselbe Eingabe. Durch die Anordnung von Schichten in einer Reihenfolge erstellen wir ein Netzwerk, das einfache numerische Eingaben in beliebig reichhaltige Darstellungen umwandeln kann.

Mathematisch ausgedrückt: Wenn wir die Aktivierungen der Schicht ℓ−1 durch den Spaltenvektor aℓ−1 und die Gewichte der Schicht ℓ durch eine Matrix Wℓ bezeichnen, deren Zeilen die Gewichtsvektoren der einzelnen Neuronen sind, dann ergibt sich der Präaktivierungsvektor zℓ der Schicht ℓ aus dem Matrix-Vektor-Produkt:

zℓ = Wℓ · aℓ−1 + bℓ

Wobei bℓ der Bias-Vektor für die Schicht ℓ ist. Anschließend wenden wir eine elementweise nicht lineare Aktivierungsfunktion σ an, um die Ausgabe der Schicht zu erhalten:

aℓ = σ(zℓ)

Wenn wir einen Stapel von Eingaben einspeisen, stapeln wir einfach jede Eingabe als Spalte (oder Zeile, je nach Konvention) einer Matrix X und ersetzen die Vektoroperationen durch Matrixmultiplikationen auf dem Stapel, was zu einer hocheffizienten vektorisierten Berechnung führt.

Im Code lassen sich mit PyTorch auf einfache Weise Schichten und ihre Verbindungen ausdrücken. Die integrierte Klasse torch.nn.Linear kapselt sowohl die Gewichtsmatrix als auch den Bias-Vektor und verbindet sie für die automatische Differenziation mit dem Berechnungsgrafen. Nachfolgend finden Sie ein minimales Beispiel für ein kleines Feed-Forward-Netzwerk mit einer versteckten Schicht. Jede Zeile wird ausführlich erklärt.

import torch
import torch.nn as nn

class SimpleMLP(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(SimpleMLP, self).__init__()
        # Definieren Sie eine vollständig verbundene Schicht, die input_dim auf hidden_dim abbildet
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        
        # Wählen Sie eine nichtlineare Aktivierungsfunktion für die versteckte Schicht
        self.relu = nn.ReLU()
        # Definieren Sie eine zweite vollständig verbundene Schicht, die hidden_dim auf output_dim abbildet
        self.fc2 = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        # Wende die erste lineare Transformation an
        x = self.fc1(x)
        # Wende die nichtlineare Aktivierungsfunktion elementweise an
        x = self.relu(x)
        # Wende die zweite lineare Transformation an, um die Ausgabe zu erzeugen
        x = self.fc2(x)
        return x

Die Import-Anweisungen laden torch für Tensoroperationen und torch.nn als Namespace für Bausteine neuronaler Netze. Die Klasse SimpleMLP erbt von nn.Module, der Basisklasse von PyTorch für alle Komponenten neuronaler Netze. Der Aufruf von super(SimpleMLP, self).init()stellt sicher, dass die interne Maschinerie von Module ordnungsgemäß initialisiert wird.

Innerhalb des Konstruktors sind self.fc1 und self.fc2 Instanzen von nn.Linear. Jede Linearschicht weist eine Gewichtungsmatrix der Form (output_features, input_features) und einen Bias-Vektor der Länge output_features zu. Durch das Speichern dieser Schichten als Attribute des Moduls registriert PyTorch automatisch ihre Parameter, sodass wir beim Aufruf von model.parameters() alle Gewichtungs- und Bias-Tensoren in einem einzigen iterierbaren Objekt zurückgeben können.

Die Wahl von ReLU für self.relu spiegelt dessen weitverbreitete Verwendung wider: Die rektifizierte lineare Einheit gibt für jede negative Eingabe Null zurück und für jede nicht negative Eingabe die Eingabe selbst. Diese einfache, nicht lineare Operation führt die Nichtlinearität ein, die das Netzwerk benötigt, um komplexe Funktionen zu approximieren.

Die Vorwärtsmethode definiert die Transformation des Eingabetensors x, während er durch das Netzwerk fließt. Wenn x die Form (batch_size, input_dim) hat, hat er nach self.fc1(x) die Form (batch_size, hidden_dim) und behält nach Anwendung von ReLU die gleiche Form, wobei sich negative Werte auf Null abbilden. Der letzte Aufruf von self.fc2 erzeugt eine Ausgabe der Form (batch_size, output_dim). Durch die Rückgabe von x am Ende von forward ermöglichen wir es, das Netzwerk wie eine Funktion aufzurufen:

model = SimpleMLP(input_dim=10, hidden_dim=50, output_dim=1)
batch_of_inputs = torch.randn(32, 10)
outputs = model(batch_of_inputs)

In diesem Beispiel ist batch_of_inputs ein Tensor der Form (32, 10), der zweiunddreißig Samples mit jeweils zehn Merkmalen darstellt. Der Aufruf model(batch_of_inputs) ruft im Hintergrund forward auf, und outputs hat die Form (32, 1), sodass wir pro Sample eine Vorhersage erhalten.

Im Hintergrund erstellt PyTorch einen Berechnungsgraphen, der jede Operation – Matrixmultiplikationen, Additionen und Nichtlinearitäten – aufzeichnet, sodass bei der Berechnung eines Verlusts auf der Grundlage der Outputs und dem anschließenden Aufruf von loss.backward() sich die Gradienten aller Parameter in fc1 und fc2 automatisch berechnen lassen. Diese Gradienten lassen sich dann von Optimierern verwenden, um die Gewichtungsmatrizen und Bias-Vektoren zu aktualisieren.

Durch das Stapeln weiterer Schichten – beispielsweise durch mehrmaliges Abwechseln von linearen und Aktivierungsschichten – und durch Variieren der versteckten Dimensionen lassen sich tiefere und breitere Netzwerke erstellen, die hochkomplexe Zuordnungen lernen können.

Der nächste Teil der Serie zeigt, wie die gebatchten, vektorisierten Operationen den Vorwärtslauf in seiner Allgemeinheit bilden und wie die Wahl der Aktivierungen mit der Netzwerktiefe zusammenwirkt.

(rme)