Notebookuri Jupyter

Notebookurile sunt bancul de lucru al ingineriei IA. Aici creați prototipuri, apoi transferați în producție soluțiile care funcționează.

Tip: Construire Limbaje: Python Cerințe preliminare: Faza 0, lecția 01 Durată: ~30 de minute

Obiective de învățare

• Instalarea și lansarea JupyterLab, Jupyter Notebook sau VS Code cu extensia Jupyter
• Utilizarea comenzilor magice (magic commands: %timeit, %%time, %matplotlib inline) pentru măsurarea performanței și afișarea vizualizărilor direct în notebook
• Diferențierea situațiilor în care se folosesc notebookuri de cele în care se folosesc scripturi și aplicarea fluxului de lucru „explorați în notebookuri, livrați prin scripturi”
• Identificarea și evitarea capcanelor frecvente ale notebookurilor: execuția în altă ordine, starea ascunsă și scurgerile de memorie

Problema

Fiecare lucrare despre IA, tutorial și competiție Kaggle utilizează notebookuri Jupyter. Acestea vă permit să rulați codul pe fragmente, să vedeți rezultatele direct în document, să combinați codul cu explicații și să iterați rapid. Dacă încercați să învățați IA fără notebookuri, este ca și cum v-ați face temele la matematică fără ciornă.

Notebookurile au însă capcane reale. Oamenii le folosesc pentru orice, inclusiv pentru activități la care sunt foarte nepotrivite. Dacă știți când să utilizați un notebook și când să utilizați un script, veți evita ulterior adevărate coșmaruri de depanare.

Conceptul

Un notebook este o listă de celule. Fiecare celulă conține fie cod, fie text.

Kernelul este un proces Python activ în fundal. Când rulați o celulă, aceasta trimite codul către kernel, care îl execută și returnează rezultatul. Toate celulele folosesc același kernel, așadar variabilele se păstrează de la o celulă la alta.

Această posibilitate de a rula celulele în orice ordine este atât superputerea notebookului, cât și o capcană periculoasă.

Construirea soluției

Pasul 1: alegeți interfața

Trei opțiuni, un singur format:

Interfață	Instalare	Potrivită pentru
JupyterLab	pip install jupyterlab, apoi jupyter lab	Experiență IDE completă, mai multe file, browser de fișiere, terminal
Jupyter Notebook	pip install notebook, apoi jupyter notebook	Utilizare simplă, cu puține resurse, câte un notebook pe rând
VS Code	Instalați extensia „Jupyter”	Lucru direct în editorul pe care îl folosiți deja, integrare cu git, depanare

Toate cele trei interfețe citesc și scriu același format de fișier .ipynb. Alegeți-o pe cea preferată. JupyterLab este cea mai răspândită în activitatea cu IA.

pip install jupyterlab
jupyter lab

Pasul 2: comenzile rapide de la tastatură care contează

Lucrați în două moduri. Apăsați Escape pentru modul de comandă (bara albastră din stânga) și Enter pentru modul de editare (bara verde).

Modul de comandă (cel mai utilizat):

Tastă	Acțiune
Shift+Enter	Rulați celula și treceți la următoarea
A	Inserați o celulă deasupra
B	Inserați o celulă dedesubt
DD	Ștergeți celula
M	Convertiți în Markdown
Y	Convertiți în cod
Z	Anulați operația asupra celulei
Ctrl+Shift+H	Afișați toate comenzile rapide

Modul de editare:

Tastă	Acțiune
Tab	Completați automat
Shift+Tab	Afișați semnătura funcției
Ctrl+/	Activați sau dezactivați comentariul

Veți folosi Shift+Enter de o mie de ori pe zi. Învățați mai întâi această combinație.

Pasul 3: tipuri de celule

Celulele de cod execută instrucțiuni Python și afișează rezultatul:

import numpy as np
data = np.random.randn(1000)
data.mean(), data.std()

Rezultat: (0.0032, 0.9987)

Celulele Markdown afișează text formatat. Folosiți-le pentru a documenta ce faceți și de ce. Acestea acceptă titluri, text aldin, text cursiv, formule matematice LaTeX ($E = mc^2$), tabele și imagini.

Pasul 4: comenzi magice

Acestea nu sunt instrucțiuni Python. Sunt comenzi specifice Jupyter care încep cu % (comandă magică pentru o linie) sau %% (comandă magică pentru o celulă).

Măsurați timpul de execuție al codului:

%timeit np.random.randn(10000)

Rezultat: 45.2 us +/- 1.3 us per loop

%%time
model.fit(X_train, y_train, epochs=10)

Rezultat: Wall time: 2.34 s

%timeit execută codul de mai multe ori și calculează media. %%time îl execută o singură dată. Folosiți %timeit pentru microbenchmarkuri și %%time pentru rulările de antrenare.

Activați afișarea graficelor direct în notebook:

%matplotlib inline

Fiecare apel plt.plot() sau plt.show() va afișa acum rezultatul direct în notebook.

Instalați pachete fără să părăsiți notebookul:

!pip install scikit-learn

Prefixul ! permite executarea oricărei comenzi shell.

Verificați variabilele de mediu:

%env CUDA_VISIBLE_DEVICES

Pasul 5: afișați conținut complex direct în notebook

Notebookurile afișează automat rezultatul ultimei expresii dintr-o celulă. Puteți însă controla acest comportament:

import pandas as pd

df = pd.DataFrame({
    "model": ["Linear", "Random Forest", "Neural Net"],
    "accuracy": [0.72, 0.89, 0.94],
    "training_time": [0.1, 2.3, 45.6]
})
df

Astfel se afișează un tabel HTML formatat, nu o simplă reprezentare text. Același lucru este valabil și pentru grafice:

import matplotlib.pyplot as plt

plt.figure(figsize=(8, 4))
plt.plot([1, 2, 3, 4], [1, 4, 2, 3])
plt.title("Inline Plot")
plt.show()

Graficul apare imediat sub celulă. De aceea notebookurile domină activitatea în domeniul IA: vedeți împreună datele, graficul și codul.

Pentru imagini:

from IPython.display import Image, display
display(Image(filename="architecture.png"))

Pasul 6: Google Colab

Colab este un notebook Jupyter gratuit, disponibil în cloud. Vă oferă un GPU, biblioteci preinstalate și integrare cu Google Drive. Nu necesită nicio configurare.

1. Accesați colab.research.google.com
2. Încărcați orice fișier .ipynb din acest curs
3. Runtime > Change runtime type > T4 GPU (free)

Diferențe între Colab și Jupyter local:

• Fișierele nu se păstrează între sesiuni (salvați-le în Drive sau descărcați-le)
• Biblioteci preinstalate: numpy, pandas, matplotlib, torch, tensorflow, sklearn
• from google.colab import files pentru încărcarea și descărcarea fișierelor
• from google.colab import drive; drive.mount('/content/drive') pentru stocare persistentă
• Sesiunile expiră după 90 de minute de inactivitate (nivelul gratuit)

Utilizarea soluției

Notebookuri sau scripturi: când se folosește fiecare variantă

Folosiți notebookuri pentru	Folosiți scripturi pentru
Explorarea unui set de date	Fluxuri de antrenare
Prototiparea unui model	Utilitare reutilizabile
Vizualizarea rezultatelor	Orice conține if __name__
Explicarea activității	Cod cu execuție programată
Experimente rapide	Cod de producție
Exercițiile cursului	Pachete și biblioteci

Regula este: explorați în notebookuri, livrați prin scripturi.

Un flux de lucru obișnuit în domeniul IA:

1. Explorați datele într-un notebook
2. Prototipați modelul în notebook
3. După ce funcționează, mutați codul în fișiere .py
4. Importați din nou aceste fișiere .py în notebook pentru experimente ulterioare

Capcane frecvente

Execuția în altă ordine. Rulați celula 5, apoi celula 2, apoi celula 7. Notebookul funcționează pe calculatorul dumneavoastră, dar eșuează când este rulat de altcineva de sus în jos. Soluție: înainte de a-l partaja, selectați Kernel > Restart & Run All.

Starea ascunsă. Ștergeți o celulă, însă variabila creată de aceasta rămâne în memorie. Notebookul pare ordonat, dar depinde de o celulă-fantomă. Soluție: reporniți kernelul cu regularitate.

Scurgerile de memorie. Încărcați un set de date de 4 GB, antrenați un model, apoi încărcați alt set de date. Memoria nu este eliberată. Soluție: utilizați del variable_name și gc.collect() sau reporniți kernelul.

Livrarea rezultatului

În urma acestei lecții obțineți:

• outputs/prompt-notebook-helper.md pentru depanarea problemelor legate de notebookuri

Exerciții

1. Deschideți JupyterLab, creați un notebook și utilizați %timeit pentru a evalua diferența dintre o list comprehension și numpy la crearea unui tablou cu 100.000 de numere aleatoare
2. Creați un notebook cu celule Markdown și celule de cod pentru încărcarea unui fișier CSV, afișarea unui dataframe și trasarea unui grafic. Apoi selectați Kernel > Restart & Run All pentru a confirma că funcționează de sus în jos
3. Preluați codul din code/notebook_tips.py, inserați-l într-un notebook Colab și rulați-l cu un GPU gratuit

Termeni-cheie

Termen	Cum este numit în mod obișnuit	Ce înseamnă de fapt
Kernel	„Componenta care îmi execută codul”	Un proces Python separat, care execută celulele și păstrează variabilele în memorie
Celulă	„Un bloc de cod”	O unitate dintr-un notebook care poate fi rulată independent și conține cod sau Markdown
Comandă magică	„Trucuri Jupyter”	Comenzi speciale prefixate cu % sau %%, care controlează mediul notebookului
.ipynb	„Fișier notebook”	Un fișier JSON care conține celule, rezultate și metadate. Denumirea provine de la „IPython Notebook”

Lecturi suplimentare

• Documentația JupyterLab pentru setul complet de funcționalități
• Întrebări frecvente despre Google Colab pentru limitele și funcționalitățile specifice Colab
• 28 de sfaturi pentru Jupyter Notebook pentru comenzile rapide destinate utilizatorilor avansați

---

Sursă: Jupyter Notebooks — original; adresa exactă este indicată în metadatele paginii. Navigare: înapoi: 00.04 — API-uri și chei · Faza 0 — Configurare și instrumente · Catalog complet · în continuare: 00.06 — Medii Python.