Artificial Intelligence (AI)

Getting Started With Go Programing For Data Science

Written by smirow

Erste Schritte mit der Go-Programmierung für Data ScienceErste Schritte mit der Go-Programmierung für Data Science
Bild vom Autor

Die Programmiersprache Go erfreut sich bei Entwicklern als Allzwecksprache immer größerer Beliebtheit. Es ist schnell, einfach und leistungsstark und eignet sich perfekt für die Erstellung von Webanwendungen, mobilen Anwendungen und Systemprogrammierung. Vor kurzem hat Go begonnen, sich in den Bereich des maschinellen Lernens und der Datenanalyse einzuschleichen, was es zu einer überzeugenden Wahl für datenwissenschaftliche Projekte macht.

Wenn Sie eine neue Sprache lernen möchten, die Ihnen dabei hilft, Datenanalyse- und Visualisierungsaufgaben effektiver durchzuführen, ist Go möglicherweise die perfekte Wahl für Sie. In diesem Tutorial lernen Sie die Grundlagen der Einrichtung von Go, der Analyse und Visualisierung von Daten sowie der Erstellung eines einfachen KNN-Klassifikators.

Laden Sie die neueste Version von Go herunter und installieren Sie sie, indem Sie go.dev aufrufen. So einfach ist das.

Erste Schritte mit der Go-Programmierung für Data ScienceErste Schritte mit der Go-Programmierung für Data Science

Um zu überprüfen, ob die Installation erfolgreich war, führen Sie den folgenden Befehl aus:

$ go version
go version go1.22.0 windows/amd64

Als nächstes erstellen wir einen Projektordner und ersetzen das Verzeichnis durch den Ordner.

$ mkdir go-example
$ cd go-example

Initialisieren Sie das Go-Modul. Dieser Befehl erstellt eine „go.mod-Datei“, um die Abhängigkeiten Ihres Codes zu verfolgen.

$ go mod init example/kdnuggets
go: creating new go.mod: module example/kdnuggets

Starten Sie die IDE oder den Code-Editor. In unserem Fall verwenden wir VSCode.

Schreiben Sie einen einfachen Druckbefehl in die Hauptfunktion.

package main

import "fmt"

func main() {
    // Print to the console
    fmt.Println("Welcome to KDnuggets")
}

Führen Sie den Befehl „go run“ im Terminal aus.

$ go run .
Welcome to KDnuggets

Es ist Python ziemlich ähnlich, bietet aber im Vergleich zu Python viele Funktionen. Besonders effizientes Paketmanagement.

In diesem Datenanalysebeispiel laden wir den Datensatz „Erwachsenenzählungseinkommen“ von Kaggle herunter und laden ihn.

Importieren Sie zunächst alle Go-Pakete, die wir für die Analyse verwenden werden. Laden Sie als Nächstes die CSV-Datei mit dem Befehl „os“. Konvertieren Sie die Rohdaten mithilfe des Datenrahmenpakets „gota“ in einen Datenrahmen. Zum Schluss drucken wir die ersten beiden Zeilen.

package main

import (
    "fmt"
    "os"
    "github.com/go-gota/gota/dataframe"
    "github.com/go-gota/gota/series"
)

func main() {

    f, err := os.Open("adult.csv")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()

    df := dataframe.ReadCSV(f)
   
    fmt.Println(df.Subset([]int{0, 1}))

}

Bevor wir den Code ausführen, müssen wir alle im obigen Code verwendeten Pakete installieren. Dazu starten wir:

$ go mod tidy

go: finding module for package github.com/go-gota/gota/series
go: finding module for package github.com/go-gota/gota/dataframe
go: downloading github.com/go-gota/gota v0.12.0
go: found github.com/go-gota/gota/dataframe in github.com/go-gota/gota v0.12.0
go: found github.com/go-gota/gota/series in github.com/go-gota/gota v0.12.0
go: downloading golang.org/x/net v0.0.0-20210423184538-5f58ad60dda6
go: downloading gonum.org/v1/gonum v0.9.1
go: downloading golang.org/x/exp v0.0.0-20191002040644-a1355ae1e2c3
go: downloading gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0

Führen Sie nach der Installation aller Pakete den Code aus, indem Sie den Dateinamen angeben.

Der „gota“-Datenrahmen ist nicht so einfach zu lesen wie der „pandas“-Datenrahmen, kann aber große Datensätze in Sekundenschnelle lesen.

$ go run simple-analysis.go

[2x15] DataFrame

    age   workclass fnlwgt education education.num marital.status ...
 0: 90    ?         77053  HS-grad   9             Widowed        ...
 1: 82    Private   132870 HS-grad   9             Widowed        ...
                           ...

Not Showing: occupation , relationship , race , sex ,
capital.gain , capital.loss , hours.per.week , native.country ,
income 

Wir schreiben nun den vollständigen Code zum Filtern, Berechnen des Durchschnitts und Generieren der Zusammenfassung. Der Code ist Pandas ziemlich ähnlich, Sie müssen jedoch die Dokumentation lesen, um zu verstehen, wie die einzelnen Funktionen interagieren.

package main

import (
	"fmt"
	"github.com/go-gota/gota/dataframe"
	"github.com/go-gota/gota/series"
	"os"
)

func main() {
	// Loading the CSV file
	f, err := os.Open("adult.csv")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer f.Close()

	df := dataframe.ReadCSV(f)

	// Filter the data: individuals with education level "HS-grad"
	hsGrad := df.Filter(dataframe.F{Colname: "education", Comparator: series.Eq, Comparando: "HS-grad"})
	fmt.Println("\nFiltered DataFrame (HS-grad):")
	fmt.Println(hsGrad)

	// calculating the average age of individuals in the dataset
	avgAge := df.Col("age").Mean()
	fmt.Printf("\nAverage age: %.2f\n", avgAge)

	// Describing the data
	fmt.Println("\nGenerate descriptive statistics:")
	description := df.Describe()
	fmt.Println(description)

}

Wir haben den gefilterten Datensatz, das Durchschnittsalter und eine Zusammenfassung der numerischen Spalten angezeigt.

Filtered DataFrame (HS-grad):
[10501x15] DataFrame

    age   workclass        fnlwgt education education.num marital.status     ...
 0: 90    ?                77053  HS-grad   9             Widowed            ...
 1: 82    Private          132870 HS-grad   9             Widowed            ...
 2: 34    Private          216864 HS-grad   9             Divorced           ...
 3: 68    Federal-gov      422013 HS-grad   9             Divorced           ...
 4: 61    Private          29059  HS-grad   9             Divorced           ...
 5: 61    ?                135285 HS-grad   9             Married-civ-spouse ...
 6: 60    Self-emp-not-inc 205246 HS-grad   9             Never-married      ...
 7: 53    Private          149650 HS-grad   9             Never-married      ...
 8: 71    ?                100820 HS-grad   9             Married-civ-spouse ...
 9: 71    Private          110380 HS-grad   9             Married-civ-spouse ...
    ...   ...              ...    ...       ...           ...                ...
                                      ...

Not Showing: occupation , relationship , race , sex ,
capital.gain , capital.loss , hours.per.week , native.country ,
income 


Average age: 38.58

Generate descriptive statistics:
[8x16] DataFrame

    column   age       workclass   fnlwgt         education    education.num ...
 0: mean     38.581647 -           189778.366512  -            10.080679     ...
 1: median   37.000000 -           178356.000000  -            10.000000     ...
 2: stddev   13.640433 -           105549.977697  -            2.572720      ...
 3: min      17.000000 ?           12285.000000   10th         1.000000      ...
 4: 25%      28.000000 -           117827.000000  -            9.000000      ...
 5: 50%      37.000000 -           178356.000000  -            10.000000     ...
 6: 75%      48.000000 -           237051.000000  -            12.000000     ...
 7: max      90.000000 Without-pay 1484705.000000 Some-college 16.000000     ...
                                ...

Not Showing: marital.status , occupation , relationship ,
race , sex , capital.gain , capital.loss ,
hours.per.week , native.country , income 

Python ist gut mit Jupyter Notebook kompatibel, sodass die Visualisierung von Grafiken und Diagrammen recht einfach ist. Sie können Go auch in Jupyter Notebook konfigurieren, aber es wird nicht so reibungslos sein wie Python.

In diesem Beispiel sind wir es

  1. Laden des Datensatzes
  2. Konvertieren Sie es in einen Datenrahmen
  3. Extrahieren Sie die Spalte „Alter“.
  4. Erstellen des Plotobjekts
  5. Hinzufügen von Text zum Titel sowie zu X- und Y-Beschriftungen
  6. Zeichnen Sie das Histogramm der „Alter“-Spalten
  7. Füllfarbe ändern
  8. Speichern des Plots als PNG-Datei im lokalen Verzeichnis
package main

import (
    "fmt"
    "image/color"
    "log"
    "os"
    "gonum.org/v1/plot"
    "gonum.org/v1/plot/plotter"
    "gonum.org/v1/plot/vg"
    "github.com/go-gota/gota/dataframe"
)

func main() {
    // Sample data: replace this CSV string with the path to your actual data file or another data source.
    f, err := os.Open("adult.csv")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()
   
    // Read the data into a DataFrame.
    df := dataframe.ReadCSV(f)

    // Extract the 'age' column and convert it to a slice of float64s for plotting.
    ages := df.Col("age").Float()

    // Create a new plot.
    p:= plot.New()

    p.Title.Text = "Age Distribution"
    p.X.Label.Text = "Age"
    p.Y.Label.Text = "Frequency"

    // Create a histogram of the 'age' column.
    h, err := plotter.NewHist(plotter.Values(ages), 16) // 16 bins.
    if err != nil {
        log.Fatal(err)
    }
    h.FillColor = color.RGBA{R: 255, A: 255}

    p.Add(h)

    // Save the plot to a PNG file.
    if err := p.Save(4*vg.Inch, 4*vg.Inch, "age_distribution.png"); err != nil {
        log.Fatal(err)
    }

    fmt.Println("Histogram saved as age_distribution.png")
}

Nochmals, bevor Sie den Code ausführen. Wir müssen die Codeabhängigkeiten installieren.

Nachdem wir den Code ausgeführt haben, generieren wir die Bilddatei, die Sie anzeigen können, indem Sie in Ihren Projektordner gehen.

$ go run simple-viz.go
Histogram saved as age_distribution.png

Erste Schritte mit der Go-Programmierung für Data ScienceErste Schritte mit der Go-Programmierung für Data Science

Um Modelle für maschinelles Lernen zu trainieren, laden wir den Iris Species-Datensatz von Kaggle herunter und laden ihn.

Wir werden das Paket „golearn“ ähnlich wie scikit-learn verwenden für:

  1. CSV-Datensatz wird geladen
  2. Aufbau des KNN-Klassifizierungsmodells
  3. Teilen Sie den Datensatz in Training und Test auf
  4. Modellanpassung
  5. Sagen Sie den Wert aus dem Testdatensatz voraus und zeigen Sie ihn an
  6. Berechnung und Ausdruck von Konfusionsmatrix, Genauigkeit, Rückruf, Präzision und F1-Score
package main

import (
    "fmt"

    "github.com/sjwhitworth/golearn/base"
    "github.com/sjwhitworth/golearn/evaluation"
    "github.com/sjwhitworth/golearn/knn"
)

func main() {
    // Load in a dataset, with headers. Header attributes will be stored.
    rawData, err := base.ParseCSVToInstances("iris.csv", true)
    if err != nil {
        panic(err)
    }

    //Initialises a new KNN classifier
    cls := knn.NewKnnClassifier("euclidean", "linear", 2)

    //Do a training-test split
    trainData, testData := base.InstancesTrainTestSplit(rawData, 0.50)
    cls.Fit(trainData)

    //Calculates the Euclidean distance and returns the most popular label
    predictions, err := cls.Predict(testData)
    if err != nil {
        panic(err)
    }
    fmt.Println(predictions)

    // Prints precision/recall metrics
    confusionMat, err := evaluation.GetConfusionMatrix(testData, predictions)
    if err != nil {
        panic(fmt.Sprintf("Unable to get confusion matrix: %s", err.Error()))
    }
    fmt.Println(evaluation.GetSummary(confusionMat))
}

Stellen Sie vor dem Ausführen des Codes sicher, dass Sie über einen G++-Compiler verfügen, indem Sie den folgenden Befehl ausführen:

Wenn es nicht installiert ist, befolgen Sie die Anleitung „Erste Schritte mit C++ und MinGW-w64“ in Visual Studio Code.

Installieren Sie die Codeabhängigkeit, indem Sie den Tidy-Befehl im Terminal ausführen.

Wenn Sie den Code ausführen, erhalten Sie Vorhersagen, eine Verwirrungsmatrix und eine Modellbewertung.

$ go run simple-ml.go 

Instances with 68 row(s) 1 attribute(s)
Attributes:
*       CategoricalAttribute("Species", [Iris-setosa Iris-versicolor Iris-virginica])

Data:
        Iris-setosa
        Iris-setosa
        Iris-versicolor
        Iris-virginica
        Iris-virginica
        Iris-setosa
        Iris-virginica
        Iris-setosa
        Iris-setosa
        Iris-setosa
        Iris-virginica
        Iris-virginica
        Iris-setosa
        Iris-setosa
        Iris-versicolor
        Iris-versicolor
        Iris-setosa
        Iris-versicolor
        Iris-virginica
        Iris-setosa
        Iris-setosa
        Iris-virginica
        Iris-virginica
        Iris-virginica
        Iris-virginica
        Iris-versicolor
        Iris-virginica
        Iris-virginica
        Iris-virginica
        Iris-versicolor
        ...
38 row(s) undisplayed
Reference Class True Positives  False Positives True Negatives  Precision       Recall  F1 Score
--------------- --------------  --------------- --------------  ---------       ------  --------
Iris-setosa     24              0               44              1.0000          1.0000  1.0000
Iris-versicolor 22              0               43              1.0000          0.8800  0.9362
Iris-virginica  19              3               46              0.8636          1.0000  0.9268
Overall accuracy: 0.9559

Wenn Sie Probleme beim Ausführen des Codes haben, schauen Sie sich meinen Code auf GitHub an: kingabzpro/go-example-kdn.

Datenwissenschaftspakete in der Go-Sprache werden nicht gut gepflegt und es gibt keine große Entwicklergemeinschaft, die Tools für Datenwissenschaftler erstellt. Der Hauptvorteil der Go-Sprache ist jedoch ihre Geschwindigkeit und Benutzerfreundlichkeit. Die Verwendung der Go-Sprache bietet viele weitere Vorteile, die Benutzer davon überzeugen können, ihren Arbeitsablauf darauf umzustellen.

In diesem Einsteiger-Tutorial haben wir gelernt, wie man einen Datensatz als Datenrahmen lädt, eine Datenanalyse und -visualisierung durchführt und ein Modell für maschinelles Lernen trainiert.

Abid Ali Awan (@1abidaliawan) ist ein zertifizierter professioneller Datenwissenschaftler, der es liebt, Modelle für maschinelles Lernen zu erstellen. Derzeit konzentriert er sich auf die Erstellung von Inhalten und das Schreiben technischer Blogs zu maschinellem Lernen und Datenwissenschaftstechnologien. Abid verfügt über einen Master-Abschluss in Technologiemanagement und einen Bachelor-Abschluss in Telekommunikationstechnik. Seine Vision ist es, ein KI-Produkt mithilfe eines grafischen neuronalen Netzwerks für Schüler mit psychischen Erkrankungen zu entwickeln.

About the author

smirow

Leave a Comment