Ambientes Conda não aparecendo no Jupyter Notebook

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.)

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

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:

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).

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].

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

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.

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.

    $ 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 .

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:

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

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!

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

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)

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.

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

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:

No Jupyter Lab, você pode ver o mesmo ambiente acima do Notebook e do console:

E você pode escolher o seu ambiente quando tiver um notebook aberto:

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

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.

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 :)

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