<center>
<a target=“_blank” href="https://www.datacamp.com/learn/python/"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583330891/python_2_wyjjwk.png" /></a>
</center> 
Typically, every novice learns to write a Python script on the command line first, then moves to execute the script from the command line wherein the script is usually written in a text editor and is run from the command line.
Computers cannot understand code in the way humans write it and hence, you need an interpreter between the computer and the human written code. The job of the interpreter is to convert the code into a format that computers can then understand and process.
The interpreter processes the code in the following ways:
<ul>
<li>Processes the Python script in a sequence
</li>
<li>Compiles the code into a byte code format which is a lower-level language understood by the computers.
</li>
<li>Finally, a Python Virtual Machine (PVM) comes into the picture. The PVM is the runtime powerhouse of Python. It is a process that iterates over the instructions of your low-level bytecode code to run them one by one.
</li>
</ul>
Like Scripts, you have a have something called Module which is a Python script imported and used in another Python script.
The Python script is saved with a .py extension which informs the computer that it is a Python program script. Unlike Windows, the Unix based operating systems such as Linux and Mac come with pre-installed Python. Also, the way Python scripts are run in Windows and Unix operating systems differ.
Note: For all users, especially Windows OS users, it is highly recommended that you install <code>Anaconda</code>, which can be downloaded from <a href="https://www.anaconda.com">this website</a>. You can follow along with the instructions given in this <a href="https://www.datacamp.com/community/tutorials/installing-anaconda-windows">DataCamp tutorial</a>, which are specific to Windows operating system.
To install <code>Python3</code> on a Windows operating system, please feel free to check out this <a href="https://www.digitalocean.com/community/tutorials/how-to-install-python-3-and-set-up-a-local-programming-environment-on-windows-10">link</a>.
Command-line interpreter for Python can be accessed on the various operating systems in the following ways:
<ul>
<li>On <code>Windows</code>, the command line is known as the command prompt which can be accessed by clicking the <code>start</code> menu and search for <code>command prompt</code>. Another way is by going to the <code>Run</code> dialog box type <code>cmd</code> and press enter (Start menu $-&gt;$ Run and type cmd). After which, if Python is installed in your C-drive then all you have to do is type C:\python36\python.exe, where python36 is the Python version (Note: This path may vary based on the directory at which Python is configured).</li>
</ul>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598150/cmd1_cmgszw.png" />
 <figcaption>(<a href="https://pythonfun.wordpress.com/2012/04/04/installing-pyserial-on-windows-7-with-python3-2/">Source</a>) </figcaption>
</figure>
</center> 

<ul>
<li>On a <code>Mac</code> system, it is very straight-forward. All you need to do is open <code>Launchpad</code> and search for <code>Terminal</code>, and in the terminal, type <code>Python</code> and boom, it will give you an output with the Python version.</li>
</ul>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598150/cmd2_jnyyar.png" />
</figure>
</center> 

<ul>
<li>Like the Mac system, accessing terminal on a <code>Linux</code> system is also very easy. Right click on the desktop and click <code>Terminal</code> and in terminal type <code>Python</code> and that&#39;s all!</li>
</ul>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598150/cmd3_rmhrog.png" />
 <figcaption>(<a href="https://mbientlab.com/tutorials/LPython3.html">Source</a>) </figcaption>
</figure>
</center> 

Note: In this tutorial, you will be learning using the Mac OS Terminal.
So without further ado, lets get started!
<h3 id="writing-the-python-script-in-terminal">Writing the Python Script in Terminal</h3>
Let&#39;s see how we can code and generate the output in the terminal itself. To accomplish this, first, you will type <code>python3</code>, which means you will be using Python3 version.
After which you can code typically as you would in a <a href="https://www.datacamp.com/community/tutorials/top-python-ides-for-2019">text editor or an IDE</a> (integrated development environment), though you will not be getting the functionalities in the terminal as you would get with an IDE.
You will start with the evergreen <code>Hello, World!</code> example and let&#39;s see how the output looks like in the terminal.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598151/cmd4_semikk.png" />
</figure>
</center> 

Isn&#39;t it nice how by just opening the terminal and typing Python3 you can code in Python? Let&#39;s try some more examples.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598151/cmd5_jolchp.png" />
</figure>
</center> 

One thing to notice in the above example is, without even typing the <code>print</code> statement you were able to get the output.
Let&#39;s complicate the code a bit and lets you use the <code>NumPy</code> (Numerical Python) library to create two arrays and apply a few mathematical operations on it. For a little background on numpy, it is a Python programming library which has the capability of dealing with large, multi-dimensional arrays and matrices, along with an extensive collection of high-level mathematical functions to operate on these arrays.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598151/cmd6_quakfq.png" />
</figure>
</center> 

You can observe from the above figure that using numpy; you were able to create, add, and multiply two numpy arrays within the terminal. One thing to note here is that the <code>multiply</code> function in numpy does an element-wise multiplication while <code>dot</code> function takes the dot product of two matrices. To accomplish the <code>np.dot</code> command, you need to make sure that the <code>columns</code> of the first matrix are equal to the <code>rows</code> of the second matrix and hence, the <code>value error</code>.
<h3 id="running-the-py-script-from-the-terminal">Running the <code>.py</code> script from the Terminal</h3>
Running the Python script from the terminal is very simple, instead of writing the Python script in the terminal all you need to do is use a text editor like vim, emacs or notepad++ and save it with a <code>.py</code> extension. Then, open the terminal and go to the directory where the code resides and run the script with a keyword <code>python</code> followed by the script name.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598151/cmd7_tsl72k.png">
</figure>
</center> 

To create the <code>terminal.py</code> file, use <code>vim</code> in the terminal with the program name as <code>vim terminal.py</code> and paste the below code in it. To save the code, press <code>esc</code> key followed by <code>wq!</code>. And finally, to run that script all you need to do is type <code>python3 terminal.py</code> and within less than a second you will see the output as shown above.
The following is the code which was used in the above <a href="http://cs231n.github.io/python-numpy-tutorial/">example</a>.
<pre><code class="lang-python">import numpy as np

x = np.array([[1,2],[3,4]], dtype=np.float64)
y = np.array([[5,6],[7,8]], dtype=np.float64)

# Elementwise sum; both produce the array
# [[ 6.0 8.0]
# [10.0 12.0]]
print(&quot;Output of adding x and y with a &#39;+&#39; operator:&quot;,x + y)
print(&quot;Output of adding x and y using &#39;numpy.add&#39;:&quot;,np.add(x, y))

# Elementwise difference; both produce the array
# [[-4.0 -4.0]
# [-4.0 -4.0]]
print(&quot;Output of subtracting x and y with a &#39;-&#39; operator:&quot;,x - y)
print(&quot;Output of subtracting x and y using &#39;numpy.subtract&#39;:&quot;,np.subtract(x, y))

# Elementwise product; both produce the array
# [[ 5.0 12.0]
# [21.0 32.0]]
print(&quot;Output of elementwise product of x and y with a &#39;*&#39; operator:&quot;,x * y)
print(&quot;Output of element wise product of x and y using &#39;numpy.multiply&#39;:&quot;,np.multiply(x, y))

# Elementwise division; both produce the array
# [[ 0.2 0.33333333]
# [ 0.42857143 0.5 ]]
print(&quot;Output of elementwise division x and y with a &#39;/&#39; operator:&quot;,x / y)
print(&quot;Output of elementwise division x and y using &#39;numpy.divide&#39;:&quot;,np.divide(x, y))

# Elementwise square root; produces the array
# [[ 1. 1.41421356]
# [ 1.73205081 2. ]]
print(&quot;Output of elementwise square root x using &#39;numpy.sqrt&#39;:&quot;,np.sqrt(x))
</code></pre>
<pre><code>Output of adding x and y with a &#39;+&#39; operator: [[ 6. 8.]
 [10. 12.]]
Output of adding x and y using &#39;numpy.add&#39;: [[ 6. 8.]
 [10. 12.]]
Output of subtracting x and y with a &#39;-&#39; operator: [[-4. -4.]
 [-4. -4.]]
Output of subtracting x and y using &#39;numpy.subtract&#39;: [[-4. -4.]
 [-4. -4.]]
Output of elementwise product of x and y with a &#39;*&#39; operator: [[ 5. 12.]
 [21. 32.]]
Output of element wise product of x and y using &#39;numpy.multiply&#39;: [[ 5. 12.]
 [21. 32.]]
Output of elementwise division x and y with a &#39;/&#39; operator: [[0.2 0.33333333]
 [0.42857143 0.5 ]]
Output of elementwise division x and y using &#39;numpy.divide&#39;: [[0.2 0.33333333]
 [0.42857143 0.5 ]]
Output of elementwise square root x using &#39;numpy.sqrt&#39;: [[1. 1.41421356]
 [1.73205081 2. ]]
</code></pre><h3 id="passing-command-line-arguments-to-python-script">Passing Command Line Arguments to Python Script</h3>
Command line arguments make life a lot easier, many times in production-ready code command line arguments are used. It makes the code output reproducibility efficient. For example, let&#39;s say your code has a lot of user inputs or files that are being read, then by using command line arguments you will not have to go into the code to do all of these changes in case you need to change the file name or a variable input.
To accomplish this, you will make use of the <code>sys</code> module, which is an in-built Python module. Within <code>sys</code>, you have <code>argv</code> which gives you the list of command-line arguments passed to the Python program. <code>sys.argv</code> reads the command line arguments as a list of items where the first item/element in that list can be accessed as <code>sys.argv[1]</code> while first argument, i.e., <code>sys.argv[0]</code> is always the name of the program as it was invoked.
Let&#39;s take a simple example and see how it works.
Note: The command line argument is read as a <code>string</code> by Python, so make sure to convert it as an <code>integer</code> in case you are dealing with numbers.
Much like the previous example, save the below lines of code in an editor as <code>command_line.py</code> and to run the code type <code>python3 command_line.py 10</code> where 10 is the command line argument.
<pre><code class="lang-python">import sys
num = sys.argv[1]
for i in range(int(num)):
 print (i)
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598152/cmd8_fpvufy.png" />
</figure>
</center> 

<h4 id="what-if-you-do-not-provide-any-command-line-argument-">What if you do not provide any command line argument?</h4>
You will get an error <code>list index out of range</code> which also reinforces that <code>sys.argv</code> reads as a list of items. To avoid such errors, you need <code>exceptional handling</code>, which is out of the scope for this tutorial.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598154/cmd9_ks7w3s.png" />
</figure>
</center> 

<h3 id="writing-the-output-of-python-script-to-a-file">Writing the Output of Python Script to a File</h3>
Finally, as a bonus lets see how you can save the output of the Python script in a <code>txt</code> file with using the <code>&gt;</code> key. Yes, one mere character, isn&#39;t that amazing?
You will first create a folder <code>cli</code> and move the <code>command_line.py</code> code in the <code>cli</code> folder. Then, you will check what all is there in that folder, to make sure there is no <code>txt</code> file already existing.
Then, you will type <code>python3 command_line.py 10 &gt; output.txt</code> and finally check the content of the <code>cli</code> folder. Now, you should be able to see the <code>output.txt</code> file.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598155/cmd10_l1zfq1.png" />
</figure>
</center> 

Let&#39;s open and see the content of the <code>output.txt</code> file.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1562598155/cmd11_bxv24q.png" />
</figure>
</center> 

Voila! From the above output, you can see that the <code>0-9</code> digits have now been written in a text file using just a <code>&gt;</code> sign.
<h1 id="conclusion">Conclusion</h1>
Congratulations on finishing the tutorial.
There is still a lot to be explored like <a href="https://www.datacamp.com/community/tutorials/gui-tkinter-python">GUI</a> based execution in Python, running Python scripts interactively, running scripts from a file manager or from an IDE. Specific to command line execution you might want to experiment on the Windows <code>command prompt</code> and see how it is different from a Unix based operating system.
Please feel free to ask any questions related to this tutorial in the comments section below.
If you are just getting started in Python and would like to learn more, take DataCamp&#39;s <a href="https://www.datacamp.com/courses/introduction-to-data-science-in-python">Introduction to Data Science in Python</a> course.

https://www.datacamp.com/community/tutorials/running-a-python-script

Learn how you can execute a Python script from the command line, and also how you can provide command line arguments to your script.

Learn how you can run a PYTHON script from the COMMAND-LINE, and also how you can provide command line ARGUMENTS to your script.

(Tutorial) How to Run Python Scripts

How to Run Python Scripts

https://www.datacamp.com/community/tutorials/categorical-data

Learn the common tricks to handle categorical data and preprocess it to build machine learning models!

Learn the common tricks to handle CATEGORICAL data, such as converting to numeric PANDAS or missing data and preprocess it to build MACHINE LEARNING models!

(Tutorial) Handling Categorical Data in Python

Handling Categorical Data in Python

<center>
<a target=“_blank” href="https://www.datacamp.com/learn/python/"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583330891/python_2_wyjjwk.png" /></a>
</center> 
You have probably heard of the nested functions in Python. If you know what that means then understanding inner/nested classes is nothing. We will explore some new things in the Inner or Nested classes here.
<h2 id="sections">Sections</h2>
&nbsp; 1. <a href="#IONC">Inner or Nested Classes</a>
&nbsp; 2. <a href="#WIC">Why Inner Classes</a>
&nbsp; 3. <a href="#CIC">Coding Inner Classes</a>
&nbsp; &nbsp; &nbsp; &nbsp; 3.1. <a href="#MIC">Multiple Inner Classes</a>
&nbsp; &nbsp; &nbsp; &nbsp; 3.2. <a href="#MLIC">Multilevel Inner Classes</a>
<a id="IONC"></a>
<h2 id="1-inner-or-nested-classes">1. Inner or Nested Classes</h2>
Inner or Nested Class is defined inside another class. See the structure of inner or nested classes.
<pre><code class="lang-python">## outer class
class Outer:

 ## inner class
 class Inner:
 pass

 ## multilevel inner class
 class InnerInner:
 pass

 ## another inner class
 class _Inner:
 pass

 ## ...

 pass
</code></pre>
<a id="WIC"></a>
<h2 id="2-why-inner-classes-">2. Why Inner Classes?</h2>
<ol>
<li>Grouping of two or more classes. Suppose you have two classes Car and Engine. Every Car needs an Engine. But, Engine won&#39;t be used without a Car. So, you make the Engine an inner class to the Car. It helps save code.
</li>
<li>Hiding code is another use of Nested classes. You can hide the Nested classes from the outside world.
</li>
<li>It&#39;s easy to understand the classes. Classes are closely related here. You don&#39;t have to search for the classes in the code. They are all together.
</li>
</ol>
Inner or Nested classes are not the most commonly used feature in Python. But, it can be a good feature to implement code. The code is straightforward to organize when you use the inner or nested classes.
<a id="CIC"></a>
<h2 id="3-coding-inner-class">3. Coding Inner Class</h2>
Implementing the inner or nested classes is not difficult. You can see the structure of the code <a href="#IONC">here</a>.
You can access the inner class in the outer class using the self keyword. So, you can quickly create an instance of the inner class and perform operations in the outer class as you see fit. You can&#39;t, however, access the outer class in an inner class. Let&#39;s see an example below.
<pre><code class="lang-python">class Outer:
 &quot;&quot;&quot;Outer Class&quot;&quot;&quot;

 def __init__(self):
 ## instantiating the &#39;Inner&#39; class
 self.inner = self.Inner()

 def reveal(self):
 ## calling the &#39;Inner&#39; class function display
 self.inner.inner_display(&quot;Calling Inner class function from Outer class&quot;)

 class Inner:
 &quot;&quot;&quot;Inner Class&quot;&quot;&quot;

 def inner_display(self, msg):
 print(msg)
</code></pre>
Now, you&#39;ll make the instance of the Outer class and call it&#39;s reveal() method to execute the Inner class method inner_display().
<pre><code class="lang-python">## creating an instance of the &#39;Outer&#39; class
outer = Outer()
## calling the &#39;reveal()&#39; method
outer.reveal()
</code></pre>
<pre><code>Calling Inner class function from Outer class
</code></pre>Let&#39;s see another way to access the inner class. This way is a little less efficient.
<pre><code class="lang-python">Outer().Inner().inner_display(&quot;Calling the Inner class method directly&quot;)
</code></pre>
<pre><code>Calling the Inner class method directly
</code></pre>What if you want to create an instance of the inner class outside the outer class? Can you do that? Yes, let&#39;s see how to make an instance of the inner class outside of the outer class.
<pre><code class="lang-python">outer = Outer()

## instantiating the inner class
inner = outer.Inner() ## inner = Outer().Inner() or inner = outer.inner
inner.inner_display(&quot;Just Print It!&quot;)
</code></pre>
<pre><code>Just Print It!
</code></pre><a id="MIC"></a>
<h3 id="3-1-multiple-inner-classes">3.1. Multiple Inner Classes</h3>
It is a class containing more than one inner class. You can have more than one inner class in a class. As we defined earlier, it&#39;s easy to implement multiple inner classes.
<pre><code class="lang-python">class Outer:
 &quot;&quot;&quot;Outer Class&quot;&quot;&quot;

 def __init__(self):
 ## Instantiating the &#39;Inner&#39; class
 self.inner = self.Inner()
 ## Instantiating the &#39;_Inner&#39; class
 self._inner = self._Inner()

 def show_classes(self):
 print(&quot;This is Outer class&quot;)
 print(inner)
 print(_inner)

 class Inner:
 &quot;&quot;&quot;First Inner Class&quot;&quot;&quot;

 def inner_display(self, msg):
 print(&quot;This is Inner class&quot;)
 print(msg)

 class _Inner:
 &quot;&quot;&quot;Second Inner Class&quot;&quot;&quot;

 def inner_display(self, msg):
 print(&quot;This is _Inner class&quot;)
 print(msg)

 ## ...
</code></pre>
Accessing the classes is the same as we did earlier. See the example for better understanding.
<pre><code class="lang-python">## instantiating the classes

## &#39;Outer&#39; class
outer = Outer()
## &#39;Inner&#39; class
inner = outer.Inner() ## inner = outer.inner or inner = Outer().Inner()
## &#39;_Inner&#39; class
_inner = outer._Inner() ## _inner = outer._outer or _inner = Outer()._Inner()

## calling the methods
outer.show_classes()

print()

## &#39;Inner&#39; class
inner.inner_display(&quot;Just Print It!&quot;)

print()

## &#39;_Inner&#39; class
_inner.inner_display(&quot;Just Show It!&quot;)
</code></pre>
<pre><code>This is Outer class
&lt;__main__.Outer.Inner object at 0x0000021B37962048&gt;
&lt;__main__.Outer._Inner object at 0x0000021B37962160&gt;

This is Inner class
Just Print It!

This is _Inner class
Just Show It!
</code></pre><a id="MLIC"></a>
<h2 id="3-2-multilevel-inner-classes">3.2. Multilevel Inner Classes</h2>
In multilevel inner classes, the inner class contains another class which inner classes to the previous one. You can see the structure of this hierarchy <a href="#IONC">here</a>:
<pre><code class="lang-python">class Outer:
 &quot;&quot;&quot;Outer Class&quot;&quot;&quot;

 def __init__(self):
 ## instantiating the &#39;Inner&#39; class
 self.inner = self.Inner()
 ## instantiating the multilevel &#39;InnerInner&#39; class
 self.innerinner = self.inner.InnerInner()

 def show_classes(self):
 print(&quot;This is Outer class&quot;)
 print(inner)

 ## inner class
 class Inner:
 &quot;&quot;&quot;First Inner Class&quot;&quot;&quot;

 def __init__(self):
 ## instantiating the &#39;InnerInner&#39; class
 self.innerinner = self.InnerInner()

 def show_classes(self):
 print(&quot;This is Inner class&quot;)
 print(self.innerinner)

 ## multilevel inner class
 class InnerInner:

 def inner_display(self, msg):
 print(&quot;This is multilevel InnerInner class&quot;)
 print(msg)

 def inner_display(self, msg):
 print(&quot;This is Inner class&quot;)
 print(msg)

 ## ...
</code></pre>
Let&#39;s see how to instantiate the multilevel inner class.
<pre><code class="lang-python">outer = Outer()

inner = outer.Inner()

## this is &#39;InnerInner&#39; class instance
innerinner = inner.InnerInner() ## innerinner = Outer().Inner().InnerInner()

## let&#39;s call its method inner_display
innerinner.inner_display(&quot;Just Print It!&quot;)
</code></pre>
<pre><code>This is multilevel InnerInner class
Just Print It!
</code></pre><h2 id="conclusion">Conclusion</h2>
I hope you now understand the concept of inner classes. It&#39;s now time for you to experiment with nested classes. Happy Coding :)
If you would like to learn more about classes, take DataCamp&#39;s <a href="https://www.datacamp.com/courses/object-oriented-programming-in-python">Object-Oriented Programming in Python</a> course.

https://www.datacamp.com/community/tutorials/inner-classes-python

In this basic Python tutorial, you'll learn about why and when you should use inner classes.

Learn why and when you should use PYTHON inner/nested CLASSES.

(Tutorial) Inner/Nested Classes in Python

Inner Classes in Python

https://www.datacamp.com/community/tutorials/feature-selection-python

Learn about the basics of feature selection and how to implement and investigate various feature selection techniques in Python.

Learn the basics of feature selection in PYTHON and how to implement and investigate various FEATURE SELECTION techniques.

(Tutorial) Feature Selection in Python

Beginner's Guide to Feature Selection in Python

https://www.datacamp.com/community/tutorials/functions-python-tutorial

A tutorial on functions in Python that covers how to write functions, how to call them, and more!

In this tutorial, you'll learn the DEFINITION of a function in PYTHON, how to CALL one, and the different TYPES of functions that exist.

(Tutorial) Python Functions

Python Functions Tutorial

https://www.datacamp.com/community/tutorials/principal-component-analysis-in-python

Learn about PCA and how it can be leveraged to extract information from the data without any supervision using two popular datasets: Breast Cancer and CIFAR-10.

Learn about PCA and how it can be leveraged to EXTRACT information from the DATA without any supervision using two popular SKLEARN module datasets.

(Tutorial) Principal Component Analysis (PCA) in Python

Principal Component Analysis (PCA) in Python

https://www.datacamp.com/community/tutorials/lstm-python-stock-market

Discover Long Short-Term Memory (LSTM) networks in Python and how you can use them to make stock market predictions!

Discover Long Short-Term Memory (LSTM) networks in PYTHON and how you can use them to make STOCK MARKET predictions!

(Tutorial) LSTM in Python: Stock Market Predictions

Stock Market Predictions with LSTM in Python

https://www.datacamp.com/community/tutorials/markov-chains-python-tutorial

Learn about Markov Chains, their properties, transition matrices, and implement one yourself in Python!

Learn about MARKOV CHAINS, their properties, transition MATRICES, and implement one yourself in PYTHON!

(Tutorial) Markov Chains in Python

Markov Chains in Python: Beginner Tutorial

https://www.datacamp.com/community/tutorials/probability-distributions-python

In this tutorial, you'll learn about commonly used probability distributions in machine learning literature.

Learn about commonly used PROBABILITY DISTRIBUTIONS in MACHINE LEARNING literature. Such as Uniform, Normal, Gamma, Exponential, and Poisson.

(Tutorial) Probability Distributions in Python

Probability Distributions in Python

<center>
<a target=“_blank” href="https://www.datacamp.com/learn/python/"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582839819/python_4_t5pp5t.png" /></a>
</center>
SVM offers very high accuracy compared to other classifiers such as logistic regression, and decision trees. It is known for its kernel trick to handle nonlinear input spaces. It is used in a variety of applications such as face detection, intrusion detection, classification of emails, news articles and web pages, classification of genes, and handwriting recognition.
In this tutorial, you will be using scikit-learn in Python. If you would like to learn more about this Python package, I recommend you take a look at our <a href="https://www.datacamp.com/courses/supervised-learning-with-scikit-learn">Supervised Learning with scikit-learn</a> course.
SVM is an exciting algorithm and the concepts are relatively simple. The classifier separates data points using a hyperplane with the largest amount of margin. That&#39;s why an SVM classifier is also known as a discriminative classifier. SVM finds an optimal hyperplane which helps in classifying new data points. 
In this tutorial, you are going to cover following topics:
<nav>
<ul>
<li><a href="#svm">Support Vector Machines</a></li>
<li><a href="#how">How does it work?</a></li>
<li><a href="#kernels">Kernels</a></li>
<li><a href="#building">Classifier building in Scikit-learn</a></li>
<li><a href="#tuning">Tuning Hyperparameters</a></li>
<li><a href="#prosandcons">Advantages and Disadvantages</a>
</nav>
<div id="scoped-content"><style type="text/css">:target:before { content:""; display:block; height:150px; margin:-150px 0 0; } h3 {font-weight:normal; margin-top:.5em} h4 { font-weight:lighter }
</style>

</li>
</ul>
<a id="svm"></a>
<h2 id="support-vector-machines">Support Vector Machines</h2>
Generally, Support Vector Machines is considered to be a classification approach, it but can be employed in both types of classification and regression problems. It can easily handle multiple continuous and categorical variables. SVM constructs a hyperplane in multidimensional space to separate different classes. SVM generates optimal hyperplane in an iterative manner, which is used to minimize an error. The core idea of SVM is to find a maximum marginal hyperplane(MMH) that best divides the dataset into classes.
<img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1526288453/index3_souoaz.png" alt="Support Vectors"/>
<h4 id="support-vectors">Support Vectors</h4>
Support vectors are the data points, which are closest to the hyperplane. These points will define the separating line better by calculating margins. These points are more relevant to the construction of the classifier.
<h4 id="hyperplane">Hyperplane</h4>
A hyperplane is a decision plane which separates between a set of objects having different class memberships.
<h4 id="margin">Margin</h4>
A margin is a gap between the two lines on the closest class points. This is calculated as the perpendicular distance from the line to support vectors or closest points. If the margin is larger in between the classes, then it is considered a good margin, a smaller margin is a bad margin.
<a id="how"></a>
<h2 id="how-does-svm-work-">How does SVM work?</h2>
The main objective is to segregate the given dataset in the best possible way. The distance between the either nearest points is known as the margin. The objective is to select a hyperplane with the maximum possible margin between support vectors in the given dataset. SVM searches for the maximum marginal hyperplane in the following steps:
<ol>
<li>Generate hyperplanes which segregates the classes in the best way. Left-hand side figure showing three hyperplanes black, blue and orange. Here, the blue and orange have higher classification error, but the black is separating the two classes correctly.
</li>
<li>Select the right hyperplane with the maximum segregation from the either nearest data points as shown in the right-hand side figure.
</li>
</ol>
<img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1526288454/index2_ub1uzd.png" alt="Linear Separator"/>
<h4 id="dealing-with-non-linear-and-inseparable-planes">Dealing with non-linear and inseparable planes</h4>
Some problems can’t be solved using linear hyperplane, as shown in the figure below (left-hand side).
In such situation, SVM uses a kernel trick to transform the input space to a higher dimensional space as shown on the right. The data points are plotted on the x-axis and z-axis (Z is the squared sum of both x and y: z=x^2=y^2). Now you can easily segregate these points using linear separation.
<img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1526288453/index_bnr4rx.png" alt="Higher Dimension"/>
<a id="kernels"></a>
<h2 id="svm-kernels">SVM Kernels</h2>
The SVM algorithm is implemented in practice using a kernel. A kernel transforms an input data space into the required form. SVM uses a technique called the kernel trick. Here, the kernel takes a low-dimensional input space and transforms it into a higher dimensional space. In other words, you can say that it converts nonseparable problem to separable problems by adding more dimension to it. It is most useful in non-linear separation problem. Kernel trick helps you to build a more accurate classifier.
<ul>
<li>Linear Kernel
A linear kernel can be used as normal dot product any two given observations. The product between two vectors is the sum of the multiplication of each pair of input values.</li>
</ul>
<pre><code>K(x, xi) = sum(x * xi)
</code></pre><ul>
<li>Polynomial Kernel
A polynomial kernel is a more generalized form of the linear kernel. The polynomial kernel can distinguish curved or nonlinear input space.</li>
</ul>
<pre><code>K(x,xi) = 1 + sum(x * xi)^d
</code></pre>Where d is the degree of the polynomial. d=1 is similar to the linear transformation. The degree needs to be manually specified in the learning algorithm.
<ul>
<li>Radial Basis Function Kernel
The Radial basis function kernel is a popular kernel function commonly used in support vector machine classification. RBF can map an input space in infinite dimensional space.</li>
</ul>
<pre><code>K(x,xi) = exp(-gamma * sum((x – xi^2))
</code></pre>Here gamma is a parameter, which ranges from 0 to 1. A higher value of gamma will perfectly fit the training dataset, which causes over-fitting. Gamma=0.1 is considered to be a good default value. The value of gamma needs to be manually specified in the learning algorithm.
<a id="building"></a>
<h2 id="classifier-building-in-scikit-learn">Classifier Building in Scikit-learn</h2>
Until now, you have learned about the theoretical background of SVM. Now you will learn about its implementation in Python using scikit-learn.
In the model the building part, you can use the cancer dataset, which is a very famous multi-class classification problem. This dataset is computed from a digitized image of a fine needle aspirate (FNA) of a breast mass. They describe characteristics of the cell nuclei present in the image.
The dataset comprises 30 features (mean radius, mean texture, mean perimeter, mean area, mean smoothness, mean compactness, mean concavity, mean concave points, mean symmetry, mean fractal dimension, radius error, texture error, perimeter error, area error, smoothness error, compactness error, concavity error, concave points error, symmetry error, fractal dimension error, worst radius, worst texture, worst perimeter, worst area, worst smoothness, worst compactness, worst concavity, worst concave points, worst symmetry, and worst fractal dimension) and a target (type of cancer).
This data has two types of cancer classes: malignant (harmful) and benign (not harmful). Here, you can build a model to classify the type of cancer. The dataset is available in the scikit-learn library or you can also download it from the UCI Machine Learning Library.
<h4 id="loading-data">Loading Data</h4>
Let&#39;s first load the required dataset you will use.
<pre><code class="lang-python">#Import scikit-learn dataset library
from sklearn import datasets

#Load dataset
cancer = datasets.load_breast_cancer()
</code></pre>
<h4 id="exploring-data">Exploring Data</h4>
After you have loaded the dataset, you might want to know a little bit more about it. You can check feature and target names. 
<pre><code class="lang-python"># print the names of the 13 features
print(&quot;Features: &quot;, cancer.feature_names)

# print the label type of cancer(&#39;malignant&#39; &#39;benign&#39;)
print(&quot;Labels: &quot;, cancer.target_names)
</code></pre>
<pre><code>Features: [&#39;mean radius&#39; &#39;mean texture&#39; &#39;mean perimeter&#39; &#39;mean area&#39;
 &#39;mean smoothness&#39; &#39;mean compactness&#39; &#39;mean concavity&#39;
 &#39;mean concave points&#39; &#39;mean symmetry&#39; &#39;mean fractal dimension&#39;
 &#39;radius error&#39; &#39;texture error&#39; &#39;perimeter error&#39; &#39;area error&#39;
 &#39;smoothness error&#39; &#39;compactness error&#39; &#39;concavity error&#39;
 &#39;concave points error&#39; &#39;symmetry error&#39; &#39;fractal dimension error&#39;
 &#39;worst radius&#39; &#39;worst texture&#39; &#39;worst perimeter&#39; &#39;worst area&#39;
 &#39;worst smoothness&#39; &#39;worst compactness&#39; &#39;worst concavity&#39;
 &#39;worst concave points&#39; &#39;worst symmetry&#39; &#39;worst fractal dimension&#39;]
Labels: [&#39;malignant&#39; &#39;benign&#39;]
</code></pre>Let&#39;s explore it for a bit more. You can also check the shape of the dataset using shape.
<pre><code class="lang-python"># print data(feature)shape
cancer.data.shape
</code></pre>
<pre><code>(569, 30)
</code></pre>Let&#39;s check top 5 records of the feature set.
<pre><code class="lang-python"># print the cancer data features (top 5 records)
print(cancer.data[0:5])
</code></pre>
<pre><code>[[1.799e+01 1.038e+01 1.228e+02 1.001e+03 1.184e-01 2.776e-01 3.001e-01
 1.471e-01 2.419e-01 7.871e-02 1.095e+00 9.053e-01 8.589e+00 1.534e+02
 6.399e-03 4.904e-02 5.373e-02 1.587e-02 3.003e-02 6.193e-03 2.538e+01
 1.733e+01 1.846e+02 2.019e+03 1.622e-01 6.656e-01 7.119e-01 2.654e-01
 4.601e-01 1.189e-01]
 [2.057e+01 1.777e+01 1.329e+02 1.326e+03 8.474e-02 7.864e-02 8.690e-02
 7.017e-02 1.812e-01 5.667e-02 5.435e-01 7.339e-01 3.398e+00 7.408e+01
 5.225e-03 1.308e-02 1.860e-02 1.340e-02 1.389e-02 3.532e-03 2.499e+01
 2.341e+01 1.588e+02 1.956e+03 1.238e-01 1.866e-01 2.416e-01 1.860e-01
 2.750e-01 8.902e-02]
 [1.969e+01 2.125e+01 1.300e+02 1.203e+03 1.096e-01 1.599e-01 1.974e-01
 1.279e-01 2.069e-01 5.999e-02 7.456e-01 7.869e-01 4.585e+00 9.403e+01
 6.150e-03 4.006e-02 3.832e-02 2.058e-02 2.250e-02 4.571e-03 2.357e+01
 2.553e+01 1.525e+02 1.709e+03 1.444e-01 4.245e-01 4.504e-01 2.430e-01
 3.613e-01 8.758e-02]
 [1.142e+01 2.038e+01 7.758e+01 3.861e+02 1.425e-01 2.839e-01 2.414e-01
 1.052e-01 2.597e-01 9.744e-02 4.956e-01 1.156e+00 3.445e+00 2.723e+01
 9.110e-03 7.458e-02 5.661e-02 1.867e-02 5.963e-02 9.208e-03 1.491e+01
 2.650e+01 9.887e+01 5.677e+02 2.098e-01 8.663e-01 6.869e-01 2.575e-01
 6.638e-01 1.730e-01]
 [2.029e+01 1.434e+01 1.351e+02 1.297e+03 1.003e-01 1.328e-01 1.980e-01
 1.043e-01 1.809e-01 5.883e-02 7.572e-01 7.813e-01 5.438e+00 9.444e+01
 1.149e-02 2.461e-02 5.688e-02 1.885e-02 1.756e-02 5.115e-03 2.254e+01
 1.667e+01 1.522e+02 1.575e+03 1.374e-01 2.050e-01 4.000e-01 1.625e-01
 2.364e-01 7.678e-02]]
</code></pre>Let&#39;s take a look at the target set.
<pre><code class="lang-python"># print the cancer labels (0:malignant, 1:benign)
print(cancer.target)
</code></pre>
<pre><code>[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 1 0 0 0 0 0 0 0 0 1 0 1 1 1 1 1 0 0 1 0 0 1 1 1 1 0 1 0 0 1 1 1 1 0 1 0 0
 1 0 1 0 0 1 1 1 0 0 1 0 0 0 1 1 1 0 1 1 0 0 1 1 1 0 0 1 1 1 1 0 1 1 0 1 1
 1 1 1 1 1 1 0 0 0 1 0 0 1 1 1 0 0 1 0 1 0 0 1 0 0 1 1 0 1 1 0 1 1 1 1 0 1
 1 1 1 1 1 1 1 1 0 1 1 1 1 0 0 1 0 1 1 0 0 1 1 0 0 1 1 1 1 0 1 1 0 0 0 1 0
 1 0 1 1 1 0 1 1 0 0 1 0 0 0 0 1 0 0 0 1 0 1 0 1 1 0 1 0 0 0 0 1 1 0 0 1 1
 1 0 1 1 1 1 1 0 0 1 1 0 1 1 0 0 1 0 1 1 1 1 0 1 1 1 1 1 0 1 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 0 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1
 1 0 1 1 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 0 1 1 1 1 0 0 0 1 1
 1 1 0 1 0 1 0 1 1 1 0 1 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 0
 0 1 0 0 1 1 1 1 1 0 1 1 1 1 1 0 1 1 1 0 1 1 0 0 1 1 1 1 1 1 0 1 1 1 1 1 1
 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1 0 1 1 1 1 1 0 1 1
 0 1 0 1 1 0 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 0 1
 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 0 0 1 0 1 0 1 1 1 1 1 0 1 1 0 1 0 1 0 0
 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 0 0 0 0 0 0 1]
</code></pre><h4 id="splitting-data">Splitting Data</h4>
To understand model performance, dividing the dataset into a training set and a test set is a good strategy.
Split the dataset by using the function <code>train_test_split()</code>. you need to pass 3 parameters features, target, and test_set size. Additionally, you can use random_state to select records randomly.
<pre><code class="lang-python"># Import train_test_split function
from sklearn.model_selection import train_test_split

# Split dataset into training set and test set
X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, test_size=0.3,random_state=109) # 70% training and 30% test
</code></pre>
<h4 id="generating-model">Generating Model</h4>
Let&#39;s build support vector machine model. First, import the SVM module and create support vector classifier object by passing argument kernel as the linear kernel in <code>SVC()</code> function.
Then, fit your model on train set using <code>fit()</code> and perform prediction on the test set using <code>predict()</code>.
<pre><code class="lang-python">#Import svm model
from sklearn import svm

#Create a svm Classifier
clf = svm.SVC(kernel=&#39;linear&#39;) # Linear Kernel

#Train the model using the training sets
clf.fit(X_train, y_train)

#Predict the response for test dataset
y_pred = clf.predict(X_test)
</code></pre>
<h4 id="evaluating-the-model">Evaluating the Model</h4>
Let&#39;s estimate how accurately the classifier or model can predict the breast cancer of patients.
Accuracy can be computed by comparing actual test set values and predicted values.
<pre><code class="lang-python">#Import scikit-learn metrics module for accuracy calculation
from sklearn import metrics

# Model Accuracy: how often is the classifier correct?
print(&quot;Accuracy:&quot;,metrics.accuracy_score(y_test, y_pred))
</code></pre>
<pre><code>Accuracy: 0.9649122807017544
</code></pre>Well, you got a classification rate of 96.49%, considered as very good accuracy.
For further evaluation, you can also check precision and recall of model.
<pre><code class="lang-python"># Model Precision: what percentage of positive tuples are labeled as such?
print(&quot;Precision:&quot;,metrics.precision_score(y_test, y_pred))

# Model Recall: what percentage of positive tuples are labelled as such?
print(&quot;Recall:&quot;,metrics.recall_score(y_test, y_pred))
</code></pre>
<pre><code>Precision: 0.9811320754716981
Recall: 0.9629629629629629
</code></pre>Well, you got a precision of 98% and recall of 96%, which are considered as very good values.
<a id="tuning"></a>
<h2 id="tuning-hyperparameters">Tuning Hyperparameters</h2>
<ul>
<li>Kernel: The main function of the kernel is to transform the given dataset input data into the required form. There are various types of functions such as linear, polynomial, and radial basis function (RBF). Polynomial and RBF are useful for non-linear hyperplane. Polynomial and RBF kernels compute the separation line in the higher dimension. In some of the applications, it is suggested to use a more complex kernel to separate the classes that are curved or nonlinear. This transformation can lead to more accurate classifiers.</li>
</ul>
<ul>
<li>Regularization: Regularization parameter in python&#39;s Scikit-learn C parameter used to maintain regularization. Here C is the penalty parameter, which represents misclassification or error term. The misclassification or error term tells the SVM optimization how much error is bearable. This is how you can control the trade-off between decision boundary and misclassification term. A smaller value of C creates a small-margin hyperplane and a larger value of C creates a larger-margin hyperplane.</li>
</ul>
<ul>
<li>Gamma: A lower value of Gamma will loosely fit the training dataset, whereas a higher value of gamma will exactly fit the training dataset, which causes over-fitting. In other words, you can say a low value of gamma considers only nearby points in calculating the separation line, while the a value of gamma considers all the data points in the calculation of the separation line.</li>
</ul>
<a id="prosandcons"></a>
<h2 id="advantages">Advantages</h2>
SVM Classifiers offer good accuracy and perform faster prediction compared to Naïve Bayes algorithm. They also use less memory because they use a subset of training points in the decision phase. SVM works well with a clear margin of separation and with high dimensional space. 
<h2 id="disadvantages">Disadvantages</h2>
SVM is not suitable for large datasets because of its high training time and it also takes more time in training compared to Naïve Bayes. It works poorly with overlapping classes and is also sensitive to the type of kernel used.
<h2 id="conclusion">Conclusion</h2>
Congratulations, you have made it to the end of this tutorial!
In this tutorial, you covered a lot of ground about Support vector machine algorithm, its working, kernels, hyperparameter tuning, model building and evaluation on breast cancer dataset using the Scikit-learn package. You have also covered its advantages and disadvantages. I hope you have learned something valuable!
To learn more about this type of classifiers, you should take a look at our <a href="https://www.datacamp.com/courses/linear-classifiers-in-python">Linear Classifiers in Python</a> course. It introduces other types of regression and loss functions, as well as Support Vector Machines.
I look forward to hearing any feedback or questions. You can ask the question by leaving a comment and I will try my best to answer it.

https://www.datacamp.com/community/tutorials/svm-classification-scikit-learn-python

In this tutorial, you'll learn about Support Vector Machines, one of the most popular and widely used supervised machine learning algorithms.

Learn about Support Vector Machines (SVM), one of the most POPULAR and widely used SUPERVISED MACHINE LEARNING algorithms.

(Tutorial) Support Vector Machines (SVM) in Scikit-learn

Support Vector Machines with Scikit-learn

Anaconda is a package manager, an environment manager, and Python distribution that contains a collection of many open source packages. This is advantageous as when you are working on a data science project, you will find that you need many different packages (numpy, scikit-learn, scipy, pandas to name a few), which an installation of Anaconda comes preinstalled with. If you need additional packages after installing Anaconda, you can use Anaconda&#39;s package manager, conda, or pip to install those packages. This is highly advantageous as you don&#39;t have to manage dependencies between multiple packages yourself. Conda even makes it easy to switch between Python 2 and 3 (you can learn more <a href="https://towardsdatascience.com/environment-management-with-conda-python-2-3-b9961a8a5097">here</a>). In fact, an installation of Anaconda is also the <a href="http://jupyter.org/install.html">recommended way to install Jupyter Notebooks</a> which you can learn more about <a href="https://www.datacamp.com/community/tutorials/tutorial-jupyter-notebook">here</a> on the DataCamp community.
This tutorial will include:
<nav>
<ul>
<li><a href="#install">How to Install Anaconda on Windows</a>
</li>
<li><a href="#test">How to test your installation and fix common installation issues</a>
</li>
<li><a href="#after">What to do after installing Anaconda.</a>
</nav>
<div id="scoped-content">
<style type="text/css">:target:before { content:""; display:block; height:150px; margin:-150px 0 0; } h3 {font-weight:normal; margin-top:.5em} h4 { font-weight:lighter }
</style>

</li>
</ul>
With that, let&#39;s get started!
<a id="install"></a>
<h2 id="download-and-install-anaconda">Download and Install Anaconda</h2>
&nbsp;1. Go to the <a href="https://www.anaconda.com/download/#windows">Anaconda Website</a> and choose a Python 3.x graphical installer (A) or a Python 2.x graphical installer (B). If you aren&#39;t sure which Python version you want to install, choose Python 3. Do not choose both.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528926570/1_anacondaWebsite_RED_lqqmky.png" />
&nbsp;2. Locate your download and double click it.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528926571/2_WaitTillDownloadDone_RED_rscmes.png" />
When the screen below appears, click on Next.
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528926579/3_OpeningScreen_RED_t9x3rr.png" />
&nbsp;3. Read the license agreement and click on I Agree.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528926834/4_SecondOpeningScreen_RED_u48y44.png" />
&nbsp;4. Click on Next.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528926866/justMeAfterI_Agree_RED_xb0fpf.png" />
&nbsp;5. Note your installation location and then click Next.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528926571/6_InstallationLocation_RED_hbx3zj.png" />
&nbsp;6. This is an important part of the installation process. The recommended approach is to not check the box to add Anaconda to your path. This means you will have to use Anaconda Navigator or the Anaconda Command Prompt (located in the Start Menu under &quot;Anaconda&quot;) when you wish to use Anaconda (you can always add Anaconda to your PATH later if you don&#39;t check the box). If you want to be able to use Anaconda in your command prompt (or git bash, <a href="http://cmder.net/">cmder</a>, powershell etc), please use the alternative approach and check the box.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528926970/AnacondaOptions_e8jugh.png" />
&nbsp;7. Click on Next.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528926583/8_Completed_RED_q2idx4.png" />
&nbsp;8. You can install Microsoft VSCode if you wish, but it is optional.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528926589/9_Completed_VisualStudio_RED_tjydls.png" />
&nbsp;9. Click on Finish.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528926585/10_finished_RED_ugje2b.png" />
<h2 id="add-anaconda-to-path-optional-">Add Anaconda to Path (Optional)</h2>
This is an optional step. This is for the case where you didn&#39;t check the box in step 6 and now want to add Anaconda to your Path. The advantage of this is that you will be able to use Anaconda in your Command Prompt, Git Bash, cmder etc.
&nbsp;1. Open a Command Prompt.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528927092/commandPrompt_laaopz.png" />
&nbsp;2. Check if you already have Anaconda added to your path. Enter the commands below into your Command Prompt. This is checking if you already have Anaconda added to your path. If you get a command not recognized error like in the left side of the image below, proceed to step 3. If you get an output similar to the right side of the image below, you have already added Anaconda to your path.
<pre><code>conda --version

python --version
</code></pre><center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528927121/anaconda_found_notfound_bunq4v.png" />
&nbsp;3. If you don&#39;t know where your conda and/or python is, open an Anaconda Prompt and type in the following commands. This is telling you where conda and python are located on your computer.
<pre><code>where conda
where python
</code></pre><center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528927155/anacondaPrompt_RED_gvxfea.png" />
&nbsp;4. Add conda and python to your PATH. You can do this by going to your Environment Variables and adding the output of step 3 (enclosed in the red rectangle) to your path. If you are having issues, here is a short <a href="https://youtu.be/mf5u2chPBjY?t=15m45s">video</a> on adding conda and python to your PATH.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528927222/environmentVariablesAddedToPATH_aee7yf.png" />
 <a id="test"></a>
&nbsp;5. Open a new Command Prompt. Try typing <code>conda --version</code> and <code>python --version</code> into the Command Prompt to check to see if everything went well.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1528927291/condaFoundDone_1_g3qnuj.png" />
<a id="after"></a>
<h2 id="conclusion">Conclusion</h2>
This tutorial provided a quick guide on how to install Anaconda on Windows as well as how to deal with a common installation issue. If you would like to learn more about Anaconda, you can learn more about it <a href="https://towardsdatascience.com/environment-management-with-conda-python-2-3-b9961a8a5097">here</a>. If you aren&#39;t sure what to do to start coding on your computer, I recommend you check out the the <a href="https://www.datacamp.com/community/tutorials/tutorial-jupyter-notebook">Jupyter Notebook Definitive Guide</a> to learn how to code using Jupyter Notebooks. If you want to learn about Python for Data Science, I suggest you check out the DataCamp course <a href="https://www.datacamp.com/courses/intro-to-python-for-data-science">Intro to Python for Data Science</a>. If you any questions or thoughts on the tutorial, feel free to reach out in the comments below or through <a href="https://twitter.com/GalarnykMichael">Twitter</a>.

https://www.datacamp.com/community/tutorials/installing-anaconda-windows

This tutorial will demonstrate how you can install Anaconda, a powerful package manager, on Microsoft Windows.

Learn how to download and install ANACONDA, a powerful package manager, on MICROSOFT WINDOWS.

(Tutorial) Installing ANACONDA on WINDOWS

Installing Anaconda on Windows

<center><a target=“_blank” href="https://www.datacamp.com/learn/r-programming/"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583330891/r_2_t6hgbx.png" /></a>
</center> 
Data mining or machine learning techniques can oftentimes be utilized at
early stages of biomedical research to analyze large datasets, for
example, to aid the identification of candidate genes or predictive
disease biomarkers in high-throughput sequencing datasets. However, data
from clinical trials usually include “survival data” that require a
quite different approach to analysis.
In this type of analysis, the time to a specific event, such as death or
disease recurrence, is of interest and two (or more) groups of patients
are compared with respect to this time. Three core concepts can be used
to derive meaningful results from such a dataset and the aim of this
tutorial is to introduce the statistical concepts, their interpretation,
as well as a real-world application of these methods along with their
implementation in R:
In this post, you&#39;ll tackle the following topics:
<nav>
<ul>
<li><a href="#second">The Statistics behind Survival Analysis</a><ul>
<li><a href="#third">Kaplan-Meier Method and Log-Rank Test</a></li>
<li><a href="#fourth">Cox Proportional Hazards Models</a></li>
</ul>
</li>
<li><a href="#fifth">Implementation of a Survival Analysis in R</a>
</nav>
<div id="scoped-content"><style type="text/css">:target:before { content:""; display:block; height:150px; margin:-150px 0 0; } h3 {font-weight:normal; margin-top:.5em} h4 { font-weight:lighter }
</style>

</li>
</ul>
In this tutorial, you are also going to use the <code>survival</code> and
<code>survminer</code> packages in R and the <code>ovarian</code> dataset (Edmunson J.H. et al., 1979) that comes with the <code>survival</code> package. You&#39;ll read more about this dataset later on in this tutorial!
Tip: check out <a href="https://www.rstudio.com/wp-content/uploads/2015/01/survminer-1.png">this <code>survminer</code> cheat sheet</a>
After this tutorial, you will be able to take advantage of these
data to answer questions such as the following: do patients benefit from
therapy regimen A as opposed to regimen B? Do patients’ age and fitness
significantly influence the outcome? Is residual disease a prognostic
biomarker in terms of survival?
<a id="second"></a>
<h2 id="survival-analysis-the-statistics">Survival Analysis: The Statistics</h2>
Before you go into detail with the statistics, you might want to learn
about some useful terminology:
The term &quot;censoring&quot; refers to incomplete data. Although different types
exist, you might want to restrict yourselves to right-censored data at
this point since this is the most common type of censoring in survival
datasets. 
For some patients, you might know that he or she was
followed-up on for a certain time without an “event” occurring, but you
might not know whether the patient ultimately survived or not. This can
be the case if the patient was either lost to follow-up or a subject
withdrew from the study. The data on this particular patient is going to
be “censored” after the last time point at which you know for sure that
your patient did not experience the “event” you are looking for. An
event is the pre-specified endpoint of your study, for instance death or
disease recurrence. Also, all patients who do not experience the “event”
until the study ends will be censored at that last time point.
Basically, these are the three reason why data could be censored.
Thus, the number of censored observations is always <code>n &gt;= 0</code>. All these
examples are instances of “right-censoring” and one can further classify
into either fixed or random type I censoring and type II censoring, but
these classifications are relevant mostly from the standpoint of
study-design and will not concern you in this introductory tutorial.
Something you should keep in mind is that all types of censoring are
cases of non-information and censoring is never caused by the “event”
that defines the endpoint of your study. That also implies that none of
the censored patients in the <code>ovarian</code> dataset were censored because the
respective patient died.
<a id="third"></a>
<h3 id="kaplan-meier-method-and-log-rank-test">Kaplan-Meier Method and Log Rank Test</h3>
Now, how does a survival function that describes patient survival over
time look like? 
The Kaplan-Meier estimator, independently described by
Edward Kaplan and Paul Meier and conjointly published in 1958 in the
Journal of the American Statistical Association, is a non-parametric
statistic that allows us to estimate the survival function.
Remember that a non-parametric statistic is not based on the
assumption of an underlying probability distribution, which makes sense
since survival data has a skewed distribution.
This statistic gives the probability that an individual patient will
survive past a particular time <code>t</code>. At <code>t = 0</code>, the Kaplan-Meier
estimator is <code>1</code> and with <code>t</code> going to infinity, the estimator goes to
<code>0</code>. In theory, with an infinitely large dataset and t measured to the
second, the corresponding function of <code>t</code> versus survival probability is
smooth. Later, you will see how it looks like in practice.
It is further based on the assumption that the probability of surviving
past a certain time point <code>t</code> is equal to the product of the observed
survival rates until time point <code>t</code>. More precisely,
<code>S(t) #the survival probability at time t</code> is given by
<code>S(t) = p.1 * p.2 * … * p.t</code> with <code>p.1</code> being the proportion of all
patients surviving past the first time point, <code>p.2</code> being the proportion
of patients surviving past the second time point, and so forth until
time point <code>t</code> is reached. 
It is important to notice that, starting with
<code>p.2</code> and up to <code>p.t</code>, you take only those patients into account who
survived past the previous time point when calculating the proportions
for every next time point; thus, <code>p.2</code>, <code>p.3</code>, <code>…</code>, <code>p.t</code> are
proportions that are conditional on the previous proportions.
In practice, you want to organize the survival times in order of
increasing duration first. This includes the censored values. You then
want to calculate the proportions as described above and sum them up to
derive <code>S(t)</code>. Censored patients are omitted after the time point of
censoring, so they do not influence the proportion of surviving
patients. For detailed information on the method, refer to (Swinscow and
Campbell, 2002). 
As a last note, you can use the log-rank test to
compare survival curves of two groups. The log-rank test is a
statistical hypothesis test that tests the null hypothesis that survival
curves of two populations do not differ. A certain probability
distribution, namely a chi-squared distribution, can be used to derive a
p-value. Briefly, p-values are used in statistical hypothesis testing to
quantify statistical significance. A result with <code>p &lt; 0.05</code> is usually
considered significant. In our case, <code>p &lt; 0.05</code> would indicate that the
two treatment groups are significantly different in terms of survival.
<a id="fourth"></a>
<h3 id="cox-proportional-hazards-models">Cox Proportional Hazards Models</h3>
Another useful function in the context of survival analyses is the
hazard function <code>h(t)</code>. It describes the probability of an event or its
hazard <code>h</code> (again, survival in this case) if the subject survived up to
that particular time point <code>t</code>. It is a bit more difficult to illustrate
than the Kaplan-Meier estimator because it measures the instantaneous
risk of death. Nevertheless, you need the hazard function to consider
covariates when you compare survival of patient groups. Covariates, also
called explanatory or independent variables in regression analysis, are
variables that are possibly predictive of an outcome or that you might
want to adjust for to account for interactions between variables.
Whereas the log-rank test compares two Kaplan-Meier survival curves,
which might be derived from splitting a patient population into
treatment subgroups, Cox proportional hazards models are derived from
the underlying baseline hazard functions of the patient populations in
question and an arbitrary number of dichotomized covariates. Again, it
does not assume an underlying probability distribution but it assumes
that the hazards of the patient groups you compare are constant over
time. That is why it is called “proportional hazards model”. Later, you
will see an example that illustrates these theoretical considerations.
Now, let’s try to analyze the <code>ovarian</code> dataset!
<a id="fifth"></a>
<h2 id="implementation-of-a-survival-analysis-in-r">Implementation of a Survival Analysis in R</h2>
With these concepts at hand, you can now start to analyze an actual
dataset and try to answer some of the questions above. Let’s start by
loading the two packages required for the analyses and the <code>dplyr</code>
package that comes with some useful functions for managing data frames.
<pre><code># Load required packages
library(survival)
library(survminer)
library(dplyr)
</code></pre>Tip: don&#39;t forget to use <code>install.packages()</code> to install any
packages that might still be missing in your workspace!
The next step is to load the dataset and examine its structure. As you read in the beginning of this tutorial, you&#39;ll work with the <code>ovarian</code> data set. This dataset comprises a cohort of ovarian cancer patients and respective clinical information, including the time patients were tracked until they either died or were lost to follow-up (<code>futime</code>), whether patients were censored or not (<code>fustat</code>), patient age, treatment group assignment, presence of residual disease and performance status. 
As you can already see, some of the variables’ names are a little cryptic, you might also want to consult the help page.
<pre><code># Import the ovarian cancer dataset and have a look at it
data(ovarian)
glimpse(ovarian)
## Observations: 26
## Variables: 6
## $ futime &lt;dbl&gt; 59, 115, 156, 421, 431, 448, 464, 475, 477, 563, 638,...
## $ fustat &lt;dbl&gt; 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0,...
## $ age &lt;dbl&gt; 72.3315, 74.4932, 66.4658, 53.3644, 50.3397, 56.4301,...
## $ resid.ds &lt;dbl&gt; 2, 2, 2, 2, 2, 1, 2, 2, 2, 1, 1, 1, 2, 2, 1, 1, 2, 1,...
## $ rx &lt;dbl&gt; 1, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 2, 2, 2, 1, 1, 1, 1,...
## $ ecog.ps &lt;dbl&gt; 1, 1, 2, 1, 1, 2, 2, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1,...
help(ovarian)
</code></pre>The <code>futime</code> column holds the survival times. This is the response
variable. <code>fustat</code>, on the other hand, tells you if an individual
patients’ survival time is censored. Apparently, the 26 patients in this
study received either one of two therapy regimens (<code>rx</code>) and the
attending physician assessed the regression of tumors (<code>resid.ds</code>) and
patients’ performance (according to the standardized ECOG criteria;
<code>ecog.ps</code>) at some point.
Furthermore, you get information on patients’ age and if you want to
include this as a predictive variable eventually, you have to
dichotomize continuous to binary values. But what cutoff should you
choose for that? Let us look at the overall distribution of age values:
<pre><code># Dichotomize age and change data labels
ovarian$rx &lt;- factor(ovarian$rx, 
 levels = c(&quot;1&quot;, &quot;2&quot;), 
 labels = c(&quot;A&quot;, &quot;B&quot;))
ovarian$resid.ds &lt;- factor(ovarian$resid.ds, 
 levels = c(&quot;1&quot;, &quot;2&quot;), 
 labels = c(&quot;no&quot;, &quot;yes&quot;))
ovarian$ecog.ps &lt;- factor(ovarian$ecog.ps, 
 levels = c(&quot;1&quot;, &quot;2&quot;), 
 labels = c(&quot;good&quot;, &quot;bad&quot;))

# Data seems to be bimodal
hist(ovarian$age) 
</code></pre><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1522843408/survival_lhlkdg.png"/>
<pre><code>ovarian &lt;- ovarian %&gt;% mutate(age_group = ifelse(age &gt;=50, &quot;old&quot;, &quot;young&quot;))
ovarian$age_group &lt;- factor(ovarian$age_group)
</code></pre>The obviously bi-modal distribution suggests a cutoff of 50 years. You
can use the <code>mutate</code> function to add an additional <code>age_group</code> column to
the data frame that will come in handy later on. Also, you should
convert the future covariates into factors.
Now, you are prepared to create a survival object. That is basically a
compiled version of the <code>futime</code> and <code>fustat</code> columns that can be
interpreted by the <code>survfit</code> function. A <code>+</code> behind survival times
indicates censored data points.
<pre><code># Fit survival data using the Kaplan-Meier method
surv_object &lt;- Surv(time = ovarian$futime, event = ovarian$fustat)
surv_object 
## [1] 59 115 156 421+ 431 448+ 464 475 477+ 563 638 
## [12] 744+ 769+ 770+ 803+ 855+ 1040+ 1106+ 1129+ 1206+ 1227+ 268 
## [23] 329 353 365 377+
</code></pre>The next step is to fit the Kaplan-Meier curves. You can easily do that
by passing the <code>surv_object</code> to the <code>survfit</code> function. You can also
stratify the curve depending on the treatment regimen <code>rx</code> that patients
were assigned to. A <code>summary()</code> of the resulting <code>fit1</code> object shows,
among other things, survival times, the proportion of surviving patients
at every time point, namely your <code>p.1</code>, <code>p.2</code>, <code>...</code> from above, and
treatment groups.
<pre><code>fit1 &lt;- survfit(surv_object ~ rx, data = ovarian)
summary(fit1)
## Call: survfit(formula = surv_object ~ rx, data = ovarian)
## 
## rx=A 
## time n.risk n.event survival std.err lower 95% CI upper 95% CI
## 59 13 1 0.923 0.0739 0.789 1.000
## 115 12 1 0.846 0.1001 0.671 1.000
## 156 11 1 0.769 0.1169 0.571 1.000
## 268 10 1 0.692 0.1280 0.482 0.995
## 329 9 1 0.615 0.1349 0.400 0.946
## 431 8 1 0.538 0.1383 0.326 0.891
## 638 5 1 0.431 0.1467 0.221 0.840
## 
## rx=B 
## time n.risk n.event survival std.err lower 95% CI upper 95% CI
## 353 13 1 0.923 0.0739 0.789 1.000
## 365 12 1 0.846 0.1001 0.671 1.000
## 464 9 1 0.752 0.1256 0.542 1.000
## 475 8 1 0.658 0.1407 0.433 1.000
## 563 7 1 0.564 0.1488 0.336 0.946
</code></pre>You can examine the corresponding survival curve by passing the survival
object to the <code>ggsurvplot</code> function. The <code>pval = TRUE</code> argument is very
useful, because it plots the p-value of a log rank test as well!
<pre><code>ggsurvplot(fit1, data = ovarian, pval = TRUE)
</code></pre><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1522843408/survival1_g30vej.png"/>
By convention, vertical lines indicate censored data, their
corresponding x values the time at which censoring occurred.
The log-rank p-value of 0.3 indicates a non-significant result if you
consider <code>p &lt; 0.05</code> to indicate statistical significance. In this study,
none of the treatments examined were significantly superior, although
patients receiving treatment B are doing better in the first month of
follow-up. What about the other variables?
<pre><code># Examine prdictive value of residual disease status
fit2 &lt;- survfit(surv_object ~ resid.ds, data = ovarian)
ggsurvplot(fit2, data = ovarian, pval = TRUE)
</code></pre><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1522843408/survival2_komvqh.png"/>
The Kaplan-Meier plots stratified according to residual disease status
look a bit different: The curves diverge early and the log-rank test is
almost significant. You might want to argue that a follow-up study with
an increased sample size could validate these results, that is, that
patients with positive residual disease status have a significantly
worse prognosis compared to patients without residual disease.
But is there a more systematic way to look at the different covariates?
As you might remember from one of the previous passages, Cox
proportional hazards models allow you to include covariates. You can
build Cox proportional hazards models using the <code>coxph</code> function and
visualize them using the <code>ggforest</code>. These type of plot is called a
forest plot. It shows so-called hazard ratios (HR) which are derived
from the model for all covariates that we included in the formula in
<code>coxph</code>. Briefly, an HR &gt; 1 indicates an increased risk of death
(according to the definition of <code>h(t)</code>) if a specific condition is met
by a patient. An HR &lt; 1, on the other hand, indicates a decreased
risk. Let&#39;s look at the output of the model:
<pre><code># Fit a Cox proportional hazards model
fit.coxph &lt;- coxph(surv_object ~ rx + resid.ds + age_group + ecog.ps, 
 data = ovarian)
ggforest(fit.coxph, data = ovarian)
</code></pre><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1522843408/survival3_t8aocz.png"/>
Every HR represents a relative risk of death that compares one instance
of a binary feature to the other instance. For example, a hazard ratio
of 0.25 for treatment groups tells you that patients who received
treatment B have a reduced risk of dying compared to patients who
received treatment A (which served as a reference to calculate the
hazard ratio). As shown by the forest plot, the respective 95%
confidence interval is 0.071 - 0.89 and this result is significant.
Using this model, you can see that the treatment group, residual disease
status, and age group variables significantly influence the patients&#39;
risk of death in this study. This is quite different from what you saw
with the Kaplan-Meier estimator and the log-rank test. Whereas the
former estimates the survival probability, the latter calculates the
risk of death and respective hazard ratios. Your analysis shows that the
results that these methods yield can differ in terms of significance.
<h2 id="conclusion">Conclusion</h2>
The examples above show how easy it is to implement the statistical
concepts of survival analysis in R. In this introduction, you have
learned how to build respective models, how to visualize them, and also
some of the statistical background information that helps to understand
the results of your analyses. Hopefully, you can now start to use these
techniques to analyze your own datasets. Thanks for reading this
tutorial!

https://www.datacamp.com/community/tutorials/survival-analysis-R

In this tutorial, you'll learn about the statistical concepts behind survival analysis and you'll implement a real-world application of these methods in R.

Learn about the STATISTICAL concepts behind SURVIVAL ANALYSIS and implement a real-world application of these METHODS in R.

(Tutorial) Survival ANALYSIS in R For BEGINNERS

Survival Analysis in R For Beginners

<center>
<a target=“_blank” href="https://www.datacamp.com/learn/python/"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583330891/python_3_qgciu1.png" /></a>
</center>
Classification techniques are an essential part of machine learning and data mining applications. Approximately 70% of problems in Data Science are classification problems. There are lots of classification problems that are available, but the logistics regression is common and is a useful regression method for solving the binary classification problem. Another category of classification is Multinomial classification, which handles the issues where multiple classes are present in the target variable. For example, IRIS dataset a very famous example of multi-class classification. Other examples are classifying article/blog/document category.
Logistic Regression can be used for various classification problems such as spam detection. Diabetes prediction, if a given customer will purchase a particular product or will they churn another competitor, whether the user will click on a given advertisement link or not, and many more examples are in the bucket.
Logistic Regression is one of the most simple and commonly used Machine Learning algorithms for two-class classification. It is easy to implement and can be used as the baseline for any binary classification problem. Its basic fundamental concepts are also constructive in deep learning. Logistic regression describes and estimates the relationship between one dependent binary variable and independent variables.
In this tutorial, you will learn the following things in Logistic Regression:
<ul>
<li>Introduction to Logistic Regression</li>
<li>Linear Regression Vs. Logistic Regression</li>
<li>Maximum Likelihood Estimation Vs. Ordinary Least Square Method</li>
<li>How do Logistic Regression works?</li>
<li>Model building in Scikit-learn</li>
<li>Model Evaluation using Confusion Matrix.</li>
<li>Advantages and Disadvantages of Logistic Regression</li>
</ul>
<h3 id="logistic-regression">Logistic Regression</h3>
Logistic regression is a statistical method for predicting binary classes. The outcome or target variable is dichotomous in nature. Dichotomous means there are only two possible classes. For example, it can be used for cancer detection problems. It computes the probability of an event occurrence.
It is a special case of linear regression where the target variable is categorical in nature. It uses a log of odds as the dependent variable. Logistic Regression predicts the probability of occurrence of a binary event utilizing a logit function.
Linear Regression Equation:
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281880/image1_ga8gze.png" />
Where, y is dependent variable and x1, x2 ... and Xn are explanatory variables.
Sigmoid Function:
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281880/image2_kwxquj.png" />
Apply Sigmoid function on linear regression:
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281880/image3_qldafx.png" />
Properties of Logistic Regression:
<ul>
<li>The dependent variable in logistic regression follows Bernoulli Distribution.</li>
<li>Estimation is done through maximum likelihood.</li>
<li>No R Square, Model fitness is calculated through Concordance, KS-Statistics.</li>
</ul>
<h3 id="linear-regression-vs-logistic-regression">Linear Regression Vs. Logistic Regression</h3>
Linear regression gives you a continuous output, but logistic regression provides a constant output. An example of the continuous output is house price and stock price. Example&#39;s of the discrete output is predicting whether a patient has cancer or not, predicting whether the customer will churn. Linear regression is estimated using Ordinary Least Squares (OLS) while logistic regression is estimated using Maximum Likelihood Estimation (MLE) approach.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281070/linear_vs_logistic_regression_edxw03.png" />
<h3 id="maximum-likelihood-estimation-vs-least-square-method">Maximum Likelihood Estimation Vs. Least Square Method</h3>
The MLE is a &quot;likelihood&quot; maximization method, while OLS is a distance-minimizing approximation method. Maximizing the likelihood function determines the parameters that are most likely to produce the observed data. From a statistical point of view, MLE sets the mean and variance as parameters in determining the specific parametric values for a given model. This set of parameters can be used for predicting the data needed in a normal distribution.
Ordinary Least squares estimates are computed by fitting a regression line on given data points that has the minimum sum of the squared deviations (least square error). Both are used to estimate the parameters of a linear regression model. MLE assumes a joint probability mass function, while OLS doesn&#39;t require any stochastic assumptions for minimizing distance.
<h3 id="sigmoid-function">Sigmoid Function</h3>
The sigmoid function, also called logistic function gives an ‘S’ shaped curve that can take any real-valued number and map it into a value between 0 and 1. If the curve goes to positive infinity, y predicted will become 1, and if the curve goes to negative infinity, y predicted will become 0. If the output of the sigmoid function is more than 0.5, we can classify the outcome as 1 or YES, and if it is less than 0.5, we can classify it as 0 or NO. The outputcannotFor example: If the output is 0.75, we can say in terms of probability as: There is a 75 percent chance that patient will suffer from cancer.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281880/image4_gw5mmv.png" />
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281070/sigmoid2_lv4c7i.png" />
<h3 id="types-of-logistic-regression">Types of Logistic Regression</h3>
Types of Logistic Regression:
<ul>
<li>Binary Logistic Regression: The target variable has only two possible outcomes such as Spam or Not Spam, Cancer or No Cancer.</li>
<li>Multinomial Logistic Regression: The target variable has three or more nominal categories such as predicting the type of Wine.</li>
<li>Ordinal Logistic Regression: the target variable has three or more ordinal categories such as restaurant or product rating from 1 to 5.</li>
</ul>
<h3 id="model-building-in-scikit-learn">Model building in Scikit-learn</h3>
Let&#39;s build the diabetes prediction model.
Here, you are going to predict diabetes using Logistic Regression Classifier.
Let&#39;s first load the required Pima Indian Diabetes dataset using the pandas&#39; read CSV function. You can download data from the following link: <a href="https://www.kaggle.com/uciml/pima-indians-diabetes-database">https://www.kaggle.com/uciml/pima-indians-diabetes-database</a>
<h4 id="loading-data">Loading Data</h4>
<pre><code class="lang-python">#import pandas
import pandas as pd
col_names = [&#39;pregnant&#39;, &#39;glucose&#39;, &#39;bp&#39;, &#39;skin&#39;, &#39;insulin&#39;, &#39;bmi&#39;, &#39;pedigree&#39;, &#39;age&#39;, &#39;label&#39;]
# load dataset
pima = pd.read_csv(&quot;pima-indians-diabetes.csv&quot;, header=None, names=col_names)
</code></pre>
<pre><code class="lang-python">pima.head()
</code></pre>
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281070/Screen_Shot_2018-08-14_at_5.06.08_PM_ykb1jt.png" />
<h4 id="selecting-feature">Selecting Feature</h4>
Here, you need to divide the given columns into two types of variables dependent(or target variable) and independent variable(or feature variables).
<pre><code class="lang-python">#split dataset in features and target variable
feature_cols = [&#39;pregnant&#39;, &#39;insulin&#39;, &#39;bmi&#39;, &#39;age&#39;,&#39;glucose&#39;,&#39;bp&#39;,&#39;pedigree&#39;]
X = pima[feature_cols] # Features
y = pima.label # Target variable
</code></pre>
<h4 id="splitting-data">Splitting Data</h4>
To understand model performance, dividing the dataset into a training set and a test set is a good strategy.
Let&#39;s split dataset by using function train_test_split(). You need to pass 3 parameters features, target, and test_set size. Additionally, you can use random_state to select records randomly.
<pre><code class="lang-python"># split X and y into training and testing sets
from sklearn.cross_validation import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.25,random_state=0)
</code></pre>
<pre><code>/home/admin/.local/lib/python3.5/site-packages/sklearn/cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also, note that the interface of the new CV iterators is different from that of this module. This module will be removed in 0.20.
 &quot;This module will be removed in 0.20.&quot;, DeprecationWarning)
</code></pre>Here, the Dataset is broken into two parts in a ratio of 75:25. It means 75% data will be used for model training and 25% for model testing.
<h4 id="model-development-and-prediction">Model Development and Prediction</h4>
First, import the Logistic Regression module and create a Logistic Regression classifier object using LogisticRegression() function.
Then, fit your model on the train set using fit() and perform prediction on the test set using predict().
<pre><code class="lang-python"># import the class
from sklearn.linear_model import LogisticRegression

# instantiate the model (using the default parameters)
logreg = LogisticRegression()

# fit the model with data
logreg.fit(X_train,y_train)

#
y_pred=logreg.predict(X_test)
</code></pre>
<h3 id="model-evaluation-using-confusion-matrix">Model Evaluation using Confusion Matrix</h3>
A confusion matrix is a table that is used to evaluate the performance of a classification model. You can also visualize the performance of an algorithm. The fundamental of a confusion matrix is the number of correct and incorrect predictions are summed up class-wise.
<pre><code class="lang-python"># import the metrics class
from sklearn import metrics
cnf_matrix = metrics.confusion_matrix(y_test, y_pred)
cnf_matrix
</code></pre>
<pre><code>array([[119, 11],
 [ 26, 36]])
</code></pre>Here, you can see the confusion matrix in the form of the array object. The dimension of this matrix is 2*2 because this model is binary classification. You have two classes 0 and 1. Diagonal values represent accurate predictions, while non-diagonal elements are inaccurate predictions. In the output, 119 and 36 are actual predictions, and 26 and 11 are incorrect predictions. 
<h4 id="visualizing-confusion-matrix-using-heatmap">Visualizing Confusion Matrix using Heatmap</h4>
Let&#39;s visualize the results of the model in the form of a confusion matrix using matplotlib and seaborn.
Here, you will visualize the confusion matrix using Heatmap.
<pre><code class="lang-python"># import required modules
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
</code></pre>
<pre><code class="lang-python">class_names=[0,1] # name of classes
fig, ax = plt.subplots()
tick_marks = np.arange(len(class_names))
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names)
# create heatmap
sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap=&quot;YlGnBu&quot; ,fmt=&#39;g&#39;)
ax.xaxis.set_label_position(&quot;top&quot;)
plt.tight_layout()
plt.title(&#39;Confusion matrix&#39;, y=1.1)
plt.ylabel(&#39;Actual label&#39;)
plt.xlabel(&#39;Predicted label&#39;)
</code></pre>
<pre><code>Text(0.5,257.44,&#39;Predicted label&#39;)
</code></pre><center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281070/output_46_1_y8ftmf.png" />
<h4 id="confusion-matrix-evaluation-metrics">Confusion Matrix Evaluation Metrics</h4>
Let&#39;s evaluate the model using model evaluation metrics such as accuracy, precision, and recall.
<pre><code class="lang-python">print(&quot;Accuracy:&quot;,metrics.accuracy_score(y_test, y_pred))
print(&quot;Precision:&quot;,metrics.precision_score(y_test, y_pred))
print(&quot;Recall:&quot;,metrics.recall_score(y_test, y_pred))
</code></pre>
<pre><code>Accuracy: 0.8072916666666666
Precision: 0.7659574468085106
Recall: 0.5806451612903226
</code></pre>Well, you got a classification rate of 80%, considered as good accuracy.
Precision: Precision is about being precise, i.e., how accurate your model is. In other words, you can say, when a model makes a prediction, how often it is correct. In your prediction case, when your Logistic Regression model predicted patients are going to suffer from diabetes, that patients have 76% of the time.
Recall: If there are patients who have diabetes in the test set and your Logistic Regression model can identify it 58% of the time.
<h4 id="roc-curve">ROC Curve</h4>
Receiver Operating Characteristic(ROC) curve is a plot of the true positive rate against the false positive rate. It shows the tradeoff between sensitivity and specificity.
<pre><code class="lang-python">y_pred_proba = logreg.predict_proba(X_test)[::,1]
fpr, tpr, _ = metrics.roc_curve(y_test, y_pred_proba)
auc = metrics.roc_auc_score(y_test, y_pred_proba)
plt.plot(fpr,tpr,label=&quot;data 1, auc=&quot;+str(auc))
plt.legend(loc=4)
plt.show()
</code></pre>
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281070/output_53_0_qqcjsm.png" />
AUC score for the case is 0.86. AUC score 1 represents perfect classifier, and 0.5 represents a worthless classifier.
<h3 id="advantages">Advantages</h3>
Because of its efficient and straightforward nature, doesn&#39;t require high computation power, easy to implement, easily interpretable, used widely by data analyst and scientist. Also, it doesn&#39;t require scaling of features. Logistic regression provides a probability score for observations.
<h3 id="disadvantages">Disadvantages</h3>
Logistic regression is not able to handle a large number of categorical features/variables. It is vulnerable to overfitting. Also, can&#39;t solve the non-linear problem with the logistic regression that is why it requires a transformation of non-linear features. Logistic regression will not perform well with independent variables that are not correlated to the target variable and are very similar or correlated to each other.
<h3 id="conclusion">Conclusion</h3>
In this tutorial, you covered a lot of details about Logistic Regression. You have learned what the logistic regression is, how to build respective models, how to visualize results and some of the theoretical background information. Also, you covered some basic concepts such as the sigmoid function, maximum likelihood, confusion matrix, ROC curve.
Hopefully, you can now utilize the Logistic Regression technique to analyze your own datasets. Thanks for reading this tutorial!
If you would like to learn more about Logistic Regression, take DataCamp&#39;s <a href="https://www.datacamp.com/courses/foundations-of-predictive-analytics-in-python-part-1">Foundations of Predictive Analytics in Python (Part 1)</a> course.

https://www.datacamp.com/community/tutorials/understanding-logistic-regression-python

Learn about Logistic Regression, its basic properties, and build a machine learning model on a real-world application in Python.

Learn about LOGISTIC REGRESSION, its basic properties, and build a MACHINE LEARNING model on a real-world application in PYTHON.

(Tutorial) Understanding Logistic REGRESSION in PYTHON

Understanding Logistic Regression in Python

https://www.datacamp.com/community/tutorials/text-analytics-beginners-nltk

Learn How to analyze text using NLTK. Analyze people's sentiments and classify movie reviews.

Analyze text using NLTK IN PYTHON. Learn how to ANALYZE people's sentiments and classify movie reviews.

(Tutorial) Text ANALYTICS for Beginners using NLTK

Text Analytics for Beginners using NLTK

https://www.datacamp.com/community/tutorials/matplotlib-tutorial-python

This Matplotlib tutorial takes you through the basics Python data visualization: the anatomy of a plot, pyplot and pylab, and much more

This MATPLOTLIB tutorial takes you through the basics of PYTHON data visualization: the anatomy of a PLOT, PYPLOT and PYLAB, and much more.

community

datacamp

Tutorials