anaconda - activate - Los entornos Conda no aparecen en Jupyter Notebook
activate conda environment in jupyter notebook (15)
Resumen (tldr)
Si desea que el núcleo ''python3'' ejecute siempre la instalación de Python desde el entorno en el que se inicia, elimine el núcleo del usuario ''python3'', que tiene prioridad sobre el entorno actual con el que se encuentre:
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
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 notebook
y crea una nueva notebook haciendo clic en ''python3'' en el menú desplegable ''Nuevo'', esa notebook 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:
name: bqplot
channels:
- conda-forge
- defaults
dependencies:
- python>=3.6
- bqplot
- ipykernel
Esto le dará la opción de usar el entorno test_env sin importar desde qué entorno inicie el
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 list
para enumerar todos sus entornos.
Por ejemplo, si tiene una Mac, se le devolverá lo siguiente (mi nombre de usuario es Ted).
jupyter kernelspec remove 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 del entorno, entonces nunca podrá acceder a él.
Para mí, tiene más sentido que elegir el kernel ''python3'' del entorno desde el que lanzó el portátil debe ejecutar 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:
python -m ipykernel install --user --name test_env --display-name "Python (test_env)"
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:
python3 /Users/Ted/Library/Jupyter/kernels/python3
Ahora, cuando ejecute
jupyter kernelspec list
, suponiendo que test_env todavía esté activo, obtendrá lo siguiente:
ls /Users/Ted/anaconda3/envs/test_env/share/jupyter/kernels
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 por defecto, por lo que no todos se enfrentan a este problema.
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 si inicio Jupyter Notebook desde el GUI Navigator o desde la línea de comandos
dentro
del
tensorflow
, solo hay un kernel 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 pestaña
Conda
en la página principal de Jupyter.
Pero cuando abro la pestaña
Files
e intento crear un cuaderno
new
, sigo teniendo un solo núcleo.
Miré esta pregunta:
vincular el entorno de Conda con Jupyter Notebook ¡
Pero no hay un directorio como
~/Library/Jupyter/kernels
en 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 no se encontró
ipykernel
).
El paquete
nb_conda_kernels
es la mejor manera de usar
jupyter
con
conda
.
Con dependencias y configuraciones mínimas, le permite usar otros entornos conda desde un portátil 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 entorno
base
básico, pero no es necesario que lo sea. Por ejemplo, si el entornonotebook_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.
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!
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 el
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
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 utilizando 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.
Hemos luchado mucho con este problema, y esto es lo que funciona para nosotros.
Si usa el
canal conda-forge
, es importante asegurarse de estar usando paquetes actualizados de
conda-forge
, incluso en su
Miniconda
raíz de
Miniconda
.
Entonces instale Miniconda , y luego haga:
jupyter kernelspec remove python3
y su entorno personalizado se mostrará en Jupyter como un kernel disponible, siempre que
ipykernel
lista de instalación en su archivo
custom_env.yml
, como este ejemplo:
python3 /Users/Ted/anaconda3/envs/test_env/share/jupyter/kernels/python3
Solo para demostrar que funciona con un montón de entornos personalizados, aquí hay una captura de pantalla de Windows:
Lo molesto es que en su entorno de
tensorflow
, puede ejecutar
jupyter notebook
sin instalar
jupyter
en ese entorno
.
Solo corre
(tensorflow) $ conda install jupyter
y el entorno de
tensorflow
ahora debería estar visible en Jupyter Notebooks iniciados en cualquiera de sus entornos de
conda
como algo así como
Python [conda env:tensorflow]
.
Me encontré con este mismo problema en el que mi nuevo entorno de
myenv
,
myenv
, no podía seleccionarse como kernel o portátil nuevo.
Y ejecutar
jupter notebook
desde el 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:
Instalación de jupyter e ipython en
myenv
con conda:
conda install -n myenv ipython jupyter
Después de eso, ejecutar
jupter notebook
fuera de cualquier
myenv
enumeró
myenv
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
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 paquete
conda install nb_conda_kernels
con
conda install nb_conda_kernels
para agregar todos los entornos automáticamente, consulte
https://github.com/Anaconda-Platform/nb_conda_kernels
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
Si sus entornos no se muestran, probablemente no tenga
nb_conda_kernels
instalados en el entorno donde está instalado Jupyter.
La documentación de Anaconda
establece que
nb_conda_kernels
debe 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 de que
nb_conda
aún no
nb_conda
entornos Python 3.6
.
Si otras soluciones no logran que Jupyter reconozca otros entornos conda, siempre puede instalar y ejecutar
jupyter
desde 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 instalar Jupyter en cada entorno puede ser indeseable (dependiendo de su sistema).
Siga las
https://ipython.readthedocs.io/en/stable/install/kernel_install.html
para agregar diferentes entornos conda a la lista de núcleos para elegir en Jupyter Notebook.
En resumen, después de instalar
ipykernel
, debe activar cada entorno conda uno por uno en una terminal y ejecutar el comando
python -m ipykernel install --user --name myenv --display-name "Python (myenv)"
, donde
myenv
es El entorno (kernel) que desea agregar.
Simplemente ejecute
conda install ipykernel
en 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.
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
$ 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 https://github.com/Anaconda-Platform/nb_conda_kernels .