I am trying to install feature-engine module on anaconda
this is the error i am getting
Package is not available from current channels
repo.anaconda win 64 , noarch etc.
Can you please help me with the problem?
Thanks,
RD
to install from anaconda:
conda install -c conda-forge feature_engine
I believe that feature-engine is not available through anaconda channels for installation with conda install. I was able to install it via pip. Here is how I did it (in Windows):
open a CMD and run conda activate <<VIRTUALENV>>. This is the environment you create for your project. If you have not created one, then use base, the default one.
cd to the location of your pip installation within that activated conda Virtual environment (mine was within my user folder in \AppData\Local\Continuum\anaconda3\envs\<<VIRTUALENV>>\Scripts).
in there, run pip install feature-engine
you should now be able to see it listed under pip freeze or pip list, but not under conda list.
Finally, go to your code location and run the code. remember to activate that same <> each time you open a new CMD to run it.
Hope it helps.
If you are using Jupyter Notebooks, it might be the case that your Jupyter Notebook is not actually running the kernel in your (activated!) Anaconda environment (via this answer), but the generic Python3 kernel that only can import packages from your global Anaconda environment.
You can check for this by importing a package that is installed in your global environment (e.g., pandas), while running a notebook:
import pandas
pandas.__file__
If you see something likes this (on Windows), you are indeed running the wrong kernel (as you would expect the packages to be loaded from the activated environments):
'C:\\Users\\<user>\\Anaconda3\\lib\\site-packages\\pandas\\__init__.py'
Therefore, in your Anaconda Prompt, you have to create a new kernel within ipykernel (assuming cenv is your environment of interest):
$ conda activate cenv # . ./cenv/bin/activate in case of virtualenv
(cenv)$ conda install ipykernel
(cenv)$ ipython kernel install --user --name=<any_name_for_kernel>
(cenv)$ jupyter notebook
Now, in the restarted Jupyter Notebook you can change the kernel via the menu: Kernel > Change kernel > <any_name_for_kernel>
Importing the same package, like pandas, should show the following file path:
'C:\\Users\\<user>\\Anaconda3\\envs\\<cenv>\\lib\\site-packages\\pandas\\__init__.py'
and you should be able to import any package installed in that Anaconda environment.
I am trying to use the interactive shell of IPython within my conda env and am having issues.
The steps I take are:
source activate myenv
conda install ipython
ipython
When I am in ipython interactive shell, it calls python from the anaconda root bin. (~/anaconda2/bin')
Is there anything I can do to change the python path to ~/anaconda2/envs/myenv/bin and import packages from myenv?
I see few solutions to making env work in jupyter when I search the web, but no answer on making it work on the interactive shell.
This is likely due to your $PATH variable being messed up.
THe easiest way to make sure you get IPython from within an env is to use $ python -m IPython <rest of the options> to start IPython. This works for many of the Python installable application; like pytest, pip and other.
I have jupyter/anaconda/python3.5.
How can I know which conda environment is my jupyter notebook running on?
How can I launch jupyter from a new conda environment?
As mentioned in the comments, conda support for jupyter notebooks is needed to switch kernels. Seems like this support is now available through conda itself (rather than relying on pip).
http://docs.continuum.io/anaconda/user-guide/tasks/use-jupyter-notebook-extensions/
conda install nb_conda
which brings three other handy extensions in addition to Notebook Conda Kernels.
Question 1: Find the current notebook's conda environment
Open the notebook in Jupyter Notebooks and look in the upper right corner of the screen.
It should say, for example, "Python [env_name]" if the language is Python and it's using an environment called env_name.
Question 2: Start Jupyter Notebook from within a different conda environment
Activate a conda environment in your terminal using source activate <environment name> before you run jupyter notebook. This sets the default environment for Jupyter Notebooks. Otherwise, the [Root] environment is the default.
You can also create new environments from within Jupyter Notebook (home screen, Conda tab, and then click the plus sign).
And you can create a notebook in any environment you want. Select the "Files" tab on the home screen and click the "New" dropdown menu, and in that menu select a Python environment from the list.
which environment is jupyter executing:
import sys
print(sys.executable)
create kernel for jupyter notebook
source activate myenv
python -m ipykernel install --user --name myenv --display-name "Python (myenv)"
source activate other-env
python -m ipykernel install --user --name other-env --display-name "Python (other-env)"
http://ipython.readthedocs.io/en/stable/install/kernel_install.html#kernel-install
If the above ans doesn't work then try running conda install ipykernel in new env and then run jupyter notebook from any env, you will be able to see or switch between those kernels.
to show which conda env a notebook is using just type in a cell:
!conda info
if you have grep, a more direct way:
!conda info | grep 'active env'
You can also switch environments in Anaconda Navigator, install Jupiter and run it.
Because none of the answers above worked for me, I write here the solution that finally solved my problem on Ubuntu. My problem was:
I did the following steps:
Activate my environment: conda activate MyEnv
Start jupyter notebook:jupyter notebook
Although MyEnv was active in the terminal and had an asterix when writing conda env list, but jupyter notebook was started with the base environment.
Installing nb_conda and ipykernel didn't solve the problem for me either. Additionally, the conda tab wasn't appearing in jupyter notebook and also clicking on the kernels or going to the menu Kernel->Change Kernel didn't show the kernel MyEnv.
Solution was: install the jupyter_environment_kernel in MyEnv environment:
pip install environment_kernels
After that when starting jupyter notebook, it is started with the right environment. You can also switch between environments without stopping the kernel, by going to the menu Kernel->Change Kernel and selecting the desired kernel.
Question 1: How can I know which conda environment is my jupyter notebook running on?
Launch your Anaconda Prompt and run the command conda env list to list all the available conda environments.
You can clearly see that I've two different conda environments installed on my PC, with my currently active environment being root(Python 2.7), indicated by the asterisk(*) symbol ahead of the path.
Question 2: How can I launch jupyter from a new conda environment?
Now, to launch the desired conda environment, simply run activate <environment name>. In this case, activate py36
For more info, check out this link and this previous Stack Overflow question..
The following commands will add the env in the jupyter notebook directly.
conda create --name test_env
conda activate test_env
conda install -c anaconda ipykernel
python -m ipykernel install --user --name=test_env
Now It should say, "Python [test_env]" if the language is Python and it's using an environment called test_env.
To check on which environment your notebook is running type the following commands in the notebook shell
import sys
print(sys.executable)
To launch the notebook in a new environment deactivate that environment first. Create a conda environment and then install the ipykernel. Activate that environment. Install jupyter on that environment.
conda create --name {envname}
conda install ipykernel --name {envname}
python -m ipykernel install --prefix=C:/anaconda/envs/{envname} --name {envname}
activate envname
pip install jupyter
In your case path "C:/anaconda/envs/{envname}" could be different, check accordingly.
After following all steps, launch notebook and do step 1
run the following in shell.
sys.executable
This should show: Anaconda/envs/envname
On Ubuntu 20.04, none of the suggestions above worked.
I.e. I activated an existing environment. I discovered (using sys.executable and sys.path) that my jupyter notebook kernel was running the DEFAULT Anaconda python, and NOT the python I had installed in my activated environment. The consequence of this was that my notebook was unable to import packages that I had installed into this particular Anaconda environment.
Following instructions above (and a slew of other URLs), I installed ipykernel, nb_conda, and nb_conda_kernels, and ran: python -m ipykernel --user --name myenv.
Using the Kernels|Change Kernel... menu in my Jupyter notebook, I selected myenv, the one I had specified in my python -m ipykernel command.
However, sys.executable showed that this did not "stick".
I tried shutting down and restarting, but nothing resulted in my getting the environment I had selected.
Finally, I simply edited file kernel.json in folder:
~/.local/share/jupyter/kernels/myenv
Sure enough, despite my having performed all the steps suggested above, the first argument in this JSON file was still showing the default python location:
$Anaconda/bin/python (where $Anaconda is the location where I installed anaconda)
I edited file kernel.json with a text editor so that this was changed to:
$Anaconda/envs/myenv/bin/python
Hopefully, my use of myenv is understood to mean that you should replace this with the name of YOUR environment.
Having edited this file, my Jupyter notebooks started working properly - namely, they used the python specified for my activated environment, and I was able to import packages that were installed in this environment, but not the base Anaconda environment.
Clearly, something is messed up in how the set of packages ipykernel, nb_conda, and nb_conda_kernels are configuring Anaconda environments for jupyter.
I have tried every method mentioned above and nothing worked, except installing jupyter in the new environment.
to activate the new environment
conda activate new_env
replace 'new_env' with your environment name.
next install jupyter
'pip install jupyter'
you can also install jupyter by going to anaconda navigator and selecting the right environment, and installing jupyter notebook from Home tab
Adding to the above answers, you can also use
!which python
Type this in a cell and this will show the path of the environment. I'm not sure of the reason, but in my installation, there is no segregation of environments in the notebook, but on activating the environment and launching jupyter notebook, the path used is the python installed in the environment.
For windows 10,
Go into Anaconda Launcher
In the 'Applications on' dropdown menu, select the required conda environment.
Install Jupyter notebook in the Anaconda Launcher
Launch Jupyter notebook from the Anaconda Launcher
The Conda tab is visible in the Jupyter notebook where you can see your active conda env.
For checking on Which Python your Jupyter Notebook is running try executig this code.
from platform import python_version
print(python_version())
In order to run jupyter notebook from your environment
activate MYenv
and install jupyter notebook using command
pip install jupyter notebook
then just
jupyter notebook
What solved the issue for me was that I had to run the following command:
python -m ipykernel install --user --name myenv --display-name "Python (myenv)"
The issue was that I opened a jupyter notebook made with/for a kernel for another conda python environment. That was visible from the output on the terminal; it is handy op run jupyter notebook from a terminal on the conda environment so that you can easily see what error messages are shown. Then it became clear that the notebook tried to run python from another environment.
Inspecting the folder/files:
C:\Users\<username>\AppData\Roaming\jupyter\kernels\<env name>\kernel.json
"argv": [
"D:\\Users\\<username..path>\\envs\\<env name>\\python.exe",
"-m",
"ipykernel_launcher",
"-f",
"{connection_file}"
],
"display_name": "Python (env name)",
"language": "python",
"metadata": {
"debugger": true
}
}
So you can check and correct if necessary.
Second, when using anaconda/conda, make sure you have a healthy channel policy and execute the following commands when creating a new environment:
conda config --add channels conda-forge
conda config --set channel_priority strict
It solved this problem for me, I hope it helps you too.
I recently began using julia, and I would like to use in with IPython Notebook/Jupyter.
So, I installed julia using MacPorts, i.e. sudo port install julia. Following the installation instructions here: https://github.com/JuliaLang/IJulia.jl
After the prompt, I used "Pkg.add("IJulia") to install IJulia.
However, I cannot use Julia with IPython notebook. After opening the notebook with
ipython notebook --profile=julia
the kernel for the julia notebook dies instantly and cannot be restarted.
The error on the Terminal shows:
[I 19:03:19.410 NotebookApp] KernelRestarter: restarting kernel (1/5)
WARNING:root:kernel dc00ae3a-8fa6-4d01-a802-f7845a16a9ba restarted
ERROR: SHA256 not defined
in include at /opt/local/lib/julia/sys.dylib
in process_options at /opt/local/lib/julia/sys.dylib
in _start at /opt/local/lib/julia/sys.dylib
while loading /Users/NAME/.julia/v0.3/IJulia/src/kernel.jl, in expression starting on line 6
I suspect I have installed IJulia incorrectly? How can I solve this?
(The version of julia is julia version 0.3.11. The version of python is Python 2.7.10. The version of ipython is 4.0.0.)
The current stable version of Julia is v0.4.0.
You should download it directly from the Julia homepage (.dmg):
http://julialang.org/downloads/
Having done that, run it and do Pkg.add("IJulia") again.
Then from within Julia do
using IJulia
notebook()
Note that the Jupyter Notebook (the new name for what used to be the IPython Notebook) is run as
jupyter notebook
The --profile julia is no longer necessary and should be removed.
Furthermore, this (jupyter notebook) will only work if you had a previous installation of Jupyter, which seems to be the case. In this case, I suggest you upgrade it with conda, if you installed Anaconda, or with pip.)
So I installed Anaconda on my Ubuntu linux 12.04LTS x64 box. It seems to work fine except for this. So I created a conda environment using the
conda create -n py33dev python=3 anaconda
When I try to run the ipython shell, I would expect to get the Ipython3 shell and notebook. However, it still loads the ipython 2.7.6 shell. I tried using the ipython3 command, but it will then load an ipython3 shell from my computer and not from Anaconda.
I tried to install ipython3 to the Anaconda environment using
pip install ipython3
and
conda install ipython3
However, when I do this I just get a message saying "No packages found matching: ipython3"
So I am not sure why Anaconda runs fine with python2 but not with python3--even though Continuum indicates it is python3 ready. Am I missing a step anywhere? Does anyone know how to solve this?
Did you remember to do "source activate py33dev"?