Hur man laddar ner och installerar Tensorflow i Jupyter Notebook

⚡ Smart sammanfattning

TensorFlow installeras smidigt i en isolerad Anaconda-miljö, vilket håller Python, Jupyter och ramverket löser upp sig till en enda sökväg och förhindrar versionskrockar med alla andra dataprojekt som redan finns på samma maskin.

  • 🔘 Välj en version: CPU-paketet passar de flesta inlärningsuppgifter; GPU-bygget behöver ett NVIDIA-kort.
  • ☑️ Isolera först: En conda-miljö som deklareras i en .yml-fil håller beroenden reproducerbara.
  • ✅ Windows extra: Windows förbereder först miljön och lägger sedan till TensorFlow med pip install tensorflow.
  • 🧪 Verifiera sökvägen: Python, Jupyter och Ipython måste alla lösas i samma miljö.
  • 🛠️ Importtest: importera tensorflow som tf följt av tf.constant bevisar att installationen fungerar.
  • 🔒 Återaktivera: Varje ny session behöver conda-aktivering hello-tf innan Jupyter startar.

Ladda ner och installera TensorFlow i Jupyter Notebook

Installera TensorFlow med Anaconda on Windows or macOS tar en conda-miljö och några kommandon. Du kommer också att lära dig hur man importerar TensorFlow inuti Jupyter Notebook, det webbläsarbaserade anteckningsboksvisaren.

TensorFlow-versioner

TensorFlow stöder beräkningar över flera CPU:er och GPU:er. Det innebär att beräkningarna kan fördelas över enheter för att förbättra träningshastigheten. Med parallellisering behöver du inte vänta i veckor för att få resultaten av träningsalgoritmer.

För Windows För användare erbjuder TensorFlow två byggvarianter:

  • TensorFlow med endast CPU-stödOm din maskin inte har någon NVIDIA GPU, installera den här versionen.
  • TensorFlow med GPU-stödSnabbare för träning, men värt installationen bara när du behöver verklig beräkningskapacitet.

Under den här handledningen räcker det med grundversionen av TensorFlow. Tabellen nedan jämför de två versionerna:

Kriterium CPU-bygge GPU-bygge
Paket tensorflöde (CPU-hjul) tensorflöde med CUDA-körtid
hårdvara Valfri x86- eller ARM-processor NVIDIA-kort med stöd för CUDA
Bäst för Handledningar, små modeller Stora träningspass
Installationsarbete Ett kommando Matchning av drivrutin, CUDA och cuDNN

Versionsinformation: TensorFlow 2.10 var den senaste utgåvan med nativa funktioner Windows GPU-stöd. Från och med 2.11, Windows Användare kör GPU-bygget inuti WSL2 eller installerar CPU-paketet. Apple Silicon Macs lägger till tensorflow-metal för acceleration.

Obs: TensorFlow erbjuder inte CUDA GPU-stöd på macOS.

Så här går du tillväga

macOS användare:

  • Installera Anaconda
  • Skapa en .yml-fil för att installera TensorFlow och beroenden
  • Starta Jupyter Notebook

Windows användare:

  • Installera Anaconda
  • Skapa en .yml-fil för att installera beroenden
  • Använd pip för att lägga till TensorFlow
  • Starta Jupyter Notebook

Att köra TensorFlow med Jupyter, skapa en dedikerad miljö inuti Anaconda Holding IPython, Jupyter och TensorFlow. Lägg till en viktig datavetenskap även biblioteket: pandor, som manipulerar dataramar.

Installera Anaconda

Ladda ner Anakonda version 4.3.1 (för Python 3.6) för lämpligt system.

Dessa versioner är äldre: nuvarande TensorFlow 2.x parar ihop med Python 3.9 till 3.12. Sedan 2024 kräver Anacondas standardkanal även en betald licens för organisationer över 200 personer, så Miniconda eller Miniforge med conda-forge är den kostnadsfria vägen.

Anaconda hanterar de bibliotek som krävs för Python or Roch installerar dem sedan per miljö.

Skapa .yml-fil för att installera TensorFlow och beroenden

Det inkluderar

  • Hitta Anacondas väg
  • Ställ in arbetskatalogen till Anaconda
  • Skapa yml-filen (för MacOS-användare installeras TensorFlow här)
  • Redigera yml-filen
  • Kompilera yml-filen
  • Aktivera Anaconda
  • Installera TensorFlow (Windows endast användare)

Steg 1) Hitta Anaconda,

Det första steget du behöver göra är att hitta vägen till Anaconda.

Du kommer att skapa en conda-miljö som innehåller de bibliotek som används i TensorFlow-handledningarna.

Windows

Om du är en Windows användare kan du använda Anaconda Prompt och skriva:

C:\>where anaconda

Anaconda Prompt utdata för kommandot where anaconda på Windows

Vi är intresserade av att veta namnet på mappen där Anaconda är installerat eftersom vi vill skapa vår nya miljö i den här sökvägen. På bilden ovan ligger Anaconda i administratörsmappen; din kommer att ha ditt eget användarnamn.

Nästa steg är att flytta arbetskatalogen från c:\ till Anaconda3.

MacOS

För macOS användare, öppna terminalen och skriv:

which anaconda

Terminalutgången för vilket anaconda-kommando på macOS

Du skapar nu en mapp i Anaconda som kommer att innehålla IPython, Jupyter och TensorFlowDet snabbaste sättet att deklarera dessa bibliotek är en yml-fil.

Steg 2) Ställ in arbetskatalog

Ange arbetskatalogen där yml-filen ska skapas; som nämnts ovan finns den inuti Anaconda.

För macOS användare:

Terminalen är som standard inställd på Användare/ANVÄNDARNAMNI figuren nedan matchar anaconda3-sökvägen och arbetskatalogen; macOS visar den aktuella mappen före $. Alla bibliotek installeras där.

Om sökvägen i din textredigerare inte matchar, kör cd PATH i terminalen och citera sökvägen när den innehåller mellanslag.

macOS Terminal som visar anaconda3-sökvägen som arbetskatalog

Öppna din terminal och skriv:

cd anaconda3

För Windows användare, kontrollera mappen som kommer före Anaconda3:

cd C:\Users\Admin\Anaconda3

eller sökvägen "där anaconda"-kommandot ger dig

Windows prompt efter att katalogen har ändrats till Anaconda3

Steg 3) Skapa yml-filen

Du kan skapa yml-filen i den nya arbetskatalogen.

Filen kommer att installera de beroenden du behöver för att köra TensorFlow. Kopiera och klistra in den här koden i terminalen.

För MacOS-användare:

touch hello-tf.yml

En ny fil med namnet hello-tf.yml bör visas inuti anaconda3

macOS Terminal skapar hello-tf.yml med touch-kommandot

För Windows användare:

echo.>hello-tf.yml

En ny fil med namnet hello-tf.yml bör visas

Windows prompt skapa hello-tf.yml med echo-kommandot

Steg 4) Redigera yml-filen

Du är redo att redigera yml-filen.

För MacOS-användare:

Du kan klistra in följande kod i terminalen för att redigera filen. MacOS-användare kan använda vim för att redigera yml-filen.

vi hello-tf.yml

Hittills ser din terminal ut så här

Terminal som öppnar hello-tf.yml i vi-editorn

Du anger en redigera läge. I detta läge kan du, efter att ha tryckt på esc:

  • Tryck på i för att börja redigera
  • Tryck på esc och skriv sedan :w för att spara
  • Tryck på esc och skriv sedan :q! för att avsluta utan att spara

Skriv följande kod i redigeringsläget och tryck på esc följt av :w

hello-tf.yml beroendelista inskriven i vi

Obs: Filen är case och indragningskänslig. Två mellanslag krävs för varje indragningsnivå.

För MacOS

name: hello-tf
dependencies:
 - python=3.6
 - jupyter
 - ipython
 - pandas
 - pip:
 - https://storage.googleapis.com/tensorflow/MacOS/cpu/tensorflow-1.5.0-py3-none-any.whl

Code Förklaring

  • namn: hello-tf: Namn på yml-filen
  • beroenden:
  • python=3.6
  • jupyter
  • pytonorm
  • pandor: Installera Python 3.6 Jupyter, JagPython och pandor.
  • pip: Installera en Python
    • Hjulet URLinstallera TensorFlow direkt från Google lagrings-API.

Tryck esc följt av :q! för att lämna redigeringsläget.

Sparad hello-tf.yml-fil visas efter att ha lämnat vi

För Windows Användare:

Windows har ingen vim, så Anteckningar räcker för det här steget.

notepad hello-tf.yml

Ange följande i filen

name: hello-tf
dependencies:
 - python=3.6
 - jupyter
 - ipython
 - pandas

Code Förklaring

  • namn: hello-tf: Namn på yml-filen
  • beroenden:
  • python=3.6
  • jupyter
  • pytonorm
  • pandor: Installera Python 3.6 Jupyter, JagPython och pandor.

Det kommer att öppna anteckningsblocket, du kan redigera filen härifrån.

hello-tf.yml öppnades i Windows Anteckningar

Obs: Windows användare installerar TensorFlow i nästa steg; här förbereder du bara conda-miljön.

Steg 5) Kompilera yml-filen

Kompilera .yml-filen med följande kommando:

conda env create -f hello-tf.yml

Obs: För Windows användare skapas den nya miljön i den aktuella användarkatalogen.

Det tar tid och ungefär 1.1 GB diskutrymme.

conda env skapar utdata som löser hello-tf-beroendena på macOS

In Windows

conda env skapar utdata som löser hello-tf-beroendena på Windows

Steg 6) Aktivera conda-miljön

Du har nu två konda-miljöer.

En isolerad miljö rekommenderas, eftersom varje maskininlärning Projektet behöver en annan biblioteksuppsättning, och du kan ta bort den när projektet avslutas.

conda env list

conda env-lista som visar base- och hello-tf-miljöerna

Asterisken markerar den aktiva miljön. Växla till hello-tf för att aktivera den. Moderna conda använder conda activate på alla plattformar; källkod activate är föråldrad.

För MacOS-användare:

source activate hello-tf

För Windows användare:

activate hello-tf

Terminalprompt efter aktivering av hello-tf-miljön

Bekräfta att alla beroenden löses inom samma miljö, så Python, Jupyter och TensorFlow delar ett prefix. Om de tre sökvägarna skiljer sig åt, bygg om miljön.

För MacOS-användare:

which python
which jupyter
which ipython

vilka python-, jupyter- och ipython-funktioner som löser inuti hello-tf macOS

Frivillig: Sök efter en uppdatering.

pip install --upgrade tensorflow

Steg 7) Installera TensorFlow For Windows användare

För Windows användare:

where python
where jupyter
where ipython

där python, jupyter och ipython löser upp sig inuti hello-tf på Windows

Två Python miljöer finns nu: basmiljön och hello-tf. Endast hello-tf bär TensorFlow. I bilden kopplas python, jupyter och ipython alla till samma miljö, så TensorFlow kan användas från en Jupyter Anteckningsbok.

Windows användare installerar TensorFlow med pip:

pip install tensorflow

pip install tensorflow-utdata i hello-tf-miljön

Hur man importerar TensorFlow till Jupyter Notebook

Den här delen är identisk på båda operativsystemen. Kom ihåg att miljön måste aktiveras varje gång innan du öppnar TensorFlow.

Du kommer att gå tillväga enligt följande:

  • Aktivera hello-tf conda-miljö
  • Öppet Jupyter
  • Importera TensorFlow
  • Ta bort anteckningsbok
  • Stäng Jupyter

Steg 1) Aktivera conda

För MacOS-användare:

source activate hello-tf

För Windows användare:

conda activate hello-tf

Aktivera hello-tf conda-miljön innan öppning Jupyter

Steg 2) Öppet Jupyter

Efter det kan du öppna Jupyter från terminalen

jupyter notebook

jupyter notebook-kommandot startar notebook-servern

Webbläsaren bör öppnas automatiskt; annars kopiera URL utskrivet av terminalen, vilket börjar med http://localhost:8888.

Instrumentpanelen listar alla filer i arbetskatalogen. Klicka på Nytt och Python 3 att skapa en anteckningsbok.

Obs: Den nya anteckningsboken sparas automatiskt i arbetskatalogen.

Jupyter instrumentpanelen med den nya och Python 3 meny öppen

Steg 3) Importera TensorFlow

Inuti anteckningsboken kan du importera TensorFlow in Jupyter Anteckningsbok med tf-aliaset. Klicka för att köra. En ny cell skapas nedan.

import tensorflow as tf

Notebook-cell som kör import tensorflow som tf

Låt oss skriva din första kod med TensorFlow.

hello = tf.constant('Hello, Guru99!')
hello

En ny tensor är skapad. Grattis, TensorFlow körs nu med Jupyter på din maskin.

Anteckningsbokscell som skapar Hej, Guru99 konstant tensor

Steg 4) Radera fil

Ta bort filen med namnet Untitled.ipynb från Jupyter instrumentbräda.

Tar bort Untitled.ipynb-filen från Jupyter instrumentbräda

Steg 5) Stäng Jupyter

Jupyter kan stängas från själva anteckningsboken eller från terminalen (Anaconda-prompten på Windows).

Från Jupyter

I huvudpanelen av Jupyter Anteckningsbok, klicka bara på Logga ut

Logga ut-knappen i Jupyter Huvudpanelen på den bärbara datorn

Du omdirigeras till utloggningssidan.

Jupyter bekräftelsesidan för utloggning

Från terminalen

Markera terminal- eller Anaconda-prompten och tryck två gånger på Ctrl+C.

Den första Ctrl+C-tangenten ber dig bekräfta avstängningen; den andra bekräftar det.

Terminalprompt som ber om att bekräfta avstängning av den bärbara datorservern

Terminalen efter Jupyter servern har stoppats

Du har loggat ut.

Jupyter med den huvudsakliga conda-miljön

För att starta TensorFlow med Jupyter i en framtida session, aktivera miljön först:

source activate hello-tf

Utan det steget, Jupyter startar i basmiljön och importen misslyckas.

Jupyter startade från bas-conda-miljön utan TensorFlow

Vanliga frågor

Stöd för de senaste TensorFlow-utgåvorna Python 3.9 till 3.12. Fäst versionen i din .yml-fil så att conda hittar ett matchande hjul och undviker Python nyare versioner än listan över versionsinformation.

TensorFlow levereras officiellt till PyPI, så pip install tensorflow inuti en conda-miljö är den väg som stöds. Använd conda för Python, Jupyter och pandor, och sedan pip för själva ramverket.

Kör tf.config.list_physical_devices('GPU') i en cell i en anteckningsbok. En tom lista betyder att CPU-versionen är aktiv eller att CUDA- och cuDNN-versionerna inte matchar versionskraven.

Kärnan i den bärbara datorn körs i en annan miljö. Aktivera hello-tf innan du startar. Jupyter, eller registrera miljön som en kärna med python -m ipykernel install –user –name hello-tf.

Kör conda env remove -n hello-tf från basmiljön. Inaktivera den först, bekräfta sedan med conda env list att posten är borta och att diskutrymmet har återvunnits.

Installera tensorflow i en nativ arm64-miljö och lägg sedan till tensorflow-metal-pluginet så att Keras använder Apples GPU. Rosetta-byggen körs men förlorar accelerationen helt.

Copilot utkastar .yml-filer, pip-kommandon och kärnregistreringskodavsnitt från en vanlig kommentar, vilket förkortar installationstiden. Versionskoderna behöver fortfarande kontrolleras mot de officiella versionsinformationerna innan du kör något.

Assistenter utarbetar nu träningsloopar, föreslår hyperparameterintervall och förklarar fel i anteckningsboken. Det snabbar upp maskininlärning iteration, även om utvärdering och datakvalitet förblir mänskliga beslut.

Sammanfatta detta inlägg med: