Los entornos de Conda no se muestran en Jupyter Notebook

Instalé Anaconda (con Python 2.7) e instalé Tensorflow en un entorno llamado tensorflow. Puedo importar Tensorflow con éxito en ese entorno.

El problema es que Jupyter Notebook no reconoce el nuevo entorno que acabo de crear. No importa comienzo Jupyter portátil de la interfaz gráfica de usuario del navegador o desde la línea de comandos dentro del tensorflowenv, sólo hay un núcleo en el menú llamado Python [Root], y Tensorflow no se puede importar. Por supuesto, hice clic en esa opción varias veces, guardé el archivo, lo volví a abrir, pero esto no ayudó.

Curiosamente, puedo ver los dos entornos cuando abro la Condapestaña en la página principal de Jupyter. Pero cuando abro la Filespestaña e intento newusar una computadora portátil, todavía termino con un solo núcleo.

Miré esta pregunta: vincular el entorno de Conda con Jupyter Notebook ¡ Pero no hay un directorio como ~/Library/Jupyter/kernelsen mi computadora! Este directorio de Jupyter solo tiene un subdirectorio llamado runtime.

Estoy realmente confundido ¿Se supone que los entornos Conda se convierten en núcleos automáticamente? (Seguí https://ipython.readthedocs.io/en/stable/install/kernel_install.html para configurar manualmente los núcleos, pero me dijeron que ipykernelno se encontró).

No creo que las otras respuestas funcionen más, ya que conda dejó de configurar automáticamente los entornos como núcleos jupyter. Debe agregar manualmente los núcleos para cada entorno de la siguiente manera:

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

Como se documenta aquí: http://ipython.readthedocs.io/en/stable/install/kernel_install.html#kernels-for-different-environments También vea este problema .

Anexo: Debería poder instalar el nb_conda_kernelspaquete conda install nb_conda_kernelspara agregar todos los entornos automáticamente, consulte https://github.com/Anaconda-Platform/nb_conda_kernels

Si sus entornos no se muestran, probablemente no haya nb_conda_kernelsinstalado en el entorno donde está instalado Jupyter. La documentación de Anaconda establece que

nb_conda_kernelsdebe instalarse en el entorno desde el que ejecuta Jupyter Notebook o JupyterLab. Este podría ser su entorno base básico, pero no es necesario que lo sea. Por ejemplo, si el entorno notebook_env contiene el paquete de la notebook, entonces debería ejecutar

conda install -n notebook_env nb_conda_kernels

Cualquier otro entorno al que desee acceder en sus computadoras portátiles debe tener instalado un paquete de kernel apropiado. Por ejemplo, para acceder a un entorno Python, debe tener el paquete ipykernel; p.ej

conda install -n python_env ipykernel

Para utilizar un entorno R, debe tener el paquete r-irkernel; p.ej

conda install -n r_env r-irkernel

Para otros idiomas, sus núcleos correspondientes deben estar instalados.

Tenga en cuenta que en el momento de publicar esto originalmente, había una posible causa por nb_condano admitir aún los entornos Python 3.6 .

Si otras soluciones no logran que Jupyter reconozca otros entornos conda, siempre puede instalar y ejecutar jupyterdesde un entorno específico. Sin embargo, es posible que no pueda ver o cambiar a otros entornos desde 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

Tenga en cuenta que estoy ejecutando Python 3.6.1 en este cuaderno:

Tenga en cuenta que si hace esto con muchos entornos, el espacio de almacenamiento adicional de la instalación de Jupyter en cada entorno puede ser indeseable (dependiendo de su sistema).

Lo molesto es que en su tensorflowentorno, puede ejecutar jupyter notebook sin instalar jupyteren ese entorno . Solo corre

(tensorflow) $ conda install jupyter

y el tensorflowentorno ahora debería ser visible en los Cuadernos Jupyter iniciados en cualquiera de sus condaentornos como algo así Python [conda env:tensorflow].

Tuve que ejecutar todos los comandos mencionados en las 3 respuestas principales para que esto funcione:

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

Simplemente ejecute conda install ipykernelen su nuevo entorno, solo entonces obtendrá un núcleo con este entorno. Esto funciona incluso si tiene diferentes versiones instaladas en cada entorno y no instala jupyter notebook nuevamente. Puede iniciar su cuaderno desde cualquier entorno en el que pueda ver los núcleos recién agregados.

Resumen (tldr)

Si desea que el kernel 'python3' ejecute siempre la instalación de Python desde el entorno donde se inicia, elimine el kernel 'python3' del usuario, que tiene prioridad sobre el entorno actual con el que se encuentre:

jupyter kernelspec remove python3

Solución completa

Voy a publicar una solución alternativa y más simple para el siguiente caso:

• Has creado un entorno conda
• Este entorno tiene instalado jupyter (que también instala ipykernel)
• Cuando ejecuta el comando jupyter notebooky crea un nuevo cuaderno haciendo clic en 'python3' en el menú desplegable 'Nuevo', ese cuaderno ejecuta python desde el entorno base y no desde el entorno actual.
• Le gustaría que el lanzamiento de una nueva computadora portátil con 'python3' en cualquier entorno ejecute la versión de Python desde ese entorno y NO desde la base

Voy a usar el nombre 'test_env' para el entorno para el resto de la solución. Además, tenga en cuenta que 'python3' es el nombre del núcleo.

La respuesta más votada actualmente funciona, pero hay una alternativa. Dice hacer lo siguiente:

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

Esto le dará la opción de usar el entorno test_env sin importar desde qué entorno inicie jupyter notebook. Pero, el lanzamiento de una computadora portátil con 'python3' seguirá utilizando la instalación de Python desde el entorno base.

Lo que probablemente está sucediendo es que existe un núcleo de usuario python3 que existe. Ejecute el comando jupyter kernelspec listpara enumerar todos sus entornos. Por ejemplo, si tiene una Mac, se le devolverá lo siguiente (mi nombre de usuario es Ted).

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

Lo que Jupyter está haciendo aquí es buscar a través de tres caminos diferentes en busca de núcleos. Va de Usuario , a Env , a Sistema . Consulte este documento para obtener más detalles sobre las rutas que busca para cada sistema operativo.

Los dos núcleos anteriores se encuentran en la ruta del usuario, lo que significa que estarán disponibles independientemente del entorno desde el que inicie un jupyter notebook. Esto también significa que si hay otro kernel 'python3' a nivel de entorno, nunca podrá acceder a él.

Para mí, tiene más sentido que la elección del núcleo 'python3' del entorno desde el que lanzó el portátil ejecute Python desde ese entorno.

Puede verificar si tiene otro entorno 'python3' buscando en la ruta de búsqueda Env para su sistema operativo (consulte el enlace a los documentos anteriores). Para mí (en mi Mac), emití el siguiente comando:

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

Y de hecho tenía un kernel 'python3' listado allí.

Gracias a este comentario de problema de GitHub (mira la primera respuesta), puedes eliminar el entorno del usuario 'python3' con el siguiente comando:

jupyter kernelspec remove python3

Ahora, cuando ejecute jupyter kernelspec list, suponiendo que test_env todavía esté activo, obtendrá lo siguiente:

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

Observe que esta ruta se encuentra dentro del directorio test_env. Si crea un nuevo entorno, instala jupyter, lo activa y enumera los núcleos, obtendrá otro núcleo 'python3' ubicado en su ruta de entorno.

El núcleo del usuario 'python3' tenía prioridad sobre cualquiera de los núcleos Env 'python3'. Al eliminarlo, el núcleo del entorno activo 'python3' quedó expuesto y se pudo elegir cada vez. Esto elimina la necesidad de crear manualmente núcleos. También tiene más sentido en términos de desarrollo de software donde uno quisiera aislarse en un solo entorno. Ejecutar un kernel que es diferente del entorno del host no parece natural.

También parece que este usuario 'python3' no está instalado para todos de forma predeterminada, por lo que no todos se enfrentan a este problema.

    $ conda install nb_conda_kernels

(en el entorno conda donde ejecuta jupyter notebook) hará que todas las env conda estén disponibles automáticamente. Para acceder a otros entornos, se deben instalar los respectivos núcleos. Aquí está la referencia .

Hemos luchado mucho con este problema, y ​​esto es lo que funciona para nosotros. Si usa el canal conda-forge , es importante asegurarse de que está usando paquetes actualizados conda-forge, incluso en su Minicondaentorno raíz.

Entonces instale Miniconda , y luego haga:

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

y su entorno personalizado se mostrará en Jupyter como un kernel disponible, siempre y cuando esté ipykernellistado para la instalación en su custom_env.ymlarchivo, como este ejemplo:

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

Solo para demostrar que funciona con un montón de entornos personalizados, aquí hay una captura de pantalla de Windows:

El nb_conda_kernelspaquete es la mejor manera de utilizar jupytercon conda. Con dependencias y configuraciones mínimas, le permite usar otros entornos conda desde una notebook jupyter que se ejecuta en un entorno diferente. Citando su documentación :

Instalación

Este paquete está diseñado para ser administrado únicamente con conda. Debe instalarse en el entorno desde el que ejecuta Jupyter Notebook o JupyterLab. Este podría ser su baseentorno de conda, pero no tiene por qué serlo. Por ejemplo, si el entorno notebook_envcontiene el paquete del cuaderno, entonces debería ejecutar

conda install -n notebook_env nb_conda_kernels

Cualquier otro entorno al que desee acceder en sus computadoras portátiles debe tener instalado un paquete de kernel apropiado. Por ejemplo, para acceder a un entorno Python, debe tener el ipykernelpaquete; p.ej

conda install -n python_env ipykernel

Para utilizar un entorno R, debe tener el paquete r-irkernel; p.ej

conda install -n r_env r-irkernel

Para otros idiomas, sus núcleos correspondientes deben estar instalados.

Entonces todo lo que necesita hacer es iniciar el servidor jupyter notebook:

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

A pesar de la gran cantidad de respuestas y los esfuerzos de @ merv para mejorarlas, aún es difícil encontrar una buena. Hice este CW, ¡así que vote por la parte superior o mejórelo!

Me encontré con el mismo problema en el que mi nuevo entorno de conda myenvno podía seleccionarse como kernel o portátil nuevo. Y correr jupter notebookdesde dentro del entorno dio el mismo resultado.

Mi solución y lo que aprendí acerca de cómo los portátiles Jupyter reconocen conda-envs y kernels:

Instalando jupyter e ipython myenvcon conda:

conda install -n myenv ipython jupyter

Después de eso, ejecutar jupter notebookfuera de cualquier myenventorno enumerado como un núcleo junto con mis entornos anteriores.

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

Ejecutar el cuaderno una vez que activé el entorno:

source activate myenv
jupyter notebook

oculta todos mis otros núcleos de entorno y solo muestra mis núcleos de idioma:

python 2
python 3
R

Esto funcionó para mí en Windows 10 y la última solución:

1) Entra en ese entorno de conda (activa 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: Incluya las comillas alrededor de "your_env_name", en el paso 3)

Esto ha sido muy frustrante. Mi problema fue que, dentro de un entorno de conda python36 recién construido, jupyter se negó a cargar "seaborn", a pesar de que seaborn se instaló dentro de ese entorno. Parecía poder importar muchos otros archivos del mismo entorno, por ejemplo, numpy y pandas, pero no nacidos. Probé muchas de las soluciones sugeridas aquí y en otros hilos sin éxito. Hasta que me di cuenta de que Jupyter no estaba ejecutando kernel python desde ese entorno sino que ejecutaba el sistema python como kernel. A pesar de que un núcleo decente y kernel.json ya estaban presentes en el entorno. Fue solo después de leer esta parte de la documentación de ipython: https://ipython.readthedocs.io/en/latest/install/kernel_install.html#kernels-for-different-environments y usando estos comandos:

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

Pude hacer que todo saliera bien. (En realidad no utilicé la variable de usuario).

Una cosa que aún no he imaginado es cómo configurar la python predeterminada para que sea la "Python (other-env)". En la actualidad, un archivo .ipynb existente abierto desde la pantalla de inicio utilizará el sistema python. Tengo que usar el menú Kernel "Cambiar kernel" para seleccionar el entorno python.

Si bien la respuesta de @coolscitist funcionó para mí, también hay una manera que no satura el entorno de su kernel con el paquete completo de jupyter + deps. Se describe en los documentos de ipython y (sospecho) solo es necesario si ejecuta el servidor portátil en un entorno no 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'

Puedes verificar si funciona usando

conda activate name_of_your_jupyter_server_env 
jupyter kernelspec list

Tuve un problema similar y encontré una solución que funciona para Mac, Windows y Linux. Se necesitan algunos ingredientes clave que se encuentran en la respuesta anterior:

Para poder ver conda env en el cuaderno Jupyter, necesitas:

• El siguiente paquete en su base env:
  conda install nb_conda

• el siguiente paquete en cada env que cree:
  conda install ipykernel

• verifique la configuración de la jupyter_notebook_config.py
  primera verificación si tiene una jupyter_notebook_config.pyen una de las ubicaciones proporcionadas por jupyter --paths
  si no existe, créelo ejecutando jupyter notebook --generate-config
  add o asegúrese de tener lo siguiente:c.NotebookApp.kernel_spec_manager_class='nb_conda_kernels.manager.CondaKernelSpecManager'

El entorno que puedes ver en tu terminal:

En Jupyter Lab puede ver el mismo entorno que el anterior, tanto el Notebook como la Consola:

Y puede elegir su entorno cuando tenga un cuaderno abierto:

La forma segura es crear un entorno específico desde el que ejecutará su ejemplo dejupyter lab comando env . Activa tu env. Luego, agregue la extensión de jupyter lab . Ejemplo de extensión de jupyter lab . Entonces puedes correr jupyter lab

Siga las instrucciones en la documentación de iPython para agregar diferentes entornos conda a la lista de núcleos para elegir en Jupyter Notebook. En resumen, después de la instalación ipykernel, debe activar cada entorno conda uno por uno en un terminal y ejecutar el comando python -m ipykernel install --user --name myenv --display-name "Python (myenv)", donde myenvestá el entorno (kernel) que desea agregar.

Posible problema específico del canal

Tuve este problema (nuevamente) y resultó que lo instalé desde el canal conda-forge ; eliminarlo y reinstalarlo desde el canal anaconda lo arregló para mí.

Actualización : Me volvió a tener el mismo problema con un nuevo env, esta vez me instalo nb_conda_kernelsde anaconda canal, pero mi jupyter_clientera del Conda-forja canal. La desinstalación nb_conda_kernelsy reinstalación actualizó eso a un canal de mayor prioridad.

Así que asegúrese de haber instalado desde los canales correctos :)

En mi caso, usando Windows 10 y conda 4.6.11, ejecutando los comandos

conda install nb_conda

conda install -c conda-forge nb_conda_kernels

desde el terminal mientras tenía el entorno activo no hizo el trabajo después de que abrí Jupyter desde la misma línea de comando usando conda jupyter notebook.

Aparentemente, la solución fue abrir Jupyter desde Anaconda Navigator yendo a mi entorno en Entornos: abrir Anaconda Navigator, seleccionar el entorno en Entornos, presionar el botón "reproducir" en el entorno elegido y seleccionar "abrir con Jupyter Notebook".

Entornos en Anaconda Navigator para ejecutar Jupyter desde el entorno seleccionado