- Ausführende
-
Lernen
Python lernen Ausführbare Beispiele, NumPy, pandas und mehr KI lernenNeuronale Netze, ML und LLMs von Grund auf C/C++ lernen Zeiger, Speicher, STL und modernes C++ C# lernenC#-Grundlagen, OOP, LINQ, Async und .NET-Übungen Matplotlib lernenLinien-, Balken-, Streu- und Kreisdiagramme mit interaktiven Visualisierungen Python-Algorithmen Suche, Sortierung, Rekursion und Visualisierungen O(n) C/C++-Algorithmen Implementierungen in C und C++ vergleichen Programmieren für Kinder Spielend programmieren lernen!
- AufgabenNeu
- Für LehrkräfteNeu
- Aktualisierungen
- Spendier mir einen Kaffee
Adam führt pro Gewicht zwei gleitende Mittelwerte, des Gradienten (m) und des quadrierten Gradienten (v), und gibt damit jedem Gewicht eine eigene Schrittweite.
Beginne mit m = 0 und v = 0 für jedes Gewicht. Für jeden Schritt t = 1, 2, 3, … mit Gradient g:
- m ← beta1 × m + (1 - beta1) × g
- v ← beta2 × v + (1 - beta2) × g²
- m̂ = m / (1 - beta1ᵗ) und v̂ = v / (1 - beta2ᵗ) (Bias-Korrektur)
- w ← w - learning_rate × m̂ / (√v̂ + epsilon)
Implementiere adam_steps(gradients, weights, learning_rate, beta1, beta2, epsilon) und wende pro Zeile von gradients ein Update an, in Reihenfolge.
Eingabe
gradients: Eine Zeile pro Schritt; jede Zeile hat einen Gradienten pro Gewicht.
weights: Die Startgewichte.
learning_rate, beta1, beta2, epsilon: Die Hyperparameter von Adam (üblich sind 0.001, 0.9, 0.999 und 0.00000001).
Ausgabe
Gib die Gewichte nach allen Schritten zurück.
Einschränkungen
0 ≤ Schritte ≤ 1.000, 1 ≤ Gewichte ≤ 100
0 < learning_rate ≤ 1, 0 ≤ beta1, beta2 < 1, 0 < epsilon ≤ 0.001
-100 ≤ jeder Wert ≤ 100
Beispiele
Beispiel 1
Eingabe:
gradients = [
[2.0]
]
weights = [1.0]
learning_rate = 0.1
beta1 = 0.9
beta2 = 0.999
epsilon = 1.0e-08
Erwartete Ausgabe:
[0.9]Erläuterung
m = 0.1 × 2 = 0.2 und v = 0.001 × 4 = 0.004. Die Bias-Korrektur ergibt m̂ = 0.2 / 0.1 = 2 und v̂ = 0.004 / 0.001 = 4, also ist der Schritt 0.1 × 2 / √4 = 0.1: w = 0.9. Im ersten Schritt bewegt Adam jedes Gewicht ungefähr um die Lernrate, unabhängig von der Größe des Gradienten.
Beispiel 2
Eingabe:
gradients = [
[100.0, 0.01]
]
weights = [0.0, 0.0]
learning_rate = 0.01
beta1 = 0.9
beta2 = 0.999
epsilon = 1.0e-08
Erwartete Ausgabe:
[-0.01, -0.01]Erläuterung
Die Gradienten unterscheiden sich um den Faktor 10.000, trotzdem bewegen sich beide Gewichte um etwa 0.01, auf [-0.01, -0.01]: Adam skaliert jeden Schritt mit der Größe des jeweiligen Gradienten.
Referenzen
-
Beispiel 1 Nicht ausgeführtEingabe:
gradients = [ [2.0] ] weights = [1.0] learning_rate = 0.1 beta1 = 0.9 beta2 = 0.999 epsilon = 1.0e-08Erwartete Ausgabe:[0.9]Deine Ausgabe -
Beispiel 2 Nicht ausgeführtEingabe:
gradients = [ [100.0, 0.01] ] weights = [0.0, 0.0] learning_rate = 0.01 beta1 = 0.9 beta2 = 0.999 epsilon = 1.0e-08Erwartete Ausgabe:[-0.01, -0.01]Deine Ausgabe
4 versteckte Tests werden beim Einreichen ebenfalls ausgeführt. Scheitert dein Code an einem, siehst du diesen Test. Löse die Aufgabe, um alle zu sehen.
Online Go Compiler
Write, compile, run, and debug Go code online in a full-featured browser IDE. Work with multiple files, save your workspace, and collaborate in real time - no setup required.
🚀 206,970 Gesamt-Ausführungen (799 diesen Monat)
Übe Go mit Coding Challenges
Löse praktische Aufgaben direkt im Editor: Führe die Beispieltests aus, reiche ein und erhalte ein KI-Code-Review.
🐹 Über diesen Go-Online-Executor
Der CodeUtility Go Executor ermöglicht es dir, Go-Code direkt im Browser zu schreiben und auszuführen - keine Installation, kein Setup und keine lokale Umgebung erforderlich. Er wird von einer sicheren Sandbox betrieben, die die echten Go-Compilerversionen 1.19, 1.20 und 1.21 unterstützt.
Dieses Tool kompiliert und führt echte Go-Programme in der Cloud aus und bietet dir eine authentische Go-Umgebung. Du kannst kurze Snippets testen, mit Packages experimentieren und die leistungsstarken Concurrency-Features von Go mit Goroutinen und Channels erkunden.
Es eignet sich perfekt, um zentrale Go-Konzepte wie Variablen, Funktionen, Structs, Slices, Maps, Interfaces und Fehlerbehandlung zu lernen und zu üben - ganz ohne lokale Installation.
Egal, ob du Go zum ersten Mal erkundest, Backend-Logik testest oder verstehen willst, wie Concurrency funktioniert: Der CodeUtility Go Executor bietet eine einfache, schnelle und browserbasierte Möglichkeit, Go-Code sofort auszuführen.
Mehr als nur ein Code-Runner
Nutzen Sie im selben Executor einen Editor für mehrere Dateien, ein isoliertes Ausführungsterminal, laufzeitspezifische Bibliotheken, persistente Arbeitsbereiche, Freigaben und Zusammenarbeit in Echtzeit.
Wie verwende ich diesen Executor?
Wählen Sie eine Laufzeit aus, öffnen oder erstellen Sie eine Datei, schreiben Sie Ihren Code und wählen Sie Ausführen. Die Ausgabe erscheint im Terminal. Angemeldete Benutzer können Dateien in einem Arbeitsbereich speichern, Bibliotheken installieren und über Freigaben zusammenarbeiten.
- Wählen Sie eine Version aus und bearbeiten Sie die aktuelle Datei oder öffnen Sie eine andere Datei aus dem Arbeitsbereich.
- Führen Sie den Code aus, geben Sie bei Aufforderung Daten im Terminal ein und prüfen Sie den gespeicherten Ausführungsverlauf.
- Nutzen Sie Bibliotheken, Arbeitsbereichswerkzeuge, Freigaben und den Chat, wenn Ihre Aufgabe mehr als ein einzelnes Codefragment erfordert.
💡 Go-Grundlagen & Beispiele, die du oben ausprobieren kannst
1. Variablen und Konstanten deklarieren
Verwende var oder :=, um Variablen zu deklarieren. Verwende const für Konstanten.
package main
var x int = 10
const Pi = 3.14
func main() {
name := "Alice"
isActive := true
println(x, Pi, name, isActive)
}2. Bedingungen (if / switch)
Go unterstützt if-else- und switch-Anweisungen mit klarer Syntax.
x := 2
if x == 1 {
println("Eins")
} else if x == 2 {
println("Zwei")
} else {
println("Sonstiges")
}
switch x {
case 1:
println("Eins")
case 2:
println("Zwei")
default:
println("Sonstiges")
}3. Schleifen
Go verwendet nur die for-Schleife, sie kann jedoch auch wie eine while-Schleife genutzt werden.
for i := 0; i < 3; i++ {
println(i)
}
n := 3
for n > 0 {
println(n)
n--
}4. Arrays
Arrays haben eine feste Größe. Verwende Slices für dynamische Listen.
var nums = [3]int{10, 20, 30}
println(nums[1])5. Slice-Operationen
Verwende Slices sowie die eingebauten Funktionen append, len, copy und die Slicing-Syntax.
fruits := []string{"apple", "banana"}
fruits = append(fruits, "cherry")
fruits = fruits[1:] // Slice
println(len(fruits))
for _, fruit := range fruits {
println(fruit)
}6. Konsolen-Ein-/Ausgabe
Verwende fmt.Print, fmt.Scan und fmt.Println.
import "fmt"
var name string
fmt.Print("Gib deinen Namen ein: ")
fmt.Scan(&name)
fmt.Println("Hallo", name)7. Funktionen
Funktionen werden mit func deklariert und können mehrere Werte zurückgeben.
func greet(name string) string {
return "Hallo, " + name
}
message := greet("Alice")
println(message)8. Maps
Maps sind Schlüssel-Wert-Speicher. Deklariere sie mit make().
ages := map[string]int{"Alice": 30}
ages["Bob"] = 25
println(ages["Alice"])9. Fehlerbehandlung
Go verwendet mehrere Rückgabewerte für Fehler anstelle von Exceptions.
import "errors"
func fail() error {
return errors.New("etwas ist schiefgelaufen")
}
err := fail()
if err != nil {
println(err.Error())
}10. Datei-I/O
Verwende die Pakete os und io/ioutil, um Dateien zu lesen/zu schreiben.
import (
"fmt"
"os"
"io/ioutil"
)
ioutil.WriteFile("file.txt", []byte("Hallo Datei"), 0644)
data, _ := ioutil.ReadFile("file.txt")
fmt.Println(string(data))11. String-Operationen
Verwende das Paket strings für String-Operationen.
import "strings"
text := " Hallo Welt "
println(strings.TrimSpace(text))
println(strings.ToUpper(text))
println(strings.ReplaceAll(text, "Hallo", "Hi"))
words := strings.Split(text, " ")
fmt.Println(words)12. Structs & Objekte
Verwende Structs, um eigene Typen mit Methoden zu definieren.
type Person struct {
Name string
}
func (p Person) Greet() string {
return "Hi, ich bin " + p.Name
}
p := Person{Name: "Alice"}
println(p.Greet())13. Referenzen (Pointer)
Go unterstützt Pointer mit * und &.
x := 10
ptr := &x
*ptr = 20
println(x) // 20