Pourquoi considérer Go pour le ML ?
Python est un excellent langage pour le prototypage et la recherche, mais il a ses limites :
Productivité: Python est lent, surtout sans bibliothèques optimisées
Parallélisme: GIL (Global Interpreter Lock) complique le multithreading
Déploiement: l'emballage des applications Python avec dépendances est une autre tâche
Typification: la saisie dynamique peut entraîner des erreurs de production
Go résout bon nombre de ces problèmes :
Langage compilé à haute performance
Soutien intégré à la compétitivité par le biais de la goroutine
Un fichier binaire sans dépendances
Typage statique
Que peut-on faire sur Go dans le domaine du ML ?
1. Inférence (application de modèles prêts à l'emploi)
Le scénario le plus populaire est l'utilisation de modèles déjà formés. Vous entraînez le modèle en Python, puis vous l'utilisez en production sur Go.
Exemple avec ONNX Runtime :
package main
import (
"fmt"
onnxruntime "github.com/yalue/onnxruntime_go"
)
func main() {
// Chargement du modèle formé dans PyTorch/TensorFlow
session, err := onnxruntime.NewSession[float32](
"model.onnx",
[]string{"input"},
[]string{"output"},
nil,
)
if err != nil {
panic(err)
}
defer session.Destroy()
// Nous préparons les données d'entrée
input := []float32{1.0, 2.0, 3.0, 4.0}
// Nous faisons une prédiction
output, err := session.Run([][]float32{input})
if err != nil {
panic(err)
}
fmt.Println("Prediction:", output[0])
}2. Algorithmes ML classiques
De nombreuses tâches ne nécessitent pas de réseaux de neurones. La régression linéaire, les arbres de décision, les k-means, tout cela peut être implémenté en Go.
Bibliothèque GoLearn :
package main
import (
"fmt"
"github.com/sjwhitworth/golearn/base"
"github.com/sjwhitworth/golearn/evaluation"
"github.com/sjwhitworth/golearn/knn"
)
func main() {
// Chargement des données
rawData, err := base.ParseCSVToInstances("data.csv", true)
if err != nil {
panic(err)
}
// Créons un classificateur KNN
cls := knn.NewKnnClassifier("euclidean", "linear", 2)
// Nous divisons en train/test
trainData, testData := base.InstancesTrainTestSplit(rawData, 0.7)
// Nous enseignons
cls.Fit(trainData)
// Vérification de la précision
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. Traitement des données et ingénierie des fonctionnalités
Go est idéal pour les pipelines ETL et le traitement de grandes quantités de données.
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
}
// Traitement parallèle via les goroutines
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])
// Normalisation ou autres transformations
results[idx] = DataPoint{
Feature1: (f1 - 50) / 10,
Feature2: (f2 - 100) / 20,
Label: label,
}
}(i, record)
}
wg.Wait()
return results, nil
}4. Microservices pour ML
Go est idéal pour créer des API qui prennent en charge les modèles ML :
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
}
// Ici, nous appelons votre modèle
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 {
// Votre logique d'inférence
return 42.0
}
func main() {
http.HandleFunc("/predict", predictHandler)
log.Println("Server starting on :8080")
log.Fatal(http.ListenAndServe(":8080", nil))
}
Bibliothèques Go populaires pour ML
Gorgonia — bibliothèque pour la construction de réseaux neuronaux, similaire à PyTorch
GoLearn — algorithmes ML classiques
Gonum — calculs numériques (analogue de NumPy)
ONNX Runtime Go — lancement des modèles ONNX
TensorFlow Go — Go-bindings pour TensorFlow
Quand utiliser Go et quand utiliser Python ?
Utilisez Go lorsque :
Besoin de hautes performances en production
La facilité de déploiement est importante (un seul binaire)
Vous travaillez avec des charges concurrentes
Utilisez des modèles prêts à l'emploi (inference)
Construire des microservices ML
Restez avec Python quand :
Effectuez des recherches et des expériences
Vous entraînez des réseaux de neurones complexes
Besoin d'un large choix de bibliothèques
Vous travaillez avec une équipe de data scientists
L'option la plus pratique :
Python pour la formation de modèles, les expériences, la science des données
Go pour l'environnement de production, l'API, le traitement des données
Cette approche utilise les points forts de chaque langue.
Exemple pratique : système de recommandation.
package main
import (
"math"
"sort"
)
type Item struct {
ID int
Features []float64
}
type Recommendation struct {
ItemID int
Score float64
}
// Similarité cosinusfunc 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))
}
// Obtenir des recommandationsfunc 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),
}
}
// Trier par score
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)
// Affichera les 2 meilleures recommandations
}Conclusion
Go peut très bien être utilisé pour construire des systèmes ML, en particulier dans un environnement de production. Oui, Python reste la norme pour l'apprentissage de modèles complexes, mais pour l'inférence, le traitement des données et la création de services hautes performances, Go est un excellent choix.
Le choix de l'outil dépend toujours de la tâche. Il n'est pas nécessaire d'abandonner complètement Python, mais il ne faut pas non plus ignorer les capacités de Go dans le domaine du ML.
Ceci et bien d'autres choses peuvent être étudiées dans Codique — tout analyser en détail et consolider par la pratique avec des tâches réelles. Nous proposons des cours structurés en Python, Go, JavaScript et d'autres langages avec un accent sur l'application pratique.
Et si vous avez besoin d'aide et que vous souhaitez discuter du code avec des personnes partageant les mêmes idées, nous avons déjà plus de 2 000 développeurs actifs à Chaîne Telegram, où vous trouverez toujours de l'aide, des conseils et du soutien pour apprendre la programmation !
🚀 Rejoignez la communauté des développeurs dans Codique!