Hvordan konfigurerer man et specifikt Python-miljø med en Jupyter-notesbog?

/ / Udgivet i Kunstig intelligens, EITC/AI/GCML Google Cloud Machine Learning, Yderligere trin i maskinindlæring, Arbejder med Jupyter

Konfiguration af et specifikt Python-miljø til brug med Jupyter Notebook er en grundlæggende praksis inden for datalogi, maskinlæring og kunstig intelligens-arbejdsgange, især når man udnytter Google Cloud Machine Learning (AI Platform)-ressourcer. Denne proces sikrer reproducerbarhed, afhængighedsstyring og isolering af projektmiljøer. Den følgende omfattende vejledning behandler konfigurationstrinnene, rationalet og bedste praksis for oprettelse og integration af et Python-miljø med Jupyter Notebook med fokus på praktisk anvendelse inden for rammerne af maskinlæring på cloudbaseret infrastruktur.

1. Forståelse af Python-miljøer

Et Python-miljø er et isoleret arbejdsområde, der giver brugerne mulighed for at installere og administrere pakker uafhængigt af den systemomfattende Python-installation. Denne isolation er afgørende for at administrere afhængigheder for forskellige projekter, undgå versionskonflikter og sikre, at udviklings- og produktionsmiljøer forbliver ensartede.

Almindelige værktøjer til at oprette isolerede Python-miljøer inkluderer:
- virtualenvOpretter lette Python-miljøer.
- venvStandardbiblioteksmodulet til oprettelse af virtuelle miljøer (Python 3.3+).
- CondaEn pakke-, afhængigheds- og miljøadministrator, der understøtter flere sprog.

Til maskinlæringsprojekter på Google Cloud anvendes `virtualenv` og `conda` i vid udstrækning, hvor `conda` ofte foretrækkes på grund af dens nemme håndtering af både Python- og ikke-Python-afhængigheder.

2. Oprettelse af et Python-miljø

Brug af virtualenv

1. Installer virtualenv (hvis ikke til stede):

bash
   pip install virtualenv

2. Opret et nyt miljø:

bash
   virtualenv my_ml_env

3. Aktiver miljøet:
– På Linux/macOS:

bash
     source my_ml_env/bin/activate

– På Windows:

bash
     my_ml_env\Scripts\activate

4. Bekræft aktivering:
Shell-prompten ændres for at angive det aktive miljø (f.eks. `(my_ml_env)`).

Brug af conda

1. Opret et nyt miljø med en specifik Python-version:

bash
   conda create -n my_ml_env python=3.10

2. Aktiver miljøet:

bash
   conda activate my_ml_env

3. Liste over miljøer (valgfrit):

{{EJS35}}
3. Installation af nødvendige pakker


Efter aktivering af det ønskede miljø skal du installere nødvendige pakker, såsom `jupyter`, maskinlæringsbiblioteker (`scikit-learn`, `tensorflow`, `pandas` osv.) og eventuelle andre afhængigheder.

Eksempel med pip:

bash
pip install jupyter numpy pandas scikit-learn matplotlib

Eksempel med conda:
bash
conda install jupyter numpy pandas scikit-learn matplotlib

For GPU-understøttelse (f.eks. TensorFlow-GPU), angiv de relevante versioner:
{{EJS38}}
4. Integration af miljøet med Jupyter Notebook


For at bruge det nyoprettede miljø som en Jupyter-kerne, skal pakken `ipykernel` installeres i miljøet. Dette gør det muligt for Jupyter Notebook at genkende og starte kerner med de præcise afhængigheder og Python-versioner, der er angivet. 1. Installer ipykernel i det aktive miljø:
   
bash
   pip install ipykernel
   
 or
bash
   conda install ipykernel
   
2. Opret en ny Jupyter-kerne til miljøet:
bash
   python -m ipykernel install --user --name my_ml_env --display-name "Python (my_ml_env)"
   
 - `--user`: Installerer kernen for den aktuelle bruger.
 - `--name`: Intern identifikator for kernen.
 - `--display-name`: Navnet vist i Jupyter Notebooks kernevalgmenu.
3. Bekræft kerneinstallation:
 Start Jupyter Notebook:
bash
   jupyter notebook
   
 Under "Kernel" > "Skift kerne" burde "Python (my_ml_env)" vises som en mulighed.
5. Eksempel på arbejdsgang
Trin 1: Opret og aktiver miljøet
{{EJS43}}
Trin 2: Installer pakker


{{EJS44}}
Trin 3: Tilføj miljø som Jupyter-kerne


{{EJS45}}
Trin 4: Start Jupyter Notebook og vælg kernel


bash
jupyter notebook

- I notesbogens brugerflade skal du vælge "Kernel" > "Skift kerne" > "Python (GCP ML Env)".
Trin 5: Kør kode i det isolerede miljø
python
import sys
import tensorflow as tf
print(sys.executable)
print(tf.__version__)

- Dette bekræfter, at din bærbare computer kører i det tilsigtede miljø og med de korrekte pakkeversioner.
6. Håndtering af flere miljøer
Når du arbejder på flere maskinlæringsprojekter med forskellige afhængigheder eller Python-versioner, skal du gentage ovenstående proces for hvert projekt. Hvert miljø skal oprettes, aktiveres og registreres uafhængigt som en Jupyter-kerne.
Sådan fjerner du en Jupyter-kerne:
bash
jupyter kernelspec uninstall <kernel_name>

Sådan fjerner du et conda-miljø:
{{EJS49}}
7. Brug af miljøer med Google Cloud Machine Learning


Google Clouds AI Platform Notebooks giver brugerne mulighed for at starte JupyterLab- eller Jupyter Notebook-servere på brugerdefinerede virtuelle maskininstanser. Disse instanser kan yderligere konfigureres via SSH eller terminaladgang for at oprette og administrere brugerdefinerede Python-miljøer som beskrevet ovenfor.

Bedste praksis:
- Brug opstartsscripts eller Docker-containere til at automatisere miljøopsætning på Google Cloud-instanser for at opnå ensartet reproducerbarhed. - Overvej at bruge Docker-containere med Jupyter Notebook og det nødvendige miljø forudinstalleret for avanceret isolering.

8. Eksport og deling af miljøer


Sådan deler du miljøer eller sikrer reproducerbarhed:

Med pip (virtualenv eller venv)


Eksport:

bash
pip freeze > requirements.txt

Importere:
{{EJS51}}
Med konda


Eksport:

bash
conda env export > environment.yml

Importere:
bash
conda env create -f environment.yml

Hvis du deler `requirements.txt`- eller `environment.yml`-filen sammen med dine Jupyter-notesbøger, kan samarbejdspartnere genskabe det præcise miljø.
9. Fejlfinding af almindelige problemer
- Kernen vises ikke: Sørg for at `ipykernel` er installeret i det aktive miljø, og at `python -m ipykernel install` er blevet udført.
 - Afhængighedskonflikter: Brug virtuelle miljøer eller conda-miljøer for at undgå versionsforskelle.
 - GPU support: Installer de korrekte versioner af biblioteker (f.eks. TensorFlow-GPU) og bekræft CUDA/cuDNN-installationen.
 - Cloud-tilladelser: Når du arbejder i Google Cloud, skal du sørge for tilstrækkelige tilladelser til at installere pakker og oprette miljøer.
10. Bedste praksis og anbefalinger
- Isoler miljøer pr. projekt for at forhindre afhængighedskonflikter og forbedre reproducerbarheden.
 - Pin-pakkeversioner i dine miljøfiler for nøjagtig replikering.
 - Opdater miljøer regelmæssigt og test med din kode for at sikre kompatibilitet.
 - Opsætning af dokumentmiljø trin i projektdokumentationen.
11. Eksempel: Fuld konfiguration på Google Cloud AI Platform Notebook
Antag, at en bruger arbejder på et maskinlæringsprojekt, der kræver TensorFlow 2.9, scikit-learn 1.1 og pandas 1.4, og projektet hostes på en Google Cloud AI Platform Notebook. Trinene kan være:
1. Åbn en terminal i JupyterLab-grænsefladen.
 2. Opret et nyt conda-miljø:
bash
   conda create -n mygcpml python=3.8
   conda activate mygcpml
   
3. Installer nødvendige pakker:
bash
   conda install tensorflow=2.9 scikit-learn=1.1 pandas=1.4 ipykernel
   
4. Tilføj miljøet som en Jupyter-kerne:
bash
   python -m ipykernel install --user --name mygcpml --display-name "Python (My GCP ML)"
   
5. Genstart JupyterLab/Notebook og vælg den nye kerne.
 6. Bekræft miljø:
python
   import tensorflow as tf
   import sklearn
   import pandas as pd
   print(tf.__version__, sklearn.__version__, pd.__version__)
   
Denne tilgang sikrer, at eksperimenter, modeller og dataanalyse kører i et kontrolleret, reproducerbart og isoleret miljø, hvilket minimerer sandsynligheden for problemer med "virker på min maskine" og letter cloudbaseret samarbejde.
Andre seneste spørgsmål og svar vedr EITC/AI/GCML Google Cloud Machine Learning:
Se flere spørgsmål og svar i EITC/AI/GCML Google Cloud Machine Learning
Flere spørgsmål og svar:
Tagged under: , , , , ,