Jupyter Handledning för bärbar dator: Hur man installerar och använder Jupyter?

Vad är Jupyter anteckningsbok?

Jupyter Notebook är en webbapplikation med öppen källkod för att skriva och dela livekoder, ekvationer, visualiseringar med rika textelement. Det ger ett bekvämt sätt att skriva stycken, ekvationer, titlar, länkar och figurer för att köra dataanalys. Det är också användbart för att dela interaktiva algoritmer med din publik för undervisning eller demonstration.

Introduktion till Jupyter Notebook-app

Ocuco-landskapet Jupyter Notebook App är gränssnittet där du kan skriva dina skript och koder via din webbläsare. Appen kan användas lokalt, vilket innebär att du inte behöver tillgång till internet eller en fjärrserver.

Varje beräkning görs via en kärna. En ny kärna skapas varje gång du startar en Jupyter Anteckningsbok.

Nuvarande installationer levereras Notebook 7, byggt på JupyterLabb. jupyter notebook fungerar fortfarande, och båda läser samma sak .ipynb fil.

Mindergy på kontoret Jupyter Notebook

I sessionen nedan får du lära dig hur du använder Jupyter Anteckningsbok. Du kommer att skriva en enkel kodrad för att bekanta dig med miljön Jupyter.

Steg 1) Du lägger till en mapp i arbetskatalogen som kommer att innehålla alla anteckningsböcker du skapar under handledningarna om TensorFlow.

If Jupyter saknas, spring pip install notebook först, som den TensorFlow installationsguide gör. Öppna sedan terminalen och skriv

mkdir jupyter_tf
jupyter notebook

Code Förklaring

• mkdir jupyter_tf: Skapa en mapp med namnet jupyter_tf
• jupyter anteckningsbok: Öppna Jupyter webb-app

Steg 2) Du kan se den nya mappen i miljön. Klicka på mappen jupyter_tf.

Steg 3) Inuti den här mappen kommer du att skapa din första anteckningsbok. Klicka på knappen Nytt och Python 3.

Steg 4) Du är inne i Jupyter miljö. Hittills heter din anteckningsbok Untitled.ipynb. Detta är standardnamnet som ges av Jupyter. Låt oss byta namn på den genom att klicka på Fil och Byt namn

Du kan döpa om den till Introduction_jupyter

Inuti Jupyter Notebook-gränssnitt, du skriver kod, anteckningar eller text inuti celler.

Inuti en cell kan du skriva en enda rad kod.

eller flera rader. Jupyter läser koden en rad efter en annan.

Till exempel, om du skriver följande kod inuti en cell.

Det kommer att producera denna produktion.

Steg 5) Du är redo att skriva din första kodrad. Du kan se att cellen har två färger. Den gröna färgen betyder att du är i redigeringsläge.

Den blå färgen indikerar dock att du är med exekveringsläge.

Din första kodrad kommer att skrivas ut Guru99!. Inuti cellen kan du skriva

print("Guru99!")

Det finns två sätt att köra en kod i Jupyter:

• Klicka och kör
• Kortkommandon

För att köra koden kan du klicka på Cell och då Kör celler och välj nedan

Du kan se att koden är utskriven under cellen och en ny cell har dykt upp direkt efter utdata.

Ett snabbare sätt att köra en kod är att använda Kortkommandon. För att komma åt kortkommandon, gå till Hjälp och Kortkommandon

Nedan listan med genvägar för ett MacOS-tangentbord. Du kan redigera genvägarna i editorn.

Följande är genvägar till Windows

Skriv den här raden

print("Hello world!")

och prova kortkommandot. Alt+Enter kör cellen och infogar en ny tom cell nedanför.

Steg 6) Det är dags att stänga anteckningsboken. Gå till Fil och klicka på Stäng och stanna

Anmärkningar: Jupyter sparar automatiskt anteckningsboken med kontrollpunkt. Om du har följande meddelande:

Det betyder Jupyter har inte sparat filen sedan den senaste kontrollpunkten. Du kan spara anteckningsboken manuellt

Du kommer att omdirigeras till huvudpanelen. Du kan se att din anteckningsbok har sparats för en minut sedan. Du kan logga ut tryggt.

installera Jupyter Notebook med AWS

När en datauppsättning växer för mycket lokalt minne, flytta anteckningsboken till en molnserver. Nedan följer en steg-för-steg-process för att installera och köra Jupyter Anteckningsbok på AWS:

Om du inte har ett konto hos AWS, skapa ett gratis konto här..

Vi kommer att fortsätta enligt följande

• Del 1: Skapa ett nyckelpar
• Del 2: Skapa en säkerhetsgrupp
• Del 3: Starta instans
• Del 4: Installera Docker
• Del 5: Installera Jupyter
• Del 6: Stäng anslutning

Del 1: Skapa ett nyckelpar

Steg 1) Gå till Tjänster och finna EC2

Steg 2) I panelen och klicka på Nyckelpar

Steg 3) Klicka på Skapa nyckelpar

1. Du kan kalla det Docker-nyckel
2. Klicka på Skapa

En fil med namnet Docker_key.pem laddas ner.

Steg 4) Kopiera och klistra in den i mappnyckeln. Vi kommer att behöva det snart.

Endast för Mac OS-användare

Det här steget gäller endast Mac OS-användare. Windows och Linux-användare kan hoppa vidare till del 2.

Du måste ange en arbetskatalog som ska innehålla filnyckeln

Först av allt, skapa en mapp med namnet nyckel. För oss ligger den inuti huvudmappen Docker. Sedan ställer du in den här sökvägen som din arbetskatalog

mkdir Docker/key
cd Docker/key

Del 2: Skapa en säkerhetsgrupp

Steg 1) Du måste konfigurera en säkerhetsgrupp. Du kan komma åt den med panelen

Steg 2) Klicka på Skapa säkerhetsgrupp

Steg 3) På nästa skärm

1. Ange säkerhetsgruppens namn "jupyter_docker" och beskrivningen Säkerhetsgrupp för Docker.
2. Lägg till de fyra inkommande reglerna nedan:
   • ssh: portområde 22, source Anywhere
   • http: portintervall 80, källa Anywhere
   • https: portintervall 443, källa Anywhere
   • Anpassad TCP: portintervall 8888, källa var som helst
3. Klicka på Skapa.

Steg 4) Den nyskapade säkerhetsgruppen kommer att listas

Del 3: Starta instans

Du är äntligen redo att skapa instansen

Steg 1) Klicka på Starta instans

Standardservern räcker. Välj Amazon Linux AMI. Skärmdumpar visar bild 2018.03.0; nuvarande konsoler erbjuder Amazon Linux 2023, så matcha etiketter, inte pixlar.

AMI står för Amazon Maskinavbildning. Den innehåller den information som krävs för att starta en instans som körs på en virtuell server i molnet.

Observera att AWS har en server dedikerad för djupinlärning som:

• Deep Learning AMI (Ubuntu)
• Deep Learning AMI
• Deep Learning Base AMI (Ubuntu)

Alla levereras med nya binärfiler av djupinlärningsramverk förinstallerade i separata virtuella miljöer:

• TensorFlow,
• caffe
• PyTorch,
• Keras,
• Theano
• CNTK.

Varje avbildning är fullt konfigurerad med NVIDIA CUDA, cuDNN och NCCL samt Intel MKL-DNN.

Steg 2) Välja t2.microDet är en gratis server. AWS erbjuder gratis denna virtuella maskin utrustad med 1 vCPU och 1 GB minne. Denna server erbjuder en bra avvägning mellan beräkning, minne och nätverksprestanda. Den passar små och medelstora arbetsbelastningar.

Steg 3) Behåll standardinställningarna på nästa skärm och klicka på Nästa: Lägg till lagring

Steg 4) Öka lagringsutrymmet till 10 GB och klicka på Nästa

Steg 5) Behåll standardinställningarna och klicka på Nästa: Konfigurera säkerhetsgrupp

Steg 6) Välj säkerhetsgruppen du skapade tidigare, dvs jupyter_docker

Steg 7) Revse dina inställningar och klicka på startknappen

Steg 8) Det sista steget är att länka nyckelparet till instansen.

Steg 9) Instans kommer att starta

Steg 10) Nedan följer en sammanfattning av de instanser som används för närvarande. Notera den publika IP-adressen.

Steg 11) Klicka på Connect

Du hittar anslutningsinformationen

Starta din instans (Mac OS-användare)

Peka först terminalens arbetskatalog mot mappen som innehåller nyckelparsfilen.

kör koden

chmod 400 docker.pem

Öppna anslutningen med denna kod.

Det finns två kommandon. Ibland stannar det första. Jupyter öppnar anteckningsboken.

I det här fallet, använd den andra för att tvinga in anslutningen Jupyter Notebook på EC2.

# If able to launch Jupyter
ssh -i "docker.pem" ec2-user@ec2-18-219-192-34.us-east-2.compute.amazonaws.com
# If not able to launch Jupyter
ssh -i "docker.pem" ec2-user@ec2-18-219-192-34.us-east-2.compute.amazonaws.com -L 8888:127.0.0.1:8888

Första gången uppmanas du att acceptera anslutningen

Starta din instans (Windows användare)

Steg 1) Gå till den här webbplatsen för att ladda ner PuTTY och PuTTYgen PuTTY

Du måste ladda ner

• PuTTY: starta instansen
• PuTTYgen: konvertera pem-filen till ppk

Nu när båda programmen är installerade behöver du konvertera .pem-filen till .ppk. PuTTY kan bara läsa .ppk. Pem-filen innehåller den unika nyckeln som skapats av AWS.

Steg 2) Öppna PuTTYgen och klicka på Ladda. Bläddra i mappen där .pem-filen finns.

Steg 3) När du har laddat filen bör du få ett meddelande som informerar dig om att nyckeln har importerats. Klicka på OK

Steg 4) Klicka sedan på Spara privat nyckel. Du tillfrågas om du vill spara denna nyckel utan en lösenordsfras. Klicka på ja.

Steg 5) Spara nyckeln

Steg 6) Gå till AWS och kopiera den offentliga DNS

Öppna PuTTY och klistra in Public DNS i värdnamnet

Steg 7)

1. På den vänstra panelen, vik upp SSH och öppna Auth
2. Bläddra i den privata nyckeln. Du bör välja .ppk
3. Klicka på Öppna.

Steg 8)

När detta steg är klart kommer ett nytt fönster att öppnas. Klicka på Ja om du ser detta popup-fönster

Steg 9)

Du måste logga in som: ec2-user

Steg 10)

Du är ansluten till Amazon Linux AMI.

Del 4: Installera Docker

Ocuco-landskapet Docker-handledning täcker containervokabulären som används nedan.

Medan du är ansluten till servern via PuTTY eller Terminal kan du installera Hamnarbetare motor.

Kör följande koder. På Amazon Linux 2023, använd dnf för yum och systemctl start docker för service docker start.

sudo yum update -y
sudo yum install -y docker
sudo service docker start
sudo usermod -a -G docker ec2-user
exit

Starta anslutningen igen

ssh -i "docker.pem" ec2-user@ec2-18-219-192-34.us-east-2.compute.amazonaws.com -L 8888:127.0.0.1:8888

Windows användare återansluter till PuTTY exakt som beskrivits ovan.

Del 5: Installera Jupyter

Steg 1) Skapa Jupyter behållare från en förbyggd avbildning:

## Tensorflow
docker run -v ~/work:/home/jovyan/work -d -p 8888:8888 jupyter/tensorflow-notebook
## Spark
docker run -v ~/work:/home/jovyan/work -d -p 8888:8888 jupyter/pyspark-notebook

Code Förklaring

• docker run: Kör bilden
• v: anslut en volym
• ~/work:/home/jovyan/work: Volym
• 8888:8888: hamn
• jupyter/datascience-notebook: Bild

För andra färdiga bilder, bläddra bland Jupyter Docker Stacks-arkivSedan oktober 2023 skickas dessa bilder på Quay.io, så dra quay.io/jupyter/tensorflow-notebook or quay.io/jupyter/pyspark-notebook för PySparkDocker Hub-kopiorna är frysta.

Låt containern skriva in i den monterade work mapp så att anteckningsböcker överlever en omstart:

sudo chown 1000 ~/work

Steg 2) installera tree så att du kan granska arbetskatalogen:

sudo yum install -y tree

Steg 3) Kontrollera behållaren och dess namn

Kör kommandona nedan i ordning:

1. Lista de behållare som körs:

   docker ps

2. Läs containerloggen för Jupyter URLHär heter behållaren vigilant_easley:

   docker logs vigilant_easley

3. kopiera URL, med dess token, från loggen.

Steg 4) I URL Från loggen, ersätt värden (90a3c09282d6 eller 127.0.0.1) med din instans publika DNS:

http://(90a3c09282d6 or 127.0.0.1):8888/?token=f460f1e79ab74c382b19f90fe3fd55f9f99c5222365eceed

Steg 5) Den nya URL blir,

http://ec2-174-129-135-16.compute-1.amazonaws.com:8888/?token=f460f1e79ab74c382b19f90fe3fd55f9f99c5222365eceed

Steg 6) Kopiera och klistra in URL i din webbläsare.

Jupyter Öppnar

Steg 7) Du kan nu skapa en ny anteckningsbok i din work mapp.

Del 6: Stäng anslutning

Stäng anslutningen i terminalen

exit

Gå tillbaka till AWS och stoppa servern.

Felsökning

Om Docker inte fungerar, återskapa avbildningen med hjälp av

docker run -v ~/work:/home/jovyan/work -d -p 8888:8888 jupyter/tensorflow-notebook

Vanliga frågor