anaconda - notebook - jupyter numpy not found




Ambienti Conda non visualizzati in Jupyter Notebook (10)

Riepilogo (tldr)

Se vuoi che il kernel 'python3' esegua sempre l'installazione di Python dall'ambiente in cui è stato lanciato, elimina il kernel 'python3' dell'utente, che ha la precedenza su qualunque sia l'ambiente attuale:

conda config --add channels conda-forge --force
conda update --all  -y
conda install nb_conda_kernels -y
conda env create -f custom_env.yml -q --force
jupyter notebook

Soluzione completa

Pubblicherò una soluzione alternativa e più semplice per il seguente caso:

  • Hai creato un ambiente conda
  • In questo ambiente è installato jupyter (che installa anche ipykernel)
  • Quando esegui il comando jupyter notebook e crei un nuovo notebook facendo clic su "python3" nel menu a discesa "Nuovo", quel notebook esegue python dall'ambiente di base e non dall'ambiente corrente.
  • Ti piacerebbe che il lancio di un nuovo notebook con 'python3' in qualsiasi ambiente esegua la versione di Python da quell'ambiente e NON dalla base

Userò il nome 'test_env' per l'ambiente per il resto della soluzione. Inoltre, nota che 'python3' è il nome del kernel.

La risposta attualmente più votata funziona, ma esiste un'alternativa. Dice di fare quanto segue:

name: bqplot
channels:
- conda-forge
- defaults
dependencies:
- python>=3.6
- bqplot
- ipykernel

Questo ti darà la possibilità di utilizzare l'ambiente test_env indipendentemente dall'ambiente in cui jupyter notebook . Tuttavia, il lancio di un notebook con 'python3' utilizzerà comunque l'installazione di Python dall'ambiente di base.

Ciò che sta probabilmente accadendo è che esiste un kernel utente python3 che esiste. Esegui il comando jupyter kernelspec list per elencare tutti i tuoi ambienti. Ad esempio, se hai un Mac ti verrà restituito quanto segue (il mio nome utente è Ted).

jupyter kernelspec remove python3

Quello che Jupyter sta facendo qui è la ricerca attraverso tre diversi percorsi alla ricerca di kernel. Passa da Utente , a Env , a Sistema . Vedi questo documento per maggiori dettagli sui percorsi che cerca per ciascun sistema operativo.

I due kernel sopra si trovano entrambi nel percorso Utente, il che significa che saranno disponibili indipendentemente dall'ambiente da cui si avvia un notebook jupyter. Questo significa anche che se esiste un altro kernel 'python3' a livello di ambiente, non sarà mai possibile accedervi.

Per me ha più senso che la scelta del kernel 'python3' dall'ambiente da cui è stato lanciato il notebook dovrebbe eseguire Python da quell'ambiente.

Puoi verificare se hai un altro ambiente 'python3' cercando nel percorso di ricerca Env per il tuo sistema operativo (vedi il link ai documenti sopra). Per me (sul mio mac), ho emesso il seguente comando:

python -m ipykernel install --user --name test_env --display-name "Python (test_env)"

E in effetti avevo un kernel 'python3' elencato lì.

Grazie a questo commento sul problema di GitHub (guarda la prima risposta), puoi rimuovere l'ambiente 'python3' dell'utente con il seguente comando:

python3       /Users/Ted/Library/Jupyter/kernels/python3

Ora quando esegui jupyter kernelspec list , supponendo che test_env sia ancora attivo, otterrai quanto segue:

 ls /Users/Ted/anaconda3/envs/test_env/share/jupyter/kernels

Si noti che questo percorso si trova nella directory test_env. Se crei un nuovo ambiente, installi jupyter, lo attivi ed elenchi i kernel, otterrai un altro kernel 'python3' situato nel suo percorso di ambiente.

Il kernel User 'python3' stava avendo la precedenza su qualsiasi kernel Env 'python3'. Rimuovendolo, il kernel 'python3' dell'ambiente attivo è stato esposto e può essere scelto ogni volta. Questo elimina la necessità di creare manualmente kernel. Ha anche più senso in termini di sviluppo software in cui si vorrebbe isolarsi in un unico ambiente. L'esecuzione di un kernel diverso dall'ambiente host non sembra naturale.

Sembra anche che questo utente 'python3' non sia installato per tutti per impostazione predefinita, quindi non tutti devono affrontare questo problema.

Ho installato Anaconda (con Python 2.7) e installato Tensorflow in un ambiente chiamato tensorflow . Posso importare Tensorflow con successo in quell'ambiente.

Il problema è che Jupyter Notebook non riconosce il nuovo ambiente che ho appena creato. Indipendentemente dal fatto che avvii Jupyter Notebook dal Navigatore GUI o dalla riga di comando all'interno di env tensorflow , nel menu è presente un solo kernel chiamato Python [Root] e Tensorflow non può essere importato. Certo, ho cliccato su quell'opzione più volte, ho salvato il file, riaperto, ma questi non mi hanno aiutato.

Stranamente, posso vedere i due ambienti quando apro la scheda Conda sulla prima pagina di Jupyter. Ma quando apro la scheda Files e provo a creare un new taccuino, finisco comunque con un solo kernel.

Ho esaminato questa domanda: collega l'ambiente Conda con Jupyter Notebook Ma sul mio computer non esiste una directory come ~/Library/Jupyter/kernels ! Questa directory Jupyter ha solo una sottodirectory chiamata runtime .

Sono davvero confuso. Gli ambienti Conda dovrebbero diventare kernel automaticamente? (Ho seguito https://ipython.readthedocs.io/en/stable/install/kernel_install.html per impostare manualmente i kernel, ma mi è stato detto che ipykernel non è stato trovato.)


Abbiamo lottato molto con questo problema ed ecco cosa funziona per noi. Se si utilizza il canale conda-forge , è importante assicurarsi di utilizzare i pacchetti aggiornati da conda-forge , anche nel proprio ambiente root Miniconda .

Quindi installa Miniconda , quindi fai:

jupyter kernelspec remove python3

e il tuo ambiente personalizzato verrà visualizzato in Jupyter come kernel disponibile, purché ipykernel sia elencato per l'installazione nel tuo file custom_env.yml , come in questo esempio:

python3       /Users/Ted/anaconda3/envs/test_env/share/jupyter/kernels/python3

Giusto per dimostrarlo lavorando con un sacco di ambienti personalizzati, ecco una schermata di Windows:


Il pacchetto nb_conda_kernels è il modo migliore per usare jupyter con conda . Con dipendenze e configurazione minime, ti consente di utilizzare altri ambienti conda da un notebook jupyter in esecuzione in un ambiente diverso. Citando la sua documentazione :

Installazione

Questo pacchetto è progettato per essere gestito esclusivamente tramite conda. Dovrebbe essere installato nell'ambiente da cui si esegue Jupyter Notebook o JupyterLab. Questo potrebbe essere l'ambiente conda di base , ma non è necessario. Ad esempio, se l'ambiente notebook_env contiene il pacchetto notebook, si eseguirà

conda install -n notebook_env nb_conda_kernels

Tutti gli altri ambienti a cui si desidera accedere nei notebook devono disporre di un pacchetto kernel appropriato installato. Ad esempio, per accedere a un ambiente Python, deve avere il pacchetto ipykernel ; per esempio

conda install -n python_env ipykernel

Per utilizzare un ambiente R, è necessario disporre del pacchetto r-irkernel; per esempio

conda install -n r_env r-irkernel

Per altre lingue, devono essere installati i kernel corrispondenti .

Quindi tutto ciò che devi fare è avviare il server notebook jupyter:

conda activate notebook_env  # only needed if you are not using the base environment for the server
# conda install jupyter # in case you have not installed it already
jupyter

Nonostante la pletora di risposte e gli sforzi di @ merv per migliorarle, è ancora difficile trovarne una buona. Ho creato questo CW, quindi per favore votalo in alto o miglioralo!


La cosa fastidiosa è che nel tuo ambiente tensorflow , puoi eseguire il jupyter notebook senza installare jupyter in quell'ambiente . Corri

(tensorflow) $ conda install jupyter

e l'ambiente tensorflow ora dovrebbe essere visibile nei Notebook di Jupyter avviati in uno qualsiasi dei tuoi ambienti conda come qualcosa come Python [conda env:tensorflow] .


Mi sono imbattuto in questo stesso problema in cui il mio nuovo ambiente myenv , myenv , non poteva essere selezionato come kernel o nuovo notebook. E l'esecuzione del jupter notebook dall'interno ha dato lo stesso risultato.

La mia soluzione e quello che ho imparato su come i notebook Jupyter riconoscono conda-envs e kernel:

Installazione di jupyter e ipython su myenv con conda:

conda install -n myenv ipython jupyter

Dopodiché, eseguire jupter notebook al di fuori di qualsiasi env ha elencato myenv come kernel insieme ai miei ambienti precedenti.

Python [conda env:old]
Python [conda env:myenv]

Esecuzione del notebook una volta attivato l'ambiente:

source activate myenv
jupyter notebook

nasconde tutti gli altri miei kernel di ambiente e mostra solo i miei kernel di lingua:

python 2
python 3
R

Nel mio caso, usando Windows 10 e conda 4.6.11, eseguendo i comandi

conda install nb_conda

conda install -c conda-forge nb_conda_kernels

dal terminale pur avendo l'ambiente attivo non ha fatto il lavoro dopo aver aperto Jupyter dalla stessa riga di comando usando il conda jupyter notebook .

Apparentemente la soluzione era aprire Jupyter da Anaconda Navigator andando nel mio ambiente in Ambienti: Apri Anaconda Navigator, seleziona l'ambiente in Ambienti, premi il pulsante "gioca" sull'ambiente scelto e seleziona "apri con Jupyter Notebook".

Ambienti in Anaconda Navigator per eseguire Jupyter dall'ambiente selezionato


Questo è stato così frustrante, il mio problema era che all'interno di un ambiente conda python36 di nuova costruzione, Giove si rifiutava di caricare "Seaborn" - anche se Seaborn era installato in quell'ambiente. Sembrava essere in grado di importare molti altri file dallo stesso ambiente, ad esempio numpy e panda, ma non appena nato. Ho provato molte delle soluzioni suggerite qui e su altri thread senza successo. Fino a quando mi sono reso conto che Jupyter non stava eseguendo kernel Python dall'interno di quell'ambiente, ma eseguendo il sistema Python come kernel. Anche se un kernel dall'aspetto decente e kernel.json erano già presenti nell'ambiente. È stato solo dopo aver letto questa parte della documentazione di ipython: https://ipython.readthedocs.io/en/latest/install/kernel_install.html#kernels-for-different-environments e usando questi comandi:

source activate other-env
python -m ipykernel install --user --name other-env --display-name "Python (other-env)"

Sono stato in grado di far andare tutto bene. (In realtà non ho usato la variabile —user).

Una cosa che non ho ancora immaginato è come impostare il Python predefinito su "Python (other-env)". Attualmente un file .ipynb esistente aperto dalla schermata principale utilizzerà il sistema Python. Devo usare il menu del kernel "Cambia kernel" per selezionare l'ambiente Python.


Questo ha funzionato per me in Windows 10 e l'ultima soluzione:

1) Entra in quell'ambiente conda (attiva your_env_name)

2) conda install -n your_env_name ipykernel

3) python -m ipykernel install --user --name build_central --display-name "your_env_name"

(NOTA: includi le virgolette intorno a "nome_vilente", nel passaggio 3)


Segui le https://ipython.readthedocs.io/en/stable/install/kernel_install.html per l'aggiunta di diversi ambienti conda all'elenco dei kernel tra cui scegliere in Jupyter Notebook. In breve, dopo aver installato ipykernel , è necessario attivare uno per uno ogni ambiente conda in un terminale ed eseguire il comando python -m ipykernel install --user --name myenv --display-name "Python (myenv)" , dove myenv è l'ambiente (kernel) che si desidera aggiungere.


conda install ipykernel nel tuo nuovo ambiente, solo allora otterrai un kernel con questo env. Funziona anche se in ogni ambiente sono installate versioni diverse e non installa di nuovo il notebook jupyter. Puoi avviare il tuo notebook da qualsiasi ambiente in cui potrai vedere i kernel appena aggiunti.