Ambienti Conda non visualizzati in Jupyter Notebook

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. Non importa Comincio Jupyter Notebook dalla GUI Navigator o dalla riga di comando all'interno della tensorflowenv, c'è solo un kernel nel menu 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, riesco a vedere i due ambienti quando apro la Condascheda nella prima pagina di Jupyter. Ma quando apro la Filesscheda e provo su newun notebook, finisco comunque con un solo kernel.

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

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

Non credo che le altre risposte stiano funzionando più, dato che conda ha smesso di impostare automaticamente gli ambienti come kernel jupyter. È necessario aggiungere manualmente i kernel per ciascun ambiente nel modo seguente:

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

Come documentato qui: http://ipython.readthedocs.io/en/stable/install/kernel_install.html#kernels-for-different-environments Vedi anche questo problema .

Addendum: dovresti essere in grado di installare il nb_conda_kernelspacchetto con conda install nb_conda_kernelsper aggiungere automaticamente tutti gli ambienti, vedi https://github.com/Anaconda-Platform/nb_conda_kernels

Se i tuoi ambienti non vengono visualizzati, probabilmente non hai nb_conda_kernelsinstallato nell'ambiente in cui è installato Jupyter. La documentazione di Anaconda afferma che

nb_conda_kernelsdovrebbe 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, verrà eseguito

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 .

Si noti che al momento della pubblicazione originale, c'era una possibile causa nb_condanon supportando ancora gli ambienti Python 3.6 .

Se altre soluzioni non riescono a far riconoscere a Jupyter altri ambienti conda, puoi sempre installarlo ed eseguirlo jupyterda un ambiente specifico. Tuttavia, potresti non essere in grado di vedere o passare ad altri ambienti da Jupyter.

$ conda create -n py36_test -y python=3.6 jupyter
$ source activate py36_test
(py36_test) $ which jupyter
/home/schowell/anaconda3/envs/py36_test/bin/jupyter
(py36_test) $ jupyter notebook

Si noti che sto eseguendo Python 3.6.1 in questo notebook:

Nota che se lo fai in molti ambienti, lo spazio di archiviazione aggiunto dall'installazione di Jupyter in ogni ambiente potrebbe essere indesiderabile (a seconda del tuo sistema).

La cosa fastidiosa è che nel tuo tensorflowambiente, puoi eseguire jupyter notebook senza installare jupyterin quell'ambiente . Corri

(tensorflow) $ conda install jupyter

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

Ho dovuto eseguire tutti i comandi indicati nelle prime 3 risposte per farlo funzionare:

conda install jupyter
conda install nb_conda
conda install ipykernel
python -m ipykernel install --user --name mykernel

Basta eseguire conda install ipykernelnel nuovo ambiente, solo allora si otterrà un kernel con questo env. Funziona anche se in ogni ambiente sono installate versioni diverse e non installa nuovamente il notebook jupyter. Puoi avviare il tuo notebook da qualsiasi ambiente in cui potrai vedere i kernel appena aggiunti.

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:

jupyter kernelspec remove python3

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 si esegue il comando jupyter notebooke si crea 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:

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

Questo ti darà la possibilità di utilizzare l'ambiente test_env indipendentemente dall'ambiente da cui lanci 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 listper elencare tutti i tuoi ambienti. Ad esempio, se hai un Mac ti verrà restituito quanto segue (il mio nome utente è Ted).

python3       /Users/Ted/Library/Jupyter/kernels/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 sono 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:

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

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:

jupyter kernelspec remove python3

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

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

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.

    $ conda install nb_conda_kernels

(nell'ambiente conda in cui si esegue jupyter notebook) renderà automaticamente disponibili tutti gli ambienti conda. Per accedere ad altri ambienti, è necessario installare i rispettivi kernel. Ecco il rif .

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

Quindi installa Miniconda , quindi fai:

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

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

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

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

Il nb_conda_kernelspacchetto è il modo migliore per utilizzare jupytercon 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 il tuo baseambiente conda, ma non è necessario. Ad esempio, se l'ambiente notebook_envcontiene 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 ipykernelpacchetto; 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!

Mi sono imbattuto in questo stesso problema in cui il mio nuovo ambiente conda myenv, non poteva essere selezionato come kernel o nuovo notebook. E correndojupter notebook dall'interno dell'ENV 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 myenvcon conda:

conda install -n myenv ipython jupyter

Dopodiché, eseguo jupter notebookal di fuori di qualsiasi env elencato myenvcome 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 i miei kernel di ambiente e mostra solo i miei kernel di lingua:

python 2
python 3
R

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)

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 pitone 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.

Mentre la risposta di @ coolscitist ha funzionato per me, c'è anche un modo che non ingombra l'ambiente del kernel con il pacchetto jupyter completo + deps. È descritto nei documenti di IPython ed è (sospetto) necessario solo se si esegue il server notebook in un ambiente non di base.

conda activate name_of_your_kernel_env
conda install ipykernel
python -m ipykernel install --prefix=/home/your_username/.conda/envs/name_of_your_jupyter_server_env --name 'name_of_your_kernel_env'

Puoi verificare se funziona usando

conda activate name_of_your_jupyter_server_env 
jupyter kernelspec list

Ho avuto un problema simile e ho trovato una soluzione che funziona per Mac, Windows e Linux. Ci vogliono alcuni ingredienti chiave che sono nella risposta sopra:

Per poter vedere conda env nel taccuino di Jupyter, devi:

• il seguente pacchetto in env base:
  conda install nb_conda

• il seguente pacchetto in ogni ambiente creato:
  conda install ipykernel

• controlla la configurazione del jupyter_notebook_config.py
  primo controllo se hai una jupyter_notebook_config.pyin una delle posizioni fornite da jupyter --paths
  se non esiste, creala eseguendo jupyter notebook --generate-config
  aggiungi o assicurati di avere quanto segue:c.NotebookApp.kernel_spec_manager_class='nb_conda_kernels.manager.CondaKernelSpecManager'

L'env che puoi vedere nel tuo terminale:

Su Jupyter Lab puoi vedere lo stesso ambiente sopra sia il Notebook che la Console:

E puoi scegliere il tuo ambiente quando hai un notebook aperto:

Il modo sicuro è creare un env specifico dal quale eseguirai il tuo esempio dijupyter lab comando env . Attiva il tuo env. Quindi aggiungere l' esempio di estensione jupyter lab estensione jupyter lab . Quindi puoi correre jupyter lab

Segui le istruzioni nella documentazione di iPython per aggiungere diversi ambienti conda all'elenco dei kernel tra cui scegliere in Jupyter Notebook. In breve, dopo l'installazione ipykernel, è necessario attivare uno alla volta ogni ambiente conda in un terminale ed eseguire il comando python -m ipykernel install --user --name myenv --display-name "Python (myenv)", dove si myenvtrova l'ambiente (kernel) che si desidera aggiungere.

Possibile problema specifico del canale

Ho avuto questo problema (di nuovo) e si è scoperto che ho installato dal canale conda-forge ; rimuoverlo e reinstallarlo dal canale anaconda invece lo ha risolto per me.

Aggiornamento : ho avuto di nuovo lo stesso problema con un nuovo env, questa volta ho fatto l'installazione nb_conda_kernelsdal canale anaconda , ma il mio jupyter_clientera dal canale conda-forge . La disinstallazione nb_conda_kernelse la reinstallazione sono state aggiornate a un canale con priorità più alta.

Quindi assicurati di aver installato dai canali corretti :)

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 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 "Riproduci" sull'ambiente scelto e seleziona "apri con Jupyter Notebook".

Ambienti in Anaconda Navigator per eseguire Jupyter dall'ambiente selezionato