Les environnements Conda n'apparaissent pas dans le bloc-notes Jupyter

J'ai installé Anaconda (avec Python 2.7) et installé Tensorflow dans un environnement appelé tensorflow. Je peux importer Tensorflow avec succès dans cet environnement.

Le problème est que Jupyter Notebook ne reconnaît pas le nouvel environnement que je viens de créer. Peu importe que je commence Jupyter Notebook à partir du navigateur GUI ou de la ligne de commande au sein de l' tensorflowenv, il n'y a qu'un seul noyau dans le menu appelé Python [Root], et tensorflow ne peut pas être importé. Bien sûr, j'ai cliqué plusieurs fois sur cette option, enregistré le fichier, rouvert, mais cela n'a pas aidé.

Étrangement, je peux voir les deux environnements lorsque j'ouvre l' Condaonglet sur la première page de Jupyter. Mais quand j'ouvre l' Filesonglet et que j'essaye newun cahier, je me retrouve toujours avec un seul noyau.

J'ai regardé cette question: Lier l'environnement Conda avec Jupyter Notebook Mais il n'y a pas un tel répertoire que ~/Library/Jupyter/kernelssur mon ordinateur! Ce répertoire Jupyter n'a qu'un seul sous-répertoire appelé runtime.

Je suis vraiment confus. Les environnements Conda sont-ils censés devenir des noyaux automatiquement? (J'ai suivi https://ipython.readthedocs.io/en/stable/install/kernel_install.html pour configurer manuellement les noyaux, mais on m'a dit que cela ipykerneln'était pas trouvé.)

Je ne pense pas que les autres réponses fonctionnent plus, car conda a cessé de configurer automatiquement les environnements en tant que noyaux jupyter. Vous devez ajouter manuellement des noyaux pour chaque environnement de la manière suivante:

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

Comme indiqué ici: http://ipython.readthedocs.io/en/stable/install/kernel_install.html#kernels-for-different-environments Consultez également ce problème .

Addendum: vous devriez pouvoir installer le nb_conda_kernelspackage avec conda install nb_conda_kernelspour ajouter automatiquement tous les environnements, voir https://github.com/Anaconda-Platform/nb_conda_kernels

Si vos environnements ne s'affichent pas, vous ne l'avez probablement pas nb_conda_kernelsinstallé dans l'environnement où Jupyter est installé. La documentation d'Anaconda indique que

nb_conda_kernelsdoit être installé dans l'environnement à partir duquel vous exécutez Jupyter Notebook ou JupyterLab. Cela peut être votre environnement de conda de base, mais ce n'est pas nécessaire. Par exemple, si l'environnement notebook_env contient le package notebook, vous exécuterez

conda install -n notebook_env nb_conda_kernels

Tous les autres environnements auxquels vous souhaitez accéder dans vos blocs-notes doivent avoir un package de noyau approprié installé. Par exemple, pour accéder à un environnement Python, il doit avoir le package ipykernel; par exemple

conda install -n python_env ipykernel

Pour utiliser un environnement R, il doit avoir le package r-irkernel; par exemple

conda install -n r_env r-irkernel

Pour les autres langues, leurs noyaux correspondants doivent être installés.

Notez qu'au moment de la publication de cela, il y avait une cause possible à la nb_condanon-prise en charge des environnements Python 3.6 .

Si d'autres solutions ne parviennent pas à faire en sorte que Jupyter reconnaisse d'autres environnements conda, vous pouvez toujours installer et exécuter à jupyterpartir d'un environnement spécifique. Cependant, vous ne pourrez peut-être pas voir ou passer à d'autres environnements à partir de 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

Notez que j'utilise Python 3.6.1 dans ce bloc-notes:

Notez que si vous faites cela avec de nombreux environnements, l'espace de stockage supplémentaire de l'installation de Jupyter dans chaque environnement peut être indésirable (selon votre système).

Ce qui est ennuyeux, c'est que dans votre tensorflowenvironnement, vous pouvez exécuter jupyter notebook sans installer jupyterdans cet environnement . Il suffit de courir

(tensorflow) $ conda install jupyter

et l' tensorflowenvironnement devrait maintenant être visible dans Jupyter Notebooks démarré dans n'importe lequel de vos condaenvironnements comme quelque chose comme Python [conda env:tensorflow].

J'ai dû exécuter toutes les commandes mentionnées dans les 3 meilleures réponses pour que cela fonctionne:

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

Exécutez simplement conda install ipykerneldans votre nouvel environnement, alors seulement vous obtiendrez un noyau avec cet env. Cela fonctionne même si vous avez installé différentes versions dans chaque environnement et qu'il n'installe pas à nouveau le bloc-notes jupyter. Vous pouvez démarrer votre cahier à partir de n'importe quel environnement, vous pourrez voir les noyaux nouvellement ajoutés.

Résumé (tldr)

Si vous souhaitez que le noyau 'python3' exécute toujours l'installation Python à partir de l'environnement dans lequel il est lancé, supprimez le noyau utilisateur 'python3', qui a la priorité sur l'environnement actuel avec:

jupyter kernelspec remove python3

Solution complète

Je vais publier une solution alternative et plus simple pour le cas suivant:

• Vous avez créé un environnement conda
• Cet environnement a installé jupyter (qui installe également ipykernel)
• Lorsque vous exécutez la commande jupyter notebooket créez un nouveau bloc-notes en cliquant sur «python3» dans le menu déroulant «Nouveau», ce bloc-notes exécute python à partir de l'environnement de base et non à partir de l'environnement actuel.
• Vous souhaitez que le lancement d'un nouveau bloc-notes avec 'python3' dans n'importe quel environnement exécute la version Python de cet environnement et NON la base

Je vais utiliser le nom 'test_env' pour l'environnement pour le reste de la solution. Notez également que «python3» est le nom du noyau.

La réponse actuellement la plus votée fonctionne, mais il existe une alternative. Il dit de faire ce qui suit:

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

Cela vous donnera la possibilité d'utiliser l'environnement test_env quel que soit l'environnement à partir duquel vous lancez jupyter notebook. Mais, le lancement d'un ordinateur portable avec «python3» utilisera toujours l'installation Python à partir de l'environnement de base.

Ce qui se passe probablement, c'est qu'il existe un noyau utilisateur python3. Exécutez la commande jupyter kernelspec listpour répertorier tous vos environnements. Par exemple, si vous avez un mac, vous serez renvoyé ce qui suit (mon nom d'utilisateur est Ted).

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

Ce que Jupyter fait ici, c'est chercher à travers trois chemins différents à la recherche de noyaux. Cela va de l' utilisateur , à Env , au système . Consultez ce document pour plus de détails sur les chemins qu'il recherche pour chaque système d'exploitation.

Les deux noyaux ci-dessus sont tous les deux dans le chemin utilisateur, ce qui signifie qu'ils seront disponibles quel que soit l'environnement à partir duquel vous lancez un bloc-notes jupyter. Cela signifie également que s'il existe un autre noyau 'python3' au niveau de l'environnement, vous ne pourrez jamais y accéder.

Pour moi, il est plus logique de choisir le noyau 'python3' dans l'environnement à partir duquel vous avez lancé le bloc-notes devrait exécuter Python à partir de cet environnement.

Vous pouvez vérifier si vous avez un autre environnement 'python3' en recherchant dans le chemin de recherche Env pour votre système d'exploitation (voir le lien vers les documents ci-dessus). Pour moi (sur mon mac), j'ai émis la commande suivante:

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

Et j'avais en effet un noyau 'python3' répertorié là-bas.

Grâce à ce commentaire sur le problème GitHub (regardez la première réponse), vous pouvez supprimer l'environnement 'python3' de l'utilisateur avec la commande suivante:

jupyter kernelspec remove python3

Maintenant, lorsque vous exécutez jupyter kernelspec list, en supposant que test_env est toujours actif, vous obtiendrez les éléments suivants:

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

Notez que ce chemin se trouve dans le répertoire test_env. Si vous créez un nouvel environnement, installez jupyter, activez-le et listez les noyaux, vous obtiendrez un autre noyau 'python3' situé dans son chemin d'environnement.

Le noyau utilisateur 'python3' prenait le pas sur n'importe lequel des noyaux Env ​​'python3'. En le supprimant, le noyau de l'environnement actif 'python3' était exposé et pouvait être choisi à chaque fois. Cela élimine le besoin de créer manuellement des noyaux. Cela a également plus de sens en termes de développement logiciel où l'on voudrait s'isoler dans un environnement unique. L'exécution d'un noyau différent de l'environnement hôte ne semble pas naturelle.

Il semble également que cet utilisateur 'python3' ne soit pas installé pour tout le monde par défaut, donc tout le monde n'est pas confronté à ce problème.

    $ conda install nb_conda_kernels

(dans l'environnement conda où vous exécutez le cahier jupyter) rendra tous les envs conda disponibles automatiquement. Pour accéder à d'autres environnements, les noyaux respectifs doivent être installés. Voici la réf .

Nous avons beaucoup de mal avec ce problème, et voici ce qui fonctionne pour nous. Si vous utilisez le canal conda-forge , il est important de vous assurer que vous utilisez des packages mis à jour depuis conda-forge, même dans votre Minicondaenvironnement racine.

Installez donc Miniconda , puis faites:

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

et votre environnement personnalisé apparaîtra dans Jupyter en tant que noyau disponible, tant qu'il a ipykernelété répertorié pour l'installation dans votre custom_env.ymlfichier, comme cet exemple:

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

Juste pour prouver qu'il fonctionne avec un tas d'environnements personnalisés, voici une capture d'écran de Windows:

Le nb_conda_kernelspackage est le meilleur moyen d'utiliser jupyteravec conda. Avec des dépendances et une configuration minimales, il vous permet d'utiliser d'autres environnements conda à partir d'un ordinateur portable jupyter fonctionnant dans un environnement différent. Citant sa documentation :

Installation

Ce package est conçu pour être géré uniquement à l'aide de conda. Il doit être installé dans l'environnement à partir duquel vous exécutez Jupyter Notebook ou JupyterLab. Cela pourrait être votre baseenvironnement de condo, mais ce n'est pas nécessaire. Par exemple, si l'environnement notebook_envcontient le package de bloc-notes, vous exécutez

conda install -n notebook_env nb_conda_kernels

Tous les autres environnements auxquels vous souhaitez accéder dans vos blocs-notes doivent avoir un package de noyau approprié installé. Par exemple, pour accéder à un environnement Python, il doit avoir le ipykernelpackage; par exemple

conda install -n python_env ipykernel

Pour utiliser un environnement R, il doit avoir le package r-irkernel; par exemple

conda install -n r_env r-irkernel

Pour les autres langues, leurs noyaux correspondants doivent être installés.

Il vous suffit ensuite de démarrer le serveur de 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

Malgré la pléthore de réponses et les efforts de @ merv pour les améliorer, il est toujours difficile d'en trouver une bonne. J'ai fait celui-ci CW, alors votez-le en haut ou améliorez-le!

J'ai rencontré ce même problème où mon nouvel environnement conda myenvne pouvait pas être sélectionné en tant que noyau ou nouveau bloc-notes. Et courir jupter notebookà l'intérieur de l'env a donné le même résultat.

Ma solution et ce que j'ai appris sur la façon dont les blocs-notes Jupyter reconnaissent les conda-envs et les noyaux:

Installer jupyter et ipython myenvavec conda:

conda install -n myenv ipython jupyter

Après cela, courir en jupter notebookdehors de tout env répertorié en myenvtant que noyau avec mes environnements précédents.

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

Exécution du portable une fois que j'ai activé l'environnement:

source activate myenv
jupyter notebook

masque tous mes autres noyaux d'environnement et n'affiche que mes noyaux de langue:

python 2
python 3
R

Cela a fonctionné pour moi dans Windows 10 et la dernière solution:

1) Entrez dans cet environnement conda (activez votre_nom_env)

2) conda install -n votre_nom_env ipykernel

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

(REMARQUE: incluez les guillemets autour de "votre_nom_env", à l'étape 3)

Cela a été tellement frustrant. Mon problème était que dans un environnement conda python36 nouvellement construit, jupyter a refusé de charger «seaborn» - même si seaborn a été installé dans cet environnement. Il semblait être capable d'importer de nombreux autres fichiers du même environnement - par exemple numpy et pandas mais tout simplement pas seaborn. J'ai essayé plusieurs des correctifs suggérés ici et sur d'autres threads sans succès. Jusqu'à ce que je réalise que Jupyter n'exécutait pas le python du noyau à partir de cet environnement mais exécutait le python du système en tant que noyau. Même si un noyau d'aspect décent et kernel.json étaient déjà présents dans l'environnement. Ce n'est qu'après avoir lu cette partie de la documentation ipython: https://ipython.readthedocs.io/en/latest/install/kernel_install.html#kernels-for-different-environments et en utilisant ces commandes:

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

J'ai pu tout faire bien fonctionner. (Je n'ai pas réellement utilisé la variable —user).

Une chose que je n'ai pas encore compris est de savoir comment définir le python par défaut pour être le "Python (autre-env)". À l'heure actuelle, un fichier .ipynb existant ouvert depuis l'écran d'accueil utilisera le système python. Je dois utiliser le menu du noyau "Changer le noyau" pour sélectionner l'environnement python.

Bien que la réponse de @ coolscitist ait fonctionné pour moi, il existe également un moyen qui n'encombre pas votre environnement de noyau avec le package jupyter complet + deps. Il est décrit dans le documents ipython et n'est (je suppose) nécessaire que si vous exécutez le serveur notebook dans un environnement non-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'

Vous pouvez vérifier si cela fonctionne en utilisant

conda activate name_of_your_jupyter_server_env 
jupyter kernelspec list

J'ai eu un problème similaire et j'ai trouvé une solution qui fonctionne pour Mac, Windows et Linux. Il faut peu d'ingrédients clés dans la réponse ci-dessus:

Pour pouvoir voir conda env dans le cahier Jupyter, vous avez besoin de:

• le package suivant dans votre base env:
  conda install nb_conda

• le package suivant dans chaque env que vous créez:
  conda install ipykernel

• vérifiez la configuration de la jupyter_notebook_config.py
  première vérification si vous en avez un jupyter_notebook_config.pydans un emplacement donné par jupyter --paths
  s'il n'existe pas, créez-le en exécutant jupyter notebook --generate-config
  add ou assurez-vous d'avoir les éléments suivants:c.NotebookApp.kernel_spec_manager_class='nb_conda_kernels.manager.CondaKernelSpecManager'

L'env que vous pouvez voir dans votre terminal:

Sur Jupyter Lab, vous pouvez voir le même env que ci-dessus à la fois le portable et la console:

Et vous pouvez choisir votre env quand un cahier est ouvert:

Le moyen sûr est de créer un env spécifique à partir duquel vous exécuterez votre exemple dejupyter lab commande env . Activez votre env. Ajoutez ensuite l' exemple d'extension de laboratoire jupyter . Ensuite, vous pouvez exécuter jupyter lab

Suivez les instructions de la documentation iPython pour ajouter différents environnements conda à la liste des noyaux parmi lesquels choisir dans Jupyter Notebook. En résumé, après l'installation ipykernel, vous devez activer chaque environnement conda un par un dans un terminal et exécuter la commande python -m ipykernel install --user --name myenv --display-name "Python (myenv)", où myenvest l'environnement (noyau) que vous souhaitez ajouter.

Problème possible spécifique au canal

J'ai eu ce problème (encore) et il s'est avéré que j'ai installé à partir du canal conda-forge ; le supprimer et le réinstaller à partir du canal anaconda l' a corrigé à ma place.

Mise à jour : Je nouveau eu le même problème avec un nouveau env, cette fois , je n'installe nb_conda_kernelsde Anaconda canal, mais mon jupyter_clientétait de la Conda-forge canal. Désinstallationnb_conda_kernels et la réinstallation l'ont mis à jour vers un canal de priorité plus élevée.

Assurez-vous donc que vous avez installé à partir des bons canaux :)

Dans mon cas, en utilisant Windows 10 et conda 4.6.11, en exécutant les commandes

conda install nb_conda

conda install -c conda-forge nb_conda_kernels

depuis le terminal tout en ayant l'environnement actif n'a pas fait le travail après avoir ouvert Jupyter à partir de la même ligne de commande en utilisant conda jupyter notebook.

La solution était apparemment d'ouvrir Jupyter à partir d'Anaconda Navigator en accédant à mon environnement dans les environnements: ouvrez Anaconda Navigator, sélectionnez l'environnement dans les environnements, appuyez sur le bouton "play" de l'environnement choisi, puis sélectionnez "ouvrir avec Jupyter Notebook".

Environnements dans Anaconda Navigator pour exécuter Jupyter à partir de l'environnement sélectionné