Warum sollte man Go überhaupt für ML in Betracht ziehen?
Python ist eine großartige Sprache für Prototyping und Forschung, hat aber auch ihre Grenzen:
Produktivität: Python ist langsam, besonders ohne optimierte Bibliotheken
Parallelität: GIL (Global Interpreter Lock) erschwert Multithreading
Bereitstellung: Python-Anwendungen mit Abhängigkeiten zu packen, ist eine weitere Aufgabe
Typisierung: Dynamische Typisierung kann zu Produktionsfehlern führen
Go löst viele dieser Probleme:
Hochleistungsfähige kompilierbare Sprache
Integrierte Unterstützung der Wettbewerbsfähigkeit durch Gorutins
Eine Binärdatei ohne Abhängigkeiten
Statische Typisierung
Was kann man mit Go im Bereich ML machen?
1. Inferenz (Anwendung vorgefertigter Modelle)
Das beliebteste Szenario ist die Verwendung bereits trainierter Modelle. Sie trainieren das Modell in Python und verwenden es dann in der Produktion in Go.
Beispiel mit ONNX Runtime:
package main
import (
"fmt"
onnxruntime "github.com/yalue/onnxruntime_go"
)
func main() {
// Laden Sie das in PyTorch/TensorFlow trainierte Modell
session, err := onnxruntime.NewSession[float32](
"model.onnx",
[]string{"input"},
[]string{"output"},
nil,
)
if err != nil {
panic(err)
}
defer session.Destroy()
// Wir bereiten die Eingabedaten vor
input := []float32{1.0, 2.0, 3.0, 4.0}
// Wir machen eine Vorhersage
output, err := session.Run([][]float32{input})
if err != nil {
panic(err)
}
fmt.Println("Prediction:", output[0])
}2. Klassische ML-Algorithmen
Viele Aufgaben erfordern keine neuronalen Netze. Lineare Regression, Entscheidungsbäume, k-means - all dies kann in Go implementiert werden.
GoLearn-Bibliothek:
package main
import (
"fmt"
"github.com/sjwhitworth/golearn/base"
"github.com/sjwhitworth/golearn/evaluation"
"github.com/sjwhitworth/golearn/knn"
)
func main() {
// Daten werden geladen
rawData, err := base.ParseCSVToInstances("data.csv", true)
if err != nil {
panic(err)
}
// Erstellen Sie einen KNN-Klassifikator
cls := knn.NewKnnClassifier("euclidean", "linear", 2)
// Wir teilen in train/test
trainData, testData := base.InstancesTrainTestSplit(rawData, 0.7)
// Wir schulen
cls.Fit(trainData)
// Wir überprüfen die Genauigkeit
predictions, err := cls.Predict(testData)
if err != nil {
panic(err)
}
confusionMat, err := evaluation.GetConfusionMatrix(testData, predictions)
if err != nil {
panic(err)
}
fmt.Println(evaluation.GetAccuracy(confusionMat))
}3. Datenverarbeitung und Feature Engineering
Go eignet sich hervorragend für ETL-Pipelines und die Verarbeitung großer Datenmengen.
package main
import (
"encoding/csv"
"os"
"strconv"
"sync"
)
type DataPoint struct {
Feature1 float64
Feature2 float64
Label int
}
func processData(filename string) ([]DataPoint, error) {
file, err := os.Open(filename)
if err != nil {
return nil, err
}
defer file.Close()
reader := csv.NewReader(file)
records, err := reader.ReadAll()
if err != nil {
return nil, err
}
// Parallele Verarbeitung durch Gorutins
var wg sync.WaitGroup
results := make([]DataPoint, len(records)-1)
for i, record := range records[1:] {
wg.Add(1)
go func(idx int, rec []string) {
defer wg.Done()
f1, _ := strconv.ParseFloat(rec[0], 64)
f2, _ := strconv.ParseFloat(rec[1], 64)
label, _ := strconv.Atoi(rec[2])
// Normalisierung oder andere Transformationen
results[idx] = DataPoint{
Feature1: (f1 - 50) / 10,
Feature2: (f2 - 100) / 20,
Label: label,
}
}(i, record)
}
wg.Wait()
return results, nil
}4. Microservices für ML
Go ist ideal für die Erstellung von APIs, die ML-Modelle bedienen:
package main
import (
"encoding/json"
"net/http"
"log"
)
type PredictionRequest struct {
Features []float64 `json:"features"`
}
type PredictionResponse struct {
Prediction float64 `json:"prediction"`
Confidence float64 `json:"confidence"`
}
func predictHandler(w http.ResponseWriter, r *http.Request) {
var req PredictionRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
// Hier rufen wir Ihr Modell auf
prediction := runModel(req.Features)
response := PredictionResponse{
Prediction: prediction,
Confidence: 0.95,
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(response)
}
func runModel(features []float64) float64 {
// Ihre Logik
return 42.0
}
func main() {
http.HandleFunc("/predict", predictHandler)
log.Println("Server starting on :8080")
log.Fatal(http.ListenAndServe(":8080", nil))
}
Beliebte Go-Bibliotheken für ML
Gorgonia — Bibliothek zum Aufbau neuronaler Netze, ähnlich wie PyTorch
GoLearn — Klassische ML-Algorithmen
Gonum — numerische Berechnungen (Analog zu NumPy)
ONNX Runtime Go — Einführung von ONNX-Modellen
TensorFlow Go — Go-Bindings für TensorFlow
Wann sollte man Go und wann Python verwenden?
Verwenden Sie Go, wenn:
Wir brauchen eine hohe Leistung in der Produktion
Einfache Bereitstellung (eine Binärdatei) ist wichtig
Arbeiten Sie mit konkurrierenden Lasten
Verwenden Sie vorgefertigte Modelle (Inferenz)
ML-Microservices erstellen
Bleiben Sie bei Python, wenn:
Führen Sie Studien und Experimente durch
Sie trainieren komplexe neuronale Netze
Eine große Auswahl an Bibliotheken ist erforderlich
Sie arbeiten mit einem Team von Datenwissenschaftlern
Die praktischste Option:
Python für die Schulung von Modellen, Experimenten, Data Science
Go für Produktionsumgebung, API, Datenverarbeitung
Dieser Ansatz nutzt die Stärken jeder Sprache.
Praktisches Beispiel: Empfehlungssystem.
package main
import (
"math"
"sort"
)
type Item struct {
ID int
Features []float64
}
type Recommendation struct {
ItemID int
Score float64
}
// Kosinusähnlichkeitfunc cosineSimilarity(a, b []float64) float64 {
var dotProduct, normA, normB float64
for i := range a {
dotProduct += a[i] * b[i]
normA += a[i] * a[i]
normB += b[i] * b[i]
}
return dotProduct / (math.Sqrt(normA) * math.Sqrt(normB))
}
// Wir erhalten Empfehlungenfunc getRecommendations(userPrefs []float64, items []Item, topN int) []Recommendation {
recommendations := make([]Recommendation, len(items))
for i, item := range items {
recommendations[i] = Recommendation{
ItemID: item.ID,
Score: cosineSimilarity(userPrefs, item.Features),
}
}
// Sortieren nach Punktzahl
sort.Slice(recommendations, func(i, j int) bool {
return recommendations[i].Score > recommendations[j].Score
})
return recommendations[:topN]
}
func main() {
userPrefs := []float64{0.8, 0.3, 0.9}
items := []Item{
{ID: 1, Features: []float64{0.9, 0.2, 0.8}},
{ID: 2, Features: []float64{0.1, 0.9, 0.2}},
{ID: 3, Features: []float64{0.7, 0.4, 0.9}},
}
recs := getRecommendations(userPrefs, items, 2)
// Zeigt die Top-2-Empfehlungen an
}Befund
Go kann durchaus zum Aufbau von ML-Systemen verwendet werden, insbesondere in einer Produktionsumgebung. Ja, Python bleibt der Standard für das Training komplexer Modelle, aber für Inferenz, Datenverarbeitung und die Erstellung von Hochleistungsservices ist Go eine ausgezeichnete Wahl.
Die Wahl des Werkzeugs hängt immer von der Aufgabe ab. Sie müssen Python nicht vollständig aufgeben, aber Sie sollten die Fähigkeiten von Go im Bereich ML nicht ignorieren.
Dies und vieles mehr kann man lernen in Kodike – alles im Detail analysieren und mit Praxis und realen Aufgaben festigen. Wir bieten strukturierte Kurse in Python, Go, JavaScript und anderen Sprachen mit Schwerpunkt auf praktischer Anwendung.
Und wenn Sie Unterstützung benötigen und den Code mit Gleichgesinnten besprechen möchten, haben wir bereits mehr als 2000 aktive Entwickler in Telegram-Kanal, wo Sie immer Hilfe, Ratschläge und Unterstützung auf dem Weg zum Erlernen der Programmierung erhalten!
🚀 Treten Sie der Entwickler-Community bei Kodike!