GitHub- und Git-Tutorial für Einsteiger

Was ist Git?

Git ist ein verteiltes, quelloffenes Versionskontrollsystem. Es ermöglicht Entwicklerinnen, Entwicklern und Data Scientists, Code nachzuverfolgen, Änderungen zusammenzuführen und zu älteren Versionen zurückzurollen - AWS. Außerdem kannst du Änderungen mit einem Remote-Server synchronisieren. Durch seine Flexibilität und Verbreitung ist Git zum Branchenstandard geworden und unterstützt nahezu alle Entwicklungsumgebungen, Kommandozeilentools und Betriebssysteme. 

Wie funktioniert Git?

Git speichert deine Dateien und deren Änderungshistorie in einem lokalen Repository. Immer wenn du deine Änderungen sicherst, erstellt Git einen Commit. Ein Commit ist ein Schnappschuss des aktuellen Stands. Diese Commits sind miteinander verknüpft und bilden wie unten gezeigt einen Graphen der Entwicklungshistorie. So kannst du zu einem früheren Commit zurückkehren, Änderungen vergleichen und den Fortschritt deines Projekts einsehen - Azure DevOps. Jeder Commit hat einen eindeutigen Hash, mit dem Änderungen verglichen und zurückgenommen werden können.  

Ein Graph der Entwicklungshistorie

Branches

Branches sind Kopien des Quellcodes, die parallel zur Hauptversion laufen. Um deine Änderungen dauerhaft zu übernehmen, führst du den Branch mit der Hauptversion zusammen. Diese Arbeitsweise fördert konfliktfreie Teamarbeit. Jedes Teammitglied hat seine Aufgabe und kann dank Branches an neuen Features arbeiten, ohne andere zu stören. Nach Abschluss lässt sich das neue Feature in die Hauptversion (master-Branch) mergen. Wenn du lernen willst, wie man einen Branch klont, sieh dir dieses Tutorial zu Git Clone Branch an.

Neues Feature zum Repository hinzufügen 

Commits

In Git gibt es drei Zustände für Dateien: modified, staged und committed. Wenn du eine Datei änderst, landen diese Änderungen erst im lokalen Verzeichnis. Sie sind noch nicht Teil der Git-Historie. Um einen Commit zu erstellen, musst du geänderte Dateien zunächst stagen. Im Staging-Bereich kannst du Änderungen hinzufügen oder entfernen und sie dann mit einer Nachricht als Commit verpacken.  

Drei Zustände von Dateien in Git

Welche Vorteile bietet Git?

• Änderungen nachverfolgen: Entwicklerinnen und Entwickler können die Historie einsehen. Die Entwicklungshistorie erleichtert das Finden und Beheben von Bugs.
• IDE-Integration: Durch seine Verbreitung ist Git in allen gängigen Entwicklungsumgebungen integriert, zum Beispiel in VSCode und JupyterLab.
• Teamzusammenarbeit: Teams sehen ihren Fortschritt, können mit Branches unabhängig arbeiten und Änderungen in die Hauptversion mergen. Pull Requests, das Lösen von Merge-Konflikten und Codereviews fördern die Zusammenarbeit. 
• Verteilte VCS: In einem verteilten System gibt es keinen zentralen Speicherort. Es existieren mehrere Backups desselben Projekts. So kann offline gearbeitet und trotzdem committet werden. 

Git für Data-Science-Projekte

Git ermöglicht Versionskontrolle für Skripte, Metriken, Daten und Modelle. Mit der Git-Erweiterung git-lfs kannst du große Datensätze und ML-Modelle speichern und versionieren. In typischen Data-Science-Projekten hast du ein Jupyter Notebook, Datensätze, Modelle, Metadaten und Modellmetriken. Die Metadaten enthalten Informationen zum ML-Modell, zu Features, Modellparametern und Automationsdateien. All das ist wichtig, um den Fortschritt von KI-Anwendungen zu überwachen und Probleme zu beheben. 

Das Nachverfolgen von Experimenten hilft, versehentliche Änderungen rückgängig zu machen, anhand von Metriken die beste Variante zu wählen und im Team zusammenzuarbeiten. Das folgende Diagramm zeigt, wie Änderungen an Daten oder Code die Metadaten und das Modellergebnis beeinflussen. Dieses Tracking hilft auch anderen im Team, bessere Lösungen zu entwickeln. Lerne alles über Git im neuesten Blog von Summer Worsley.

Git für ein Data-Science-Projekt 

Zusammenarbeit mit GitHub

GitHub ist eine cloudbasierte Plattform für Softwareentwicklung. Sie wird genutzt, um Dateien zu speichern, Änderungen zu verfolgen und gemeinsam an Projekten zu arbeiten. In den letzten Jahren ist GitHub zur beliebtesten sozialen Plattform für Entwicklercommunities geworden. Einzelpersonen können zu Open-Source-Projekten und Bugreports beitragen, neue Projekte diskutieren und Tools entdecken. 

Data Scientists und Machine-Learning-Engineers übernehmen diese Arbeitsweise und integrieren ihren Workflow mit GitHub. So teilen sie ihre Forschung, ermöglichen Community-Beiträge und arbeiten mit Datenteams zusammen. Auf der Plattform findest du alle Arten von Data-Science- und ML-Projekten, Guides, Tutorials und Ressourcen. Für Studierende ist GitHub eine Chance, Praxiserfahrung zu sammeln und dadurch einen Job bei renommierten Unternehmen zu bekommen. 

Portfolio

Die meisten Tech-Recruiter fragen nach Portfolioprojekten oder dem GitHub-Profil. So prüfen sie, ob jemand fachlich passt. Es ist sehr empfehlenswert, ein GitHub-Profil anzulegen und regelmäßig zu aktualisieren. Hiring-Manager achten auf Kandidat:innen mit starker Entwicklungserfahrung und Open-Source-Beiträgen. Ein Blick ins GitHub-Portfolio hilft auch, Fragen für technische Interviews vorzubereiten. 

GitHub-Profil

GitHub ermöglicht es Data Scientists, ihre Projekte sichtbar zu machen, und kann als Berufserfahrung im Lebenslauf zählen. Portfolioprojekte zu zeigen, eröffnet außerdem Chancen für Kooperationen, Gründungen und Forschung. 

Portfolioprojekte

Features

Neben dem Portfolio bietet GitHub viele weitere wichtige Funktionen. Es lohnt sich, diese zu kennen und in deine Data-Science-Projekte einzubinden. 

• Open Source: GitHub stellt ein vollständiges Ökosystem für Open-Source-Projekte bereit. Du kannst Maintainer sponsern, zu Projekten beitragen, Open-Source-Tools in eigenen Projekten nutzen und deine Arbeit bekannt machen. 
• Community-Zusammenarbeit: GitHub ist eine Community-Plattform, auf der Issues, Feature-Requests, Code- und Doku-Beiträge diskutiert werden. 
• Explore: Der Explore-Tab hilft dir, neue Projekte, Trend-Tools und Entwickler-Events zu entdecken. 
• GitHub Gists: Teile Code-Snippets oder bette sie in Blogs und Websites ein. 
• GitHub CLI: Erledige Pull Requests, Reviews, Issue-Checks und Fortschrittskontrolle direkt in der Kommandozeile. 
• Freier Speicher: Unbegrenzter Speicher für private und öffentliche Repositories.
• Webhosting: Veröffentliche deine Portfolio-Website oder Dokumentation. GitHub Pages macht das Erstellen und Bereitstellen einfach. 
• Codespaces: Eine Cloud-Entwicklungsumgebung, integriert mit deinem GitHub-Repository. 
• Projects: Ein anpassbares, flexibles Tool zum Planen und Verfolgen von Arbeit auf GitHub.
• Automation: GitHub Actions automatisiert Builds, Tests, Publishing, Releases und Deployments.
• Sponsoring: Unterstütze deine liebsten Open-Source-Projekte oder -Entwickler mit monatlichen oder einmaligen Beiträgen. Auch Drittplattformen wie ko-fi werden unterstützt. 

Grundlegende Befehle

Bevor wir in die Verwaltung von Data-Science-Projekten einsteigen, sehen wir uns die Git-Befehle an, die du fast immer brauchst. Dazu zählen das Initialisieren eines Repositories, Änderungen sichern, Logs prüfen, Änderungen zum Remote pushen und mergen. 

• git init erstellt ein Git-Repository in einem lokalen Verzeichnis.

• git clone <remote-repo-address>: Kopiert das gesamte Repository vom Remote-Server ins lokale Verzeichnis. Funktioniert auch für lokale Repositories.

• git add <file.txt>: Fügt einzelne oder mehrere Dateien und Ordner dem Staging-Bereich hinzu.

• git commit –m “Message”: Erstellt einen Schnappschuss der Änderungen und speichert ihn im Repository. 

• git config legt benutzerspezifische Einstellungen fest, z. B. E-Mail, Benutzername und Dateiformat. 

• git status zeigt geänderte, noch nicht gestagte oder noch nicht committete Dateien.  

• git push <remote-name> <branch-name>: Sendet lokale Commits an den Remote-Branch des Repositories.  

• git checkout -b <branch-name>: Erstellt einen neuen Branch und wechselt direkt dorthin.

• git remote –v: Zeigt alle Remotes an.

• git remote add <remote-name> <host-or-remoteURL>: Fügt dem lokalen Repository einen Remote-Server hinzu. 

• git branch –d <branch-name>: Löscht den Branch.

• git pull merge Commits aus einem Remote-Repository in ein lokales Verzeichnis. 

• git merge <branch-name>: Nachdem Konflikte gelöst sind, führt der Befehl den ausgewählten Branch in den aktuellen Branch zusammen.

• git log zeigt eine detaillierte Liste der Commits des aktuellen Branches.

Komplette Entwicklung mit GitHub

Wenn du weitere Befehle lernen willst, sieh dir unser Git-Cheat Sheet an. 

Erste Schritte

In diesem Abschnitt verwenden wir Git, um ein Data-Science-Projekt zu versionieren, und GitHub als Remote-Server. Du lernst, wie man Git installiert, ein Repository auf GitHub erstellt und klont, ML-Experimente ausführt und Änderungen (Notebook, Modell, Daten) mit Windows PowerShell 7 zu GitHub pusht.  

Git installieren

Git unterstützt alle Betriebssysteme. Du kannst es über die Kommandozeile installieren oder das Setup herunterladen und ausführen. 

Linux

Für Debian/Ubuntu-basierte Systeme nutze `apt-get install git`. Wenn du ein anderes Linux-System verwendest, findest du die vollständige Befehlsübersicht hier.

macOS

Wenn Homebrew installiert ist, kannst du Git mit `brew install git` herunterladen und installieren. Alternativ lade den binären Installer herunter und führe ihn aus.

Windows

Unter Windows ist die Installation unkompliziert. Gehe zur Download-Seite, klicke auf deine Windows-Version und installiere das Setup. Wenn du das winget-Tool hast, kannst du in PowerShell winget install --id Git.Git -e --source winget ausführen. 

Nach der Installation solltest du Benutzername und E-Mail konfigurieren. Diese Informationen signieren deine Commits. 

git config --global user.name "your-user-name"
git config --global user.email "your@email.com"

Ausführlichere Infos zur Installation von Git findest du hier. 

Projekt initialisieren

Wenn du ein GitHub-Konto hast, klicke auf das +-Symbol und wähle New Repository. Vergib dann einen Namen und eine kurze Beschreibung. So entsteht ein leeres, öffentliches Repository. 

Projekt erstellen

Es gibt viele Wege, ein Remote-Repository lokal zu klonen. GitHub bietet eine ausführliche Anleitung zum Klonen, Hinzufügen von Remotes und Initialisieren eines Git-Projekts.  

GitHub-Klon

Wir können das Repository einfach per HTTPS-Link klonen. Wechsle vorher im Command Prompt oder in PowerShell in dein Arbeitsverzeichnis. 

git clone https://github.com/kingabzpro/DataCamp-Git.git

>>> Cloning into 'DataCamp-Git'...
>>> warning: You appear to have cloned an empty repository.

cd .\DataCamp-Git\

ODER

Erstelle ein neues Verzeichnis namens “DataCamp-Git” und initialisiere Git. Füge anschließend das Remote-Repository hinzu, um deine Arbeit mit GitHub zu synchronisieren.

mkdir DataCamp-Git
cd .\DataCamp-Git
git init

>>> Initialized empty Git repository in C:/Repository/GitHub/DataCamp-Git/.git/

git remote add origin https://github.com/kingabzpro/DataCamp-Git.git

ODER

Wenn du bereits ein Projektverzeichnis hast, initialisiere Git mit `git init` und füge GitHub wie oben als Remote hinzu. 

Einfacher Commit

Bevor wir Dateien hinzufügen, stelle sicher, dass du im richtigen lokalen Verzeichnis bist. 

Wir starten simpel und erstellen eine README-Datei mit der Überschrift DataCamp-Git. Danach fügen wir sie mit `git add` zum Staging hinzu. 

echo "# DataCamp-Git" >> README.md
git add README.md

Git status zeigt, dass wir auf dem main-Branch sind und die Datei `README.md` gestagt und bereit zum Committen ist.  

git status

>>> On branch main
>>> No commits yet
>>> Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   README.md

Für den ersten Commit verwenden wir `git commit` mit einer Nachricht. Wie zu sehen ist, wurde der erste Commit unter dem Hash ed9c886 hinzugefügt.

git commit -m "first commit"

>>> [main (root-commit) ed9c886] first commit
>>> 1 file changed, 1 insertion(+)
>>> create mode 100644 README.md

Projektdateien hinzufügen

Wir nutzen den DataCamp-Workspace MasterCard Stock Price with LSTM and GRU und laden die Dateien herunter. Die Autorin bzw. der Autor hat die Daten vorverarbeitet und Zeitreihen mit LSTM- und GRU-Modellen trainiert. Mehr dazu im Recurrent Neural Network Tutorial (RNN).

Um das Modell zu speichern, fügen wir im Jupyter-Notebook des Projekts eine neue Codezelle hinzu. Das Skript erstellt ein Verzeichnis “model” und speichert die LSTM- und GRU-Modelle. 

!mkdir -p model
model_lstm.save('model/LSTM')
model_gru.save('model/GRU')

Wie zu sehen ist, enthält das Git-Repository einen data-Ordner mit CSV-Dateien und einen model-Ordner mit Modellgewichten und Metadaten. 

Jetzt stagen wir alle Dateien. Du kannst nach dem Befehl beliebige Verzeichnisse, Dateien oder Daten angeben. 

git add .\data .\model LSTM_GRU.ipynb RNN.png

ODER

Wenn du alle Dateien stagen willst, nutze den Punkt. 

git add .

Commit und Push

Wir committen alle Änderungen mit einer kurzen Nachricht. Die Ausgabe zeigt alle neuen Dateien im create-Mode. 

git commit -m "project files added"

>>> [main aa3e19a] project files added
>>>  10 files changed, 5020 insertions(+)
>>>  create mode 100644 LSTM_GRU.ipynb
>>>  create mode 100644 RNN.png
>>>  create mode 100644 data/Mastercard_stock_history.csv
>>>  create mode 100644 data/Mastercard_stock_info.csv
>>>  create mode 100644 model/GRU/saved_model.pb
>>>  create mode 100644 model/GRU/variables/variables.data-00000-of-00001
>>>  create mode 100644 model/GRU/variables/variables.index
>>>  create mode 100644 model/LSTM/saved_model.pb
>>>  create mode 100644 model/LSTM/variables/variables.data-00000-of-00001
create mode 100644 model/LSTM/variables/variables.index

Zum Synchronisieren mit dem GitHub-Remote brauchst du Remotenamen und Branch: `git push <remote-name> <branch-name>`. Wenn es nur ein Remote und einen Branch gibt, reicht `git push`.  

Nach `git push` fragt ein Dialog nach Anmeldedaten. Gib deinen GitHub-Benutzernamen und dein Passwort ein. Alternativ kannst du Personal Access Tokens erzeugen und anstelle des Passworts nutzen. Mehr dazu im Git Push and Pull Tutorial.

git push

>>> Enumerating objects: 21, done.
>>> Counting objects: 100% (21/21), done.
>>> Delta compression using up to 4 threads
>>> Compressing objects: 100% (19/19), done.
>>> Writing objects: 100% (21/21), 1.83 MiB | 1.59 MiB/s, done.
>>> Total 21 (delta 2), reused 0 (delta 0), pack-reused 0
>>> remote: Resolving deltas: 100% (2/2), done.
>>> To https://github.com/kingabzpro/DataCamp-Git.git
>>>  * [new branch]      main -> main

Wir prüfen nun unser GitHub-Repository kingabzpro/DataCamp-Git, ob die Änderungen erfolgreich gepusht wurden. Das Repository enthält alle Dateien, Daten und Modelle.

Remote-Push zu GitHub

Git-Branches

Es empfiehlt sich, mit Branches zu arbeiten: Möchtest du z. B. an der Projektdokumentation arbeiten, erstelle einen Branch namens documentation mit git checkout oder git branch. Nimm Änderungen an der README vor und merge sie nach Abschluss in den Basis-Branch. 

In unserem Fall haben wir einen neuen Branch readme erstellt und dorthin gewechselt.

git checkout -b readme

Lass uns die README erweitern, das Projekt beschreiben und den RNN-Workspace und das Tutorial verlinken. Danach stagen wir die Änderungen und sichern sie mit einer Commit-Nachricht.

git add README.md
git commit -m "project description and links to blog"

>>> [readme f3b8b9b] project description and links to blog
>>>  1 file changed, 8 insertions(+)

Im Remote-Repository existiert noch kein readme-Branch. Um ihn zu erstellen und die Änderungen zu pushen, verwenden wir “readme:readme”. Die Ausgabe zeigt, dass der neue Branch erstellt wurde und lokale und Remote-Branches synchron sind. 

git push origin readme:readme
>>> remote: Resolving deltas: 100% (1/1), completed with 1 local object.
>>> remote: Create a pull request for 'readme' on GitHub by visiting:
>>> remote:  https://github.com/kingabzpro/DataCamp-Git/pull/new/readme
>>> remote:
To https://github.com/kingabzpro/DataCamp-Git.git
>>>  * [new branch]      readme -> readme

Du siehst, dass wir den lokalen Branch erfolgreich mit einer geänderten README.md nach GitHub gepusht haben. 

Readme-Branch auf GitHub

Pull Request

Diese Funktion ist vor allem in Organisationen üblich. Beispiel: Eine Entwicklerin hat ein neues Feature gebaut und möchte die Änderungen in den main-Branch mergen. Wir erstellen den Pull Request über die GitHub-Oberfläche: Klicke auf Pull Request, wähle den Branch readme und als Basis main. Beschreibe die Änderungen und erstelle den Pull Request. 

Pull Request von readme zu main

Die Maintainer vergleichen deine Änderungen und mergen sie, sobald alle Tests bestanden sind. In unserem Fall bist du Maintainer: Klicke auf Merge, um die Änderungen in den main-Branch zu übernehmen. 

Merge Pull Request auf GitHub

Glückwunsch, der Pull Request wurde erstellt und mit dem main-Branch zusammengeführt. Du kannst die Änderungen im main-Branch hier ansehen. 

Wenn du alle Änderungen im Repository einsehen willst, tippe `git log`. Der Befehl zeigt die Historie deines Projekts. Logging ist in Data-Science-Projekten wichtig, und Git hilft, alle Änderungen zu verfolgen – auch bei großen Datensätzen. 

Historie der Git-Logs

Fazit

GitOps sind entscheidend für die Entwicklung von Datenanwendungen. Sie gehören heute zu den Kernkompetenzen in IT-Jobs; selbst Forschende in der Wissenschaft nutzen sie, um Experiment-Code einer breiten Öffentlichkeit zugänglich zu machen. GitHub spielt dabei eine große Rolle, indem es allen ein kostenloses Entwicklungsökosystem für Open Source bereitstellt. 

In diesem Tutorial hast du Git und GitHub kennengelernt und erfahren, warum beide für Data-Science-Projekte wichtig sind. Außerdem hast du grundlegende Git-Befehle gesehen und praktisch geübt, wie man Änderungen an Daten, Modellen und Code nachverfolgt. Wenn du mehr über Git lernen möchtest, besuche den Kurs Introduction to Git auf DataCamp. Erfahre auch, warum die GitHub Foundations-Zertifizierung wichtig ist und wie sie deiner Karriere hilft.