Ambientes Conda não aparecendo no Jupyter Notebook


364

Instalei o Anaconda (com Python 2.7) e instalei o Tensorflow em um ambiente chamado tensorflow. Eu posso importar o Tensorflow com sucesso nesse ambiente.

O problema é que o Jupyter Notebook não reconhece o novo ambiente que acabei de criar. Não importa que eu inicie o Jupyter Notebook no GUI Navigator ou na linha de comando dentro do ambiente tensorflow, existe apenas um kernel no menu chamado Python [Root]e o Tensorflow não pode ser importado. Obviamente, cliquei nessa opção várias vezes, salvei o arquivo, reabri-o, mas isso não ajudou.

Estranhamente, posso ver os dois ambientes quando abro a Condaguia na primeira página do Jupyter. Mas quando abro a Filesguia e tento para newum notebook, ainda acabo com apenas um kernel.

Eu olhei para esta pergunta: Vincule o ambiente Conda ao Jupyter Notebook Mas não existe um diretório como o ~/Library/Jupyter/kernelsmeu computador! Este diretório Jupyter possui apenas um subdiretório chamado runtime.

Estou realmente confuso. Os ambientes Conda devem se tornar kernels automaticamente? (Segui https://ipython.readthedocs.io/en/stable/install/kernel_install.html para configurar manualmente os kernels, mas foi informado que ipykernelnão foi encontrado.)


43
Execute conda install ipykernelnesse ambiente.
Thomas K

11
conda install ipykernelparece instalar jupyterno ambiente ... Estou perdendo alguma coisa?
Dror

11
presumivelmente o ipykernel tem o jupyter como uma dependência?
Kevinkayaks

11
não parece mais funcionar ... veja a resposta abaixo em Andreas
Casey L

@ThomasK isso funciona apenas se nb_condafor usado ou se o kernel estiver configurado manualmente, conforme sugerido na pergunta. Caso contrário, ele realmente estragará bastante as coisas. O executável jupyterapontará para um executável dentro do ambiente, mas o sistema jupyter-notebookserá iniciado (se instalado) e, portanto, não usará o ambiente com o kernel padrão.
Lumbric 12/08/19

Respostas:


543

Eu não acho que as outras respostas estejam funcionando mais, pois o conda parou de configurar automaticamente os ambientes como kernels jupyter. Você precisa adicionar manualmente os kernels para cada ambiente da seguinte maneira:

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

Conforme documentado aqui: http://ipython.readthedocs.io/en/stable/install/kernel_install.html#kernels-for-different-environments Consulte também este problema .

Adendo: você deve poder instalar o nb_conda_kernelspacote conda install nb_conda_kernelspara adicionar todos os ambientes automaticamente, consulte https://github.com/Anaconda-Platform/nb_conda_kernels


28
É possível, de alguma forma, sinalizar a solução mais atualizada a partir de hoje?
N. CHATURV3DI

11
Só isso funcionou para mim! conda install nb_conda - não ajudou. Obrigado!
Deil

2
Instalando nb_conda_kernelstrabalhou para mim a partir de abril 2018 ( Python 3.6.4, conda 4.3.27, jupyter 4.4.0).
precisa saber é o seguinte

3
Correção no meu comentário anterior: o novo ambiente não aparece apenas na primeira vez. Depois de desativar e ativar o ambiente novamente, abra o jupyter e ele será exibido corretamente.
R71

23
Se isso não funcionar, tente executar conda install ipykernelesta resposta assume que você já o possui instalado em seu ambiente.
Ken Myers

151

Se seus ambientes não estão aparecendo, você provavelmente não tem nb_conda_kernelsinstalado no ambiente em que o Jupyter está instalado. A documentação da Anaconda afirma que

nb_conda_kernelsdeve ser instalado no ambiente a partir do qual você executa o Jupyter Notebook ou o JupyterLab. Este pode ser o seu ambiente básico de condado, mas não precisa ser. Por exemplo, se o ambiente notebook_env contiver o pacote do notebook, você executaria

conda install -n notebook_env nb_conda_kernels

Quaisquer outros ambientes que você deseja acessar em seus notebooks devem ter um pacote de kernel apropriado instalado. Por exemplo, para acessar um ambiente Python, ele deve ter o pacote ipykernel; por exemplo

conda install -n python_env ipykernel

Para utilizar um ambiente R, ele deve ter o pacote r-irkernel; por exemplo

conda install -n r_env r-irkernel

Para outros idiomas, seus kernels correspondentes devem estar instalados.

Observe que no momento em que publicamos isso originalmente, havia uma causa possível por nb_condaainda não oferecer suporte a ambientes Python 3.6 .

Se outras soluções falharem no Jupyter para reconhecer outros ambientes conda, você sempre poderá instalar e executar a jupyterpartir de um ambiente específico. Talvez você não consiga ver ou alternar para outros ambientes a partir do 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

Observe que estou executando o Python 3.6.1 neste notebook: insira a descrição da imagem aqui

Observe que, se você fizer isso com muitos ambientes, o espaço de armazenamento adicional da instalação do Jupyter em todos os ambientes poderá ser indesejável (dependendo do seu sistema).


Oi Desculpe abrir este tópico novamente. No entanto, eu tentei de tudo como recomendado aqui e ainda não vejo o tensorflow env em jupyter. Eu tenho o jupyter instalado no ambiente tensorflow. Eu tenho o python 3.6.1 instalado lá. Eu tentei instalar o conda nb_conda, mas ele diz estar em conflito com o py3.6. Para que não seja instalado, repouse tudo o que tentei e não parece funcionar. Algum conselho?
precisa saber é o seguinte

Está bem. Eu verifiquei novamente. Meu problema é que meu jupyter, quando aberto com o kernel Python 3, não pode importar nenhum módulo. Não sei por que é isso. E também ele não mostra outra env muito
Baktaawar

2
@Baktaawar, veja minha resposta atualizada demonstrando como usar o python 3.6 no notebook. Você pode executar um ambiente python 3.6, basta iniciar o jupyter com esse ambiente ativo. Os ambientes Conda podem ser considerados instalações python independentes. Se você instalar o Jupyter no python do sistema, também verá apenas uma opção do kernel python. nb_condaO objetivo é apenas "[fornecer] o ambiente Conda e a extensão de acesso ao pacote a partir do Jupyter", para que você não possa executar o Jupyter a partir da instalação python escolhida.
Steven C. Howell

11
@ StevenC.Howell obrigado por abordar a minha preocupação. Eu acho que você ainda precisa mencionar que ipykernelprecisa ser instalado em cada ambiente que você deseja usar como kernel.
Merv

11
Hmm, não sei por que funciona sem ele. Você está certo, eles afirmam claramente que deve ser instalado. Eu adicionei isso à minha resposta. Obrigado!
Steven C. Howell

112

O irritante é que, no seu tensorflowambiente, você pode executar jupyter notebook sem instalar jupyternesse ambiente . Apenas corra

(tensorflow) $ conda install jupyter

e o tensorflowambiente agora deve estar visível nos Jupyter Notebooks iniciados em qualquer um de seus condaambientes como algo parecido Python [conda env:tensorflow].


6
Eu tinha o mesmo problema que Thomas K, e a solução compartilhada por Octavius ​​também resolveu o meu problema. No entanto, há um problema: se você possui a versão Python 3 do Anaconda, poderá ver apenas o seu ambiente ativo atual e ele deve ter seu próprio Jupyter. Mas se você instalar a versão Python 2 do Anaconda, ele poderá lidar com todos os ambientes.
Rkmalaiya

6
você pode fazer "conda install nb_conda" também na versão Python2 do anaconda para gerenciar seus envs do próprio Jupyter.
Rkmalaiya

7
@rkmalaiya está correto. Se você estiver executando o Miniconda3 ou o Anaconda3, execute conda install nb_condaem um dos ambientes conda de origem (com o notebook jupyter instalado). Em seguida, você pode alternar os envios de kernels / conda no navegador de notebooks jupyter.
precisa

11
Pode relatar este método funciona on Set 2018 com Anaconda 5.2 Python 3.6
jdr5ca

13
Essa é uma resposta terrível, porque incentiva os usuários a instalar o Jupyter em todos os ambientes, o que é completamente desnecessário. A razão pela qual isso funciona é que ipykernel(que é a única coisa realmente necessária), é uma dependência de jupyter.
merv

72

Eu tive que executar todos os comandos mencionados nas 3 principais respostas para que isso funcionasse:

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

9
Este foi o que funcionou para mim também, mas eu não precisavaconda install nb_conda
Ken Myers

3
Destilação incrível!
Bao-Tin Hoang

11
Eu só precisava de os 3 primeiros comandos para mostrar o kernel ambiente como uma opção quando eu corro jupyter labdentro daquele ambiente específico
Igor Fobia

3
Trabalhou para mim também. Meu Deus, isso foi frustrante para descobrir.
Trevor Bye

4
Você não precisa de nb_conda! ;)
Prayson W. Daniel 6/02/19

48

Basta executar conda install ipykernelem seu novo ambiente, somente então você obterá um kernel com este ambiente. Isso funciona mesmo se você tiver versões diferentes instaladas em cada envs e não instalar o notebook jupyter novamente. Você pode iniciar o seu notebook a partir de qualquer ambiente em que possa ver os kernels adicionados recentemente.


10
Esta é a melhor resposta a partir de janeiro de 2018. O Jupyter deve descobrir automaticamente seu kernel na inicialização, se você simplesmente estiver conda install ipykerneldentro do seu ambiente conda. Na pior das hipóteses, você pode usar python -m ipykernel install --user --name mykernelpara gerar manualmente o kernel, mas não o faria se ele já for descoberto automaticamente ou ele será exibido duas vezes na lista de kernel.
colllin

2
isso também instalará o Jupiter e todas as suas dependências. Ele funciona, mas de alguma forma não é ideal
Quickbeam2k1

16

Resumo (tldr)

Se você deseja que o kernel 'python3' sempre execute a instalação do Python no ambiente em que é iniciado, exclua o kernel do usuário 'python3', que tem precedência sobre qualquer que seja o ambiente atual:

jupyter kernelspec remove python3

Solução completa

Vou postar uma solução alternativa e mais simples para o seguinte caso:

  • Você criou um ambiente conda
  • Este ambiente possui o jupyter instalado (que também instala o ipykernel)
  • Quando você executa o comando jupyter notebooke cria um novo bloco de notas clicando em 'python3' no menu suspenso 'Novo', esse bloco de notas executa o python no ambiente base e não no ambiente atual.
  • Você gostaria que o lançamento de um novo notebook com 'python3' em qualquer ambiente execute a versão Python desse ambiente e NÃO a base

Vou usar o nome 'test_env' para o ambiente pelo restante da solução. Além disso, observe que 'python3' é o nome do kernel.

A resposta atualmente mais votada funciona, mas há uma alternativa. Ele diz para fazer o seguinte:

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

Isso lhe dará a opção de usar o ambiente test_env, independentemente de qual ambiente você iniciar jupyter notebook. Porém, o lançamento de um notebook com 'python3' ainda utilizará a instalação do Python a partir do ambiente base.

O que provavelmente está acontecendo é que existe um kernel python3 do usuário. Execute o comando jupyter kernelspec listpara listar todos os seus ambientes. Por exemplo, se você tiver um Mac, você receberá o seguinte (meu nome de usuário é Ted).

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

O que Jupyter está fazendo aqui é pesquisar três caminhos diferentes, procurando kernels. Vai de Usuário , para Env , para Sistema . Consulte este documento para obter mais detalhes sobre os caminhos que ele procura para cada sistema operacional.

Os dois kernels acima estão no caminho do usuário, o que significa que estarão disponíveis independentemente do ambiente em que você iniciar um notebook jupyter. Isso também significa que, se houver outro kernel 'python3' no nível do ambiente, você nunca poderá acessá-lo.

Para mim, faz mais sentido que escolher o kernel 'python3' no ambiente em que você lançou o notebook execute o Python nesse ambiente.

Você pode verificar se possui outro ambiente 'python3' procurando no caminho de pesquisa Env do seu sistema operacional (consulte o link para os documentos acima). Para mim (no meu mac), emiti o seguinte comando:

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

E eu realmente tinha um kernel 'python3' listado lá.

Graças a este comentário de problema do GitHub (observe a primeira resposta), você pode remover o ambiente 'python3' do usuário com o seguinte comando:

jupyter kernelspec remove python3

Agora, quando você executa jupyter kernelspec list, assumindo que o test_env ainda esteja ativo, você obtém o seguinte:

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

Observe que esse caminho está localizado no diretório test_env. Se você criar um novo ambiente, instalar o jupyter, ativá-lo e listar os kernels, obterá outro kernel 'python3' localizado no caminho do ambiente.

O kernel do usuário 'python3' estava tendo precedência sobre qualquer um dos kernels Env 'python3'. Ao removê-lo, o kernel 'python3' do ambiente ativo foi exposto e pode ser escolhido sempre. Isso elimina a necessidade de criar manualmente os kernels. Também faz mais sentido em termos de desenvolvimento de software, onde se deseja isolar-se em um único ambiente. A execução de um kernel diferente do ambiente host não parece natural.

Parece também que este usuário 'python3' não está instalado para todos por padrão; portanto, nem todos são confrontados com esse problema.


Instalação do python -m ipykernel --user --name test_env --display-name "Python (test_env)" funciona como um encanto. Obrigado
slobodan.blazeski

12
    $ conda install nb_conda_kernels

(no ambiente conda em que você executa o notebook jupyter) disponibilizará todos os envs do conda automaticamente. Para acessar outros ambientes, os respectivos kernels devem ser instalados. Aqui está a ref .


Isso apenas recapitula stackoverflow.com/a/48349338/570918 ?
merv

Parece a maneira mais simples.
Decula 04/03/19

9

Temos muita dificuldade com esse problema, e aqui está o que funciona para nós. Se você usa o canal conda-forge , é importante verificar se você está usando pacotes atualizados conda-forge, mesmo em seu Minicondaambiente raiz.

Instale o Miniconda e faça:

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 seu ambiente personalizado será exibido no Jupyter como um kernel disponível, desde que ipykernellistado para instalação no seu custom_env.ymlarquivo, como neste exemplo:

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

Apenas para provar que ele funciona com vários ambientes personalizados, aqui está uma captura de tela do Windows:

insira a descrição da imagem aqui


8

o nb_conda_kernels pacote é a melhor maneira de usar jupytercom conda. Com dependências e configurações mínimas, permite usar outros ambientes conda de um notebook jupyter em execução em um ambiente diferente. Citando sua documentação :

Instalação

Este pacote foi projetado para ser gerenciado exclusivamente usando o conda. Ele deve ser instalado no ambiente em que você executa o Jupyter Notebook ou o JupyterLab. Este pode ser o seubase ambiente conda, mas não precisa ser. Por exemplo, se o ambiente notebook_envcontiver o pacote do notebook, você executaria

conda install -n notebook_env nb_conda_kernels

Quaisquer outros ambientes que você deseja acessar em seus notebooks devem ter um pacote de kernel apropriado instalado. Por exemplo, para acessar um ambiente Python, ele deve ter o ipykernelpacote; por exemplo

conda install -n python_env ipykernel

Para utilizar um ambiente R, ele deve ter o pacote r-irkernel; por exemplo

conda install -n r_env r-irkernel

Para outros idiomas, seus kernels correspondentes devem estar instalados.

Então, tudo o que você precisa fazer é iniciar o servidor 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

insira a descrição da imagem aqui


Apesar da infinidade de respostas e dos esforços da @ merv para melhorá-las, ainda é difícil encontrar uma boa. Eu fiz este CW, então vote no topo ou melhore!



7

Corri para o mesmo problema em que meu novo ambiente conda myenvnão podia ser selecionado como um kernel ou um novo notebook. E correndojupter notebook de dentro do ambiente deu o mesmo resultado.

Minha solução e o que aprendi sobre como os notebooks Jupyter reconhecem condda-envs e kernels:

Instalando jupyter e ipython no myenvconda:

conda install -n myenv ipython jupyter

Depois disso, executando jupter notebookfora de qualquer ambiente listado myenvcomo um kernel junto com meus ambientes anteriores.

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

Executando o notebook uma vez que eu ativei o ambiente:

source activate myenv
jupyter notebook

oculta todos os meus outros kernels de ambiente e mostra apenas meus kernels de idioma:

python 2
python 3
R

6

Isso funcionou para mim no Windows 10 e na solução mais recente:

1) Entre nesse ambiente conda (ative seu_env_name)

2) instalação conda -n your_env_name ipykernel

3) instalação do python -m ipykernel --user --name build_central --display-name "your_env_name"

(OBSERVAÇÃO: inclua aspas em "your_env_name", na etapa 3)


4

Isso foi tão frustrante que meu problema era que, em um ambiente recém-construído do condda python36, o jupyter se recusou a carregar “seaborn” - mesmo que o seaborn tenha sido instalado nesse ambiente. Parecia poder importar muitos outros arquivos do mesmo ambiente - por exemplo, numpy e pandas, mas não apenas no mar. Tentei muitas das correções sugeridas aqui e em outros threads sem êxito. Até eu perceber que o Jupyter não estava executando o kernel python dentro desse ambiente, mas executando o sistema python como kernel. Mesmo que um kernel com aparência decente e o kernel.json já estivessem presentes no ambiente. Foi somente depois de ler esta parte da documentação do ipython: https://ipython.readthedocs.io/en/latest/install/kernel_install.html#kernels-for-different-environments e usar estes comandos:

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

Consegui fazer tudo correr bem. (Na verdade, eu não usei a variável user).

Uma coisa que ainda não descobri é como definir o python padrão como o "Python (outro env)". Atualmente, um arquivo .ipynb existente aberto na tela inicial usará o python do sistema. Eu tenho que usar o menu Kernel "Alterar kernel" para selecionar o ambiente python.


4

Enquanto a resposta do @ coolscitist funcionou para mim, também existe uma maneira de não desorganizar o ambiente do kernel com o pacote jupyter completo + deps. Ele é descrito nos documentos do ipython e é (suspeito) apenas necessário se você executar o servidor notebook em um ambiente não básico.

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'

Você pode verificar se funciona usando

conda activate name_of_your_jupyter_server_env 
jupyter kernelspec list

11
na verdade, atualizar o jupyter e usar conda install nb_conda_kernelsfunciona melhor.
jan-GLX

Observe que essa python -m ipykernel installé a rota tradicional de registrar um env e funciona para outros envs (não pertencentes à Conda). A idéia por trás nb_conda_kernelsdisso é que você não precisa fazer isso manualmente, desde que instale ipykernel.
merv 31/05/19

Sim! Transformei esse comentário em uma resposta independente .
jan-glx

2

Eu tive um problema semelhante e encontrei uma solução que está funcionando para Mac, Windows e Linux. São necessários poucos ingredientes principais que estão na resposta acima:

Para poder ver conda env no notebook Jupyter, você precisa:

  • o seguinte pacote em sua base env:
    conda install nb_conda

  • o seguinte pacote em cada ambiente que você cria:
    conda install ipykernel

  • verifique a configuração da jupyter_notebook_config.py
    primeira verificação se você tiver um jupyter_notebook_config.pyem um dos locais fornecidos por jupyter --paths
    se ele não existir, crie-o executando jupyter notebook --generate-config
    add ou verifique se você possui o seguinte:c.NotebookApp.kernel_spec_manager_class='nb_conda_kernels.manager.CondaKernelSpecManager'

O ambiente que você pode ver no seu terminal: insira a descrição da imagem aqui

No Jupyter Lab, você pode ver o mesmo ambiente acima do Notebook e do console: insira a descrição da imagem aqui

E você pode escolher o seu ambiente quando tiver um notebook aberto: insira a descrição da imagem aqui

A maneira segura é criar um env específico a partir do qual você executará seu exemplo dejupyter lab comando env . Ative seu ambiente. Em seguida, adicione o exemplo de extensão do laboratório jupyter . Então você pode correr jupyter lab


1

Siga as instruções na documentação do iPython para adicionar diferentes ambientes conda à lista de kernels para escolher no Jupyter Notebook. Em resumo, após a instalação ipykernel, você deve ativar cada ambiente conda um por um em um terminal e executar o comando python -m ipykernel install --user --name myenv --display-name "Python (myenv)", onde myenvestá o ambiente (kernel) que deseja adicionar.


1

Possível problema específico do canal

Eu tive esse problema (novamente) e, por fim, instalei a partir do canal conda-forge ; removê-lo e reinstalar a partir do canal anaconda , em vez disso, corrigi-lo para mim.

Atualização : Eu voltou a ter o mesmo problema com um novo env, desta vez eu tenha instalado nb_conda_kernelsa partir anaconda canal, mas a minha jupyter_clientera da Conda-forja canal. Desinstalar nb_conda_kernelse reinstalar atualizou isso para um canal de prioridade mais alta.

Portanto, verifique se você instalou a partir dos canais corretos :)


Parece que você pode ter algumas coisas confusas. jupytere nb_conda_kernelsdeve ser instalado em um ambiente - é aqui que você sempre foge jupyter notebook. Novos envs só precisam ipykernel, mas não devem ser ativados durante a execução jupyter notebook.
merv 29/04

11
Estou ciente, estava em uma nova máquina.
xyzzyqed 30/04

11
OK. Eu editei sua resposta, principalmente para poder alterar meu voto, mas também para esclarecer o que você estava chamando de canal conda (nada disso - padrões ou anaconda ). Sinta-se à vontade para editá-lo ainda mais se eu estiver distorcendo o que aconteceu.
merv 30/04

-1

No meu caso, usando o Windows 10 e o conda 4.6.11, executando os comandos

conda install nb_conda

conda install -c conda-forge nb_conda_kernels

do terminal enquanto o ambiente estava ativo não funcionou depois que eu abri o Jupyter na mesma linha de comando usando conda jupyter notebook.

Aparentemente, a solução foi abrir o Jupyter a partir do Anaconda Navigator, indo ao meu ambiente em Ambientes: Abra o Anaconda Navigator, selecione o ambiente em Ambientes, pressione o botão "reproduzir" no ambiente escolhido e selecione 'abrir com o Jupyter Notebook'.

Ambientes no Anaconda Navigator para executar o Jupyter no ambiente selecionado


11
Dê uma olhada na documentação sobre como usar os kernels do Conda. Você inicia o Jupyter a partir do ambiente que possui o Jupyter; você instala ipykernelem todos os envs que deseja usar no Jupyter como kernels.
Merv # 01/06
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.