Les environnements Conda n'apparaissent pas dans Jupyter Notebook
J'ai installé Anaconda (avec Python 2.7) et 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 le démarrage de Jupyter Notebook depuis le navigateur d'interface graphique ou depuis la ligne de commande dans la tensorflow env, 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, fichier sauvegardé, rouvert, mais cela n’a pas aidé.
Étrangement, je peux voir les deux environnements lorsque j'ouvre l'onglet Conda sur la page de couverture de Jupyter. Mais lorsque j'ouvre l'onglet Files et que j'essaie de new un cahier, je n'ai toujours qu'un seul noyau.
J'ai regardé cette question: environnement Link Conda avec Jupyter Notebook Mais il n'y a pas de répertoire tel que ~/Library/Jupyter/kernels sur mon ordinateur! Ce répertoire Jupyter ne contient qu'un seul sous-répertoire appelé runtime.
Je suis vraiment confus. Les environnements Conda sont-ils supposés devenir des noyaux automatiquement? (J'ai suivi https://ipython.readthedocs.io/fr/stable/install/kernel_install.html pour configurer manuellement les noyaux, mais on m'a dit que ipykernel était introuvable.)
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 documenté ici: http://ipython.readthedocs.io/fr/stable/install/kernel_install.html#kernels-for-different-environments Voir aussi ce problème .
Addendum: Vous devriez pouvoir installer le paquetage nb_conda_kernels avec conda install nb_conda_kernels pour ajouter automatiquement tous les environnements, voir https://github.com/Anaconda-Platform/nb_conda_kernels
Le problème est que, dans votre environnement tensorflow, vous pouvez exécuter jupyter notebooksans installer jupyter dans cet environnement. Il suffit de courir
(tensorflow) $ conda install jupyter
et l'environnement tensorflow devrait maintenant être visible dans Jupyter Notebooks démarré dans l'un de vos environnements conda sous la forme de quelque chose comme Python [conda env:tensorflow].
Si vos environnements ne s'affichent pas, vous n'avez probablement pas installé nb_conda_kernels dans l'environnement où Jupyter est installé. documentation d'Anaconda indique que
nb_conda_kernelsdoit être installé dans l'environnement à partir duquel vous exécutez Jupyter Notebook ou JupyterLab. Cela pourrait être votre environnement de base, mais ce n’est pas nécessairement le cas. Par exemple, si l’environnement notebook_env contient le package de bloc-notes, vous devez exécuterconda install -n notebook_env nb_conda_kernelsTous les autres environnements auxquels vous souhaitez accéder dans vos ordinateurs portables doivent avoir un package de noyau approprié installé. Par exemple, pour accéder à un environnement Python, celui-ci doit disposer du package ipykernel; par exemple.
conda install -n python_env ipykernelPour utiliser un environnement R, il doit disposer du package r-irkernel; par exemple.
conda install -n r_env r-irkernelPour les autres langues, les noyaux correspondants doivent être installés.
Notez qu'au moment de la publication de cette information, il y avait une cause possible de nb_conda ne prenant pas encore en charge les environnements Python 3.6 .
Si d'autres solutions ne permettent pas à Jupyter de reconnaître d'autres environnements Conda, vous pouvez toujours installer et exécuter jupyter à partir d'un environnement spécifique. Cependant, il est possible que vous ne puissiez pas voir ou basculer vers 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 effectuez cette opération dans de nombreux environnements, l’espace de stockage ajouté par l’installation de Jupyter dans chaque environnement risque d’être indésirable (selon votre système).
Pour que cela fonctionne, je devais exécuter toutes les commandes mentionnées dans les 3 premières réponses:
conda install jupyter
conda install nb_conda
conda install ipykernel
python -m ipykernel install --user --name mykernel
Il suffit de lancer conda install ipykernel dans votre nouvel environnement, vous obtiendrez alors un noyau avec cet env. Cela fonctionne même si vous avez différentes versions installées dans chaque env et que jupyter notebook n’est pas installé à nouveau. Vous pouvez démarrer votre cahier depuis n'importe quel env. Vous pourrez voir les nouveaux noyaux ajoutés.
Résumé (tldr)
Si vous voulez que le noyau 'python3' exécute toujours l'installation Python à partir de l'environnement où il a été lancé, supprimez le noyau User 'python3', qui prévaut sur l'environnement actuel:
jupyter kernelspec remove python3
Solution complète
Je vais poster une solution alternative et plus simple pour le cas suivant:
- Vous avez créé un environnement conda
- Jupyter est installé dans cet environnement (qui installe également ipykernel)
- Lorsque vous exécutez la commande
jupyter notebooket créez un nouveau cahier en cliquant sur "python3" dans le menu déroulant "Nouveau", ce cahier 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 à partir de cet environnement et PAS 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 depuis lequel vous lancez jupyter notebook. Toutefois, le lancement d'un bloc-notes avec 'python3' utilisera toujours l'installation Python à partir de l'environnement de base.
Ce qui est probable, c’est qu’il existe un noyau utilisateur python3. Exécutez la commande jupyter kernelspec list pour répertorier tous vos environnements. Par exemple, si vous avez un mac, vous recevrez le suivant (mon nom d'utilisateur est Ted).
python3 /Users/Ted/Library/Jupyter/kernels/python3
Jupyter cherche ici trois chemins différents à la recherche de noyaux. Il va de utilisateur à Env , à Système . Voir 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 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' à partir de l'environnement dans lequel vous avez lancé le cahier, et exécuter Python à partir de cet environnement.
Vous pouvez vérifier si vous avez un autre environnement 'python3' en consultant le chemin de recherche Env de votre système d'exploitation (voir le lien vers la documentation 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'ai en effet eu un noyau 'python3' listé ici.
Grâce à ce commentaire sur le problème GitHub (regardez la première réponse), vous pouvez supprimer l'environnement de l'utilisateur 'python3' à l'aide de 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 ce qui suit:
python3 /Users/Ted/anaconda3/envs/test_env/share/jupyter/kernels/python3
Notez que ce chemin est situé dans le répertoire test_env. Si vous créez un nouvel environnement, installez jupyter, activez-le et répertoriez les noyaux, vous obtiendrez un autre noyau 'python3' situé dans le chemin de son environnement.
Le noyau utilisateur 'python3' prenait le pas sur les noyaux Env 'python3'. En le supprimant, le noyau de l'environnement actif 'python3' était exposé et pouvait être choisi à chaque fois. Ceci é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é par défaut pour tout le monde, donc tout le monde n'est pas confronté à ce problème.
Nous avons beaucoup lutté 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 les packages mis à jour à partir de conda-forge, même dans votre environnement racine Miniconda.
Alors installez 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, à condition que ipykernel soit répertorié pour installation dans votre fichier custom_env.yml, comme dans l'exemple suivant:
name: bqplot
channels:
- conda-forge
- defaults
dependencies:
- python>=3.6
- bqplot
- ipykernel
Juste pour prouver que cela fonctionne avec plusieurs environnements personnalisés, voici une capture d'écran de Windows:
$ conda install nb_conda_kernels
(dans l’environnement conda où vous exécutez jupyter notebook) rendra tous les envois conda disponibles automatiquement. Pour accéder à d'autres environnements, les noyaux respectifs doivent être installés. Voici le ref .
J'ai rencontré ce même problème où mon nouvel environnement de conda, myenv, ne pouvait pas être sélectionné comme noyau ou nouveau bloc-notes. Et exécuter jupter notebook à partir de l'env a donné le même résultat.
Ma solution et ce que j'ai appris sur la façon dont les cahiers Jupyter reconnaissent les conda-envs et les noyaux:
Installer jupyter et ipython dans myenv avec conda:
conda install -n myenv ipython jupyter
Après cela, exécuter jupter notebook en dehors de tout env indiqué dans la liste myenv en tant que noyau avec mes environnements précédents.
Python [conda env:old]
Python [conda env:myenv]
Lancer le cahier une fois que j'ai activé l'environnement:
source activate myenv
jupyter notebook
cache tous mes autres noyaux d'environnement et ne montre que les noyaux de langue:
python 2
python 3
R
Bien que la réponse de @ coolscitist ait fonctionné pour moi, il existe également un moyen de ne pas encombrer votre environnement de noyau avec le package complet jupyter + deps. Il est décrit dans ipython docs et n’est (selon moi) nécessaire que si vous exécutez le serveur de cahier 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
Cela a été tellement frustrant. Mon problème était que, dans un environnement de conda python36 récemment construit, jupyter refusait de charger "Seaborn" - même si Seaborn était installé dans cet environnement. Il semblait pouvoir importer beaucoup d'autres fichiers du même environnement - par exemple, numpy et pandas, mais pas du tout né de la mer. J'ai essayé beaucoup de corrections suggérées ici et sur d'autres threads sans succès. Jusqu'à ce que je réalise que Jupyter n'exécutait pas le noyau python à partir de cet environnement, mais exécutait le système python 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 la lecture de cette partie de la documentation ipython: https://ipython.readthedocs.io/en/latest/install/kernel_install.html#kernels-for-different-environments et l’utilisation de 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. (Je n’ai pas utilisé la variable —user).
Une chose que je n'ai pas encore comprise est de savoir comment définir le paramètre par défaut python sur "Python (other-env)". Actuellement, un fichier .ipynb existant ouvert à partir de l'écran d'accueil utilise le système python. Je dois utiliser le menu du noyau “Changer le noyau” pour sélectionner l'environnement Python.
Le paquetage nb_conda_kernels est le meilleur moyen d'utiliser jupyter avec conda. Avec des dépendances et une configuration minimales, il vous permet d'utiliser d'autres environnements Conda à partir d'un ordinateur portable Jupyter s'exécutant dans un environnement différent. Citant sa documentation :
Installation
Ce paquet est conçu pour être géré uniquement avec conda. Il doit être installé dans l'environnement à partir duquel vous exécutez Jupyter Notebook ou JupyterLab. Cela pourrait être votre environnement
base, mais ce n’est pas nécessairement le cas. Par exemple, si l'environnementnotebook_envcontient le package de bloc-notes, vous devez exécuter
conda install -n notebook_env nb_conda_kernelsTous les autres environnements auxquels vous souhaitez accéder dans vos ordinateurs portables doivent avoir un package de noyau approprié installé. Par exemple, pour accéder à un environnement Python, celui-ci doit disposer du package
ipykernel; par exemple.
conda install -n python_env ipykernelPour utiliser un environnement R, il doit disposer du package r-irkernel; par exemple.
conda install -n r_env r-irkernelPour les autres langues, leur noyaux correspondants doit être installé.
Ensuite, tout ce que vous avez à faire est de démarrer le serveur de cahiers 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 encore difficile d'en trouver une bonne. J'ai créé celui-ci en CW, alors votez-le ou améliorez-le!
Cela a fonctionné pour moi dans Windows 10 et dernière solution:
1) Allez dans cet environnement de conda (activez votre nom_env)
2) conda install -n your_env_name ipykernel
3) python -m ipykernel install --user --name build_central --display-name "votre_nom_env"
(Remarque: inclure les guillemets autour de "your_env_name", à l'étape 3)
J'avais nb_conda installé dans tous mes envs, mais ils n'apparaissent toujours pas comme des noyaux sélectionnables dans jupyter notebook. Je courais jupyter notebook à partir de conda base.
Pour résoudre ce problème, je devais également installer nb_conda et nb_conda_kernels dans la base. Enfin, tous mes envois apparaissaient sous forme de noyaux.
J'espère que ça aide quelqu'un.
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 avoir installé 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ù myenv représente l'environnement (noyau) à ajouter.