{"id":24036,"date":"2018-08-09T03:30:52","date_gmt":"2018-08-09T03:30:52","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=24036"},"modified":"2026-04-27T17:45:42","modified_gmt":"2026-04-27T12:15:42","slug":"machine-learning-algorithms-in-python","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/","title":{"rendered":"8 Machine Learning Algorithms in Python – You Must Learn"},"content":{"rendered":"

Previously, we discussed the techniques\u00a0of machine learning with Python<\/strong><\/a>. Going deeper, today, we will learn and implement 8 top Machine Learning Algorithms in Python.<\/p>\n

Think of these 8 algorithms as the only toolkit for your data. Just like a carpenter knows exactly when to use a hammer or a saw, you\u2019re about to learn and teach our Python scripts, how to actually think, categorize, and forecast like a pro.<\/p>\n

Let\u2019s begin the journey of Machine Learning Algorithms in Python Programming.<\/p>\n

Machine Learning Algorithms in Python<\/h3>\n

The following are the Algorithms of Python Machine Learning:<\/strong><\/p>\n

a. Linear Regression in ML<\/h4>\n

Linear regression<\/a><\/strong> is one of the supervised Machine learning algorithms in Python that observes continuous features and predicts an outcome. Depending on whether it runs on a single variable or on many features, we can call it simple linear regression or multiple linear regression.<\/p>\n

This is one of the most popular Python ML algorithms and often under-appreciated. It assigns optimal weights to variables to create a line ax+b to predict the output. We often use linear regression to estimate real values like a number of calls and costs of houses based on continuous variables. The regression line\u00a0is the best line that fits Y=a*X+b to denote a relationship between independent and dependent variables.<\/p>\n

Do you know about Python Machine Learning Environment Setup<\/a><\/strong><\/p>\n

Let\u2019s plot this for the diabetes dataset.<\/p>\n

>>> import matplotlib.pyplot as plt\r\n>>> import numpy as np\r\n>>> from sklearn import datasets,linear_model\r\n>>> from sklearn.metrics import mean_squared_error,r2_score\r\n>>> diabetes=datasets.load_diabetes()\r\n>>> diabetes_X=diabetes.data[:,np.newaxis,2]\r\n>>> diabetes_X_train=diabetes_X[:-30] #splitting data into training and test sets\r\n>>> diabetes_X_test=diabetes_X[-30:]\r\n>>> diabetes_y_train=diabetes.target[:-30] #splitting targets into training and test sets\r\n>>> diabetes_y_test=diabetes.target[-30:]\r\n>>> regr=linear_model.LinearRegression() #Linear regression object\r\n>>> regr.fit(diabetes_X_train,diabetes_y_train) #Use training sets to train the model<\/pre>\n
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)<\/p>\n
>>> diabetes_y_pred=regr.predict(diabetes_X_test) #Make predictions\r\n>>> regr.coef_<\/pre>\n
array([941.43097333])<\/p>\n
>>> mean_squared_error(diabetes_y_test,diabetes_y_pred)<\/pre>\n
3035.0601152912695<\/p>\n
>>> r2_score(diabetes_y_test,diabetes_y_pred) #Variance score<\/pre>\n
0.410920728135835<\/p>\n
>>> plt.scatter(diabetes_X_test,diabetes_y_test,color ='lavender')<\/pre>\n
<matplotlib.collections.PathCollection object at 0x0584FF70><\/p>\n
>>> plt.plot(diabetes_X_test,diabetes_y_pred,color='pink',linewidth=3)<\/pre>\n
[<matplotlib.lines.Line2D object at 0x0584FF30>]<\/p>\n
>>> plt.xticks(())<\/pre>\n
([], <a list of 0 Text xticklabel objects>)<\/p>\n
>>> plt.yticks(())<\/pre>\n
([], <a list of 0 Text yticklabel objects>)<\/p>\n
>>> plt.show()<\/pre>\n
\"Machine<\/a>
Machine Learning Algorithms in Python – Linear Regression<\/p><\/div>\n
Python Machine Learning – Data Preprocessing, Analysis & Visualization<\/a><\/strong><\/p>\n
b. Logistic Regression in ML<\/h4>\n
Logistic regression is a supervised classification algorithm unique among Machine Learning algorithms in Python that finds its use in estimating discrete values like 0\/1, yes\/no, and true\/false. This is based on a given set of independent variables. We use a logistic function to predict the probability of an event, and this gives us an output between 0 and 1.<\/p>\n
Although it says \u2018regression\u2019, this is actually a classification algorithm. Logistic regression fits data into a logit function and is also called logit regression<\/i>. Let\u2019s plot this.<\/p>\n
>>> import numpy as np\r\n>>> import matplotlib.pyplot as plt\r\n>>> from sklearn import linear_model\r\n>>> xmin,xmax=-7,7 #Test set; straight line with Gaussian noise\r\n>>> n_samples=77\r\n>>> np.random.seed(0)\r\n>>> x=np.random.normal(size=n_samples)\r\n>>> y=(x>0).astype(np.float)\r\n>>> x[x>0]*=3\r\n>>> x+=.4*np.random.normal(size=n_samples)\r\n>>> x=x[:,np.newaxis]\r\n>>> clf=linear_model.LogisticRegression(C=1e4) #Classifier\r\n>>> clf.fit(x,y)\r\n>>> plt.figure(1,figsize=(3,4))\r\n<Figure size 300x400 with 0 Axes>\r\n>>> plt.clf()\r\n>>> plt.scatter(x.ravel(),y,color='lavender',zorder=17)<\/pre>\n
<matplotlib.collections.PathCollection object at 0x057B0E10><\/p>\n
>>> x_test=np.linspace(-7,7,277)\r\n>>> def model(x):\r\n         return 1\/(1+np.exp(-x))\r\n>>> loss=model(x_test*clf.coef_+clf.intercept_).ravel()\r\n>>> plt.plot(x_test,loss,color='pink',linewidth=2.5)<\/pre>\n
[<matplotlib.lines.Line2D object at 0x057BA090>]<\/p>\n
>>> ols=linear_model.LinearRegression()\r\n>>> ols.fit(x,y)<\/pre>\n
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)<\/p>\n
>>> plt.plot(x_test,ols.coef_*x_test+ols.intercept_,linewidth=1)<\/pre>\n
[<matplotlib.lines.Line2D object at 0x057BA0B0>]<\/p>\n
>>> plt.axhline(.4,color='.4')<\/pre>\n
<matplotlib.lines.Line2D object at 0x05860E70><\/p>\n
>>> plt.ylabel('y')<\/pre>\n
Text(0,0.5,’y’)<\/p>\n
>>> plt.xlabel('x')<\/pre>\n
Text(0.5,0,’x’)<\/p>\n
>>> plt.xticks(range(-7,7))\r\n>>> plt.yticks([0,0.4,1])\r\n>>> plt.ylim(-.25,1.25)<\/pre>\n
(-0.25, 1.25)<\/p>\n
>>> plt.xlim(-4,10)<\/pre>\n
(-4, 10)<\/p>\n
>>> plt.legend(('Logistic Regression','Linear Regression'),loc='lower right',fontsize='small')<\/pre>\n
<matplotlib.legend.Legend object at 0x057C89F0>
\nDo you know how to split the train and Test Set in Python Machine Learning<\/a><\/strong><\/p>\n
>>> plt.show()<\/pre>\n
\"Machine<\/a>
Machine Learning Algorithms in Python -Logistic<\/p><\/div>\n
c. Decision Tree in ML<\/h4>\n
A decision tree falls under supervised Machine Learning Algorithms in Python and comes in use for both classification and regression, although mostly for classification. This model takes an instance, traverses the tree, and compares important features with a determined conditional statement. Whether, it descends to the left child branch or the right depends on the result. Usually, more important features are closer to the root.<\/p>\n
Decision Tree, a machine learning algorithm in Python, can work on both categorical and continuous dependent variables. Here, we split a population into two or more homogeneous sets. Let\u2019s see the algorithm for this-<\/p>\n
>>> from sklearn.cross_validation import train_test_split\r\n>>> from sklearn.tree import DecisionTreeClassifier\r\n>>> from sklearn.metrics import accuracy_score\r\n>>> from sklearn.metrics import classification_report\r\n>>> def importdata(): #Importing data\r\n balance_data=pd.read_csv('https:\/\/archive.ics.uci.edu\/ml\/machine-learning-'+\r\n'databases\/balance-scale\/balance-scale.data',\r\n   sep= ',', header = None)\r\n          print(len(balance_data))\r\n          print(balance_data.shape)\r\n          print(balance_data.head())\r\n          return balance_data\r\n>>> def splitdataset(balance_data): #Splitting data\r\n          x=balance_data.values[:,1:5]\r\n          y=balance_data.values[:,0]\r\n          x_train,x_test,y_train,y_test=train_test_split(\r\n              x,y,test_size=0.3,random_state=100)\r\n          return x,y,x_train,x_test,y_train,y_test\r\n>>> def train_using_gini(x_train,x_test,y_train): #Training with giniIndex\r\n          clf_gini = DecisionTreeClassifier(criterion = \"gini\",\r\n          random_state = 100,max_depth=3, min_samples_leaf=5)\r\n          clf_gini.fit(x_train,y_train)\r\n          return clf_gini\r\n>>> def train_using_entropy(x_train,x_test,y_train): #Training with entropy\r\n          clf_entropy=DecisionTreeClassifier(\r\n          criterion = \"entropy\", random_state = 100,\r\n          max_depth = 3, min_samples_leaf = 5)\r\n          clf_entropy.fit(x_train,y_train)\r\n          return clf_entropy\r\n>>> def prediction(x_test,clf_object): #Making predictions\r\n          y_pred=clf_object.predict(x_test)\r\n          print(f\"Predicted values: {y_pred}\")\r\n          return y_pred\r\n>>> def cal_accuracy(y_test,y_pred): #Calculating accuracy\r\n          print(confusion_matrix(y_test,y_pred))\r\n          print(accuracy_score(y_test,y_pred)*100)\r\n          print(classification_report(y_test,y_pred))\r\n>>> data=importdata()<\/pre>\n
625
\n(625, 5)
\n0 1 2 3 4
\n0 B 1 1 1 1
\n1 R 1 1 1 2
\n2 R 1 1 1 3
\n3 R 1 1 1 4
\n4 R 1 1 1 5<\/p>\n
>>> x,y,x_train,x_test,y_train,y_test=splitdataset(data)\r\n>>> clf_gini=train_using_gini(x_train,x_test,y_train)\r\n>>> clf_entropy=train_using_entropy(x_train,x_test,y_train)\r\n>>> y_pred_gini=prediction(x_test,clf_gini)<\/pre>\n
\"Machine<\/a>
Machine Learning Algorithms in Python – Decision Tree<\/p><\/div>\n
>>> cal_accuracy(y_test,y_pred_gini)<\/pre>\n
[[ 0 6 7]
\n[ 0 67 18]
\n[ 0 19 71]]
\n73.40425531914893<\/p>\n
\"Machine<\/a>
Machine Learning Algorithms in Python – Decision Tree<\/p><\/div>\n
>>> y_pred_entropy=prediction(x_test,clf_entropy)<\/pre>\n
\"Machine<\/a>
Machine Learning Algorithms in Python – Decision Tree<\/p><\/div>\n
>>> cal_accuracy(y_test,y_pred_entropy)<\/pre>\n
[[ 0 6 7]
\n[ 0 63 22]
\n[ 0 20 70]]
\n70.74468085106383<\/p>\n
\"Machine<\/a>
Machine Learning Algorithms in Python – Decision Tree Algorithm i<\/p><\/div>\n
Let’s explore 4 Machine Learning Techniques with Python<\/a> <\/strong><\/p>\n
d. Support Vector Machines (SVM) in ML<\/h4>\n
SVM is a supervised classification algorithm that is one of the most important Machine Learning algorithms in Python, which plots a line that divides different categories of your data. However, in this ML algorithm, we calculate the vector to optimize the line.<\/p>\n
This is to ensure that the closest point in each group lies farthest from the others. While you will almost always find this to be a linear vector, it can be other than that.<\/p>\n
In this Python Machine Learning tutorial, we plot each data item as a point in an n-dimensional space. We have n features, and each feature has the value of a certain coordinate.<\/p>\n
First, let\u2019s plot a dataset.<\/p>\n
>>> from sklearn.datasets.samples_generator import make_blobs\r\n>>> x,y=make_blobs(n_samples=500,centers=2,\r\n           random_state=0,cluster_std=0.40)\r\n>>> import matplotlib.pyplot as plt\r\n>>> plt.scatter(x[:,0],x[:,1],c=y,s=50,cmap='plasma')<\/pre>\n
<matplotlib.collections.PathCollection object at 0x04E1BBF0><\/p>\n
>>> plt.show()<\/pre>\n
\"Machine<\/a>
Machine Learning Algorithms in Python – SVM<\/p><\/div>\n
>>> import numpy as np\r\n>>> xfit=np.linspace(-1,3.5)\r\n>>> plt.scatter(X[:, 0], X[:, 1], c=Y, s=50, cmap='plasma')<\/pre>\n
<matplotlib.collections.PathCollection object at 0x07318C90><\/p>\n
>>> for m, b, d in [(1, 0.65, 0.33), (0.5, 1.6, 0.55), (-0.2, 2.9, 0.2)]:\r\n        yfit = m * xfit + b\r\n        plt.plot(xfit, yfit, '-k')\r\n        plt.fill_between(xfit, yfit - d, yfit + d, edgecolor='none',\r\n        color='#AFFEDC', alpha=0.4)<\/pre>\n
[<matplotlib.lines.Line2D object at 0x07318FF0>]
\n<matplotlib.collections.PolyCollection object at 0x073242D0>
\n[<matplotlib.lines.Line2D object at 0x07318B70>]
\n<matplotlib.collections.PolyCollection object at 0x073246F0>
\n[<matplotlib.lines.Line2D object at 0x07324370>]
\n<matplotlib.collections.PolyCollection object at 0x07324B30><\/p>\n
>>> plt.xlim(-1,3.5)<\/pre>\n
(-1, 3.5)<\/p>\n
>>> plt.show()<\/pre>\n
\"Machine<\/a>
Machine Learning Algorithms in Python – Support Vector Machine<\/p><\/div>\n
Follow this link to know about Python PyQt5 Tutorial<\/a><\/strong><\/p>\n
e. Naive Bayes in ML<\/h4>\n
Naive Bayes is a classification method that is based on Bayes\u2019 theorem. This assumes independence between predictors. A Naive Bayes classifier will assume that a feature in a class is unrelated to any other. Consider a fruit. This is an apple if it is round, red, and 2.5 inches in diameter. In addition, a Naive Bayes classifier will say these characteristics independently contribute to the probability of the fruit being an apple. This is even if features depend on each other.<\/p>\n
Furthermore, for very large data sets, it is easy to build a Naive Bayesian model. Not only is this model very simple, but it also performs better than many highly sophisticated classification methods. Let\u2019s build this.<\/p>\n
>>> from sklearn.naive_bayes import GaussianNB\r\n>>> from sklearn.naive_bayes import MultinomialNB\r\n>>> from sklearn import datasets\r\n>>> from sklearn.metrics import confusion_matrix\r\n>>> from sklearn.model_selection import train_test_split\r\n>>> iris=datasets.load_iris()\r\n>>> x=iris.data\r\n>>> y=iris.target\r\n>>> x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.3,random_state=0)\r\n>>> gnb=GaussianNB()\r\n>>> mnb=MultinomialNB()\r\n>>> y_pred_gnb=gnb.fit(x_train,y_train).predict(x_test)\r\n>>> cnf_matrix_gnb = confusion_matrix(y_test, y_pred_gnb)\r\n>>> cnf_matrix_gnb<\/pre>\n
array([[16, 0, 0],
\n[ 0, 18, 0],
\n[ 0, 0, 11]], dtype=int64)<\/p>\n
>>> y_pred_mnb = mnb.fit(x_train, y_train).predict(x_test)\r\n>>> cnf_matrix_mnb = confusion_matrix(y_test, y_pred_mnb)\r\n>>> cnf_matrix_mnb<\/pre>\n
array([[16, 0, 0],
\n[ 0, 0, 18],
\n[ 0, 0, 11]], dtype=int64)<\/p>\n
f. kNN (k-Nearest Neighbors) in ML<\/h4>\n
This is a Python machine learning algorithm for classification and regression, mostly for classification. This is a supervised learning algorithm that considers different centroids and uses a Euclidean function to compare distances.<\/p>\n
Then, it analyzes the results and classifies each point into a group to optimize it to place with all the closest points to it. It classifies new cases using a majority vote of k of its neighbors. Hence, the case it assigns to a class is the one most common among its K nearest neighbors. For this, it uses a distance function.<\/p>\n
i. Training and testing on the entire dataset<\/strong><\/p>\n
>>> from sklearn.datasets import load_iris\r\n>>> iris=load_iris()\r\n>>> x=iris.data\r\n>>> y=iris.target\r\n>>> from sklearn.linear_model import LogisticRegression\r\n>>> logreg=LogisticRegression()\r\n>>> logreg.fit(x,y)<\/pre>\n
LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
\nintercept_scaling=1, max_iter=100, multi_class=’ovr’, n_jobs=1,
\npenalty=’l2′, random_state=None, solver=’liblinear’, tol=0.0001,
\nverbose=0, warm_start=False)<\/p>\n
>>> logreg.predict(x)<\/pre>\n
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
\n0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
\n0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\n2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1,
\n1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
\n2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2,
\n2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])<\/p>\n
>>> y_pred=logreg.predict(x)\r\n>>> len(y_pred)<\/pre>\n
150<\/p>\n
>>> from sklearn import metrics\r\n>>> metrics.accuracy_score(y,y_pred)<\/pre>\n
0.96<\/p>\n
>>> from sklearn.neighbors import KNeighborsClassifier\r\n>>> knn=KNeighborsClassifier(n_neighbors=5)\r\n>>> knn.fit(x,y)<\/pre>\n
KNeighborsClassifier(algorithm=’auto’, leaf_size=30, metric=’minkowski’,
\nmetric_params=None, n_jobs=1, n_neighbors=5, p=2,
\nweights=’uniform’)<\/p>\n
>>> y_pred=knn.predict(x)\r\n>>> metrics.accuracy_score(y,y_pred)<\/pre>\n
0.9666666666666667<\/p>\n
>>> knn=KNeighborsClassifier(n_neighbors=1)\r\n>>> knn.fit(x,y)<\/pre>\n
KNeighborsClassifier(algorithm=’auto’, leaf_size=30, metric=’minkowski’,
\nmetric_params=None, n_jobs=1, n_neighbors=1, p=2,
\nweights=’uniform’)<\/p>\n
>>> y_pred=knn.predict(x)\r\n>>> metrics.accuracy_score(y,y_pred)<\/pre>\n
1.0<\/p>\n
ii. Splitting into train\/test<\/strong><\/p>\n
>>> x.shape<\/pre>\n
(150, 4)<\/p>\n
>>> y.shape<\/pre>\n
(150,)<\/p>\n
>>> from sklearn.cross_validation import train_test_split\r\n>>> x.shape<\/pre>\n
(150, 4)<\/p>\n
>>> y.shape<\/pre>\n
(150,)<\/p>\n
>>> from sklearn.cross_validation import train_test_split\r\n>>> x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.4,random_state=4)\r\n>>> x_train.shape<\/pre>\n
(90, 4)<\/p>\n
>>> x_test.shape\r\n<\/pre>\n
(60, 4)<\/p>\n
>>> y_train.shape<\/pre>\n
(90,)<\/p>\n
>>> y_test.shape<\/pre>\n
(60,)<\/p>\n
>>> logreg=LogisticRegression()\r\n>>> logreg.fit(x_train,y_train)\r\n>>> y_pred=knn.predict(x_test)\r\n>>> metrics.accuracy_score(y_test,y_pred)<\/pre>\n
0.9666666666666667<\/p>\n
>>> knn=KNeighborsClassifier(n_neighbors=5)\r\n>>> knn.fit(x_train,y_train)<\/pre>\n
KNeighborsClassifier(algorithm=’auto’, leaf_size=30, metric=’minkowski’,
\nmetric_params=None, n_jobs=1, n_neighbors=5, p=2,
\nweights=’uniform’)<\/p>\n
>>> y_pred=knn.predict(x_test)\r\n>>> metrics.accuracy_score(y_test,y_pred)<\/pre>\n
0.9666666666666667<\/p>\n
>>> k_range=range(1,26)\r\n>>> scores=[]\r\n>>> for k in k_range:\r\n         knn = KNeighborsClassifier(n_neighbors=k)\r\n         knn.fit(x_train, y_train)\r\n         y_pred = knn.predict(x_test)\r\n         scores.append(metrics.accuracy_score(y_test, y_pred))\r\n>>> scores<\/pre>\n
[0.95, 0.95, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9833333333333333, 0.9833333333333333, 0.9833333333333333, 0.9833333333333333, 0.9833333333333333, 0.9833333333333333, 0.9833333333333333, 0.9833333333333333, 0.9833333333333333, 0.9833333333333333, 0.9833333333333333, 0.9833333333333333, 0.9666666666666667, 0.9833333333333333, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.95, 0.95]<\/p>\n
>>> import matplotlib.pyplot as plt\r\n>>> plt.plot(k_range,scores)<\/pre>\n
[<matplotlib.lines.Line2D object at 0x05FDECD0>]<\/p>\n
>>> plt.xlabel('k for kNN')<\/pre>\n
Text(0.5,0,’k for kNN’)<\/p>\n
>>> plt.ylabel('Testing Accuracy')<\/pre>\n
Text(0,0.5,’Testing Accuracy’)<\/p>\n
>>> plt.show()<\/pre>\n
\"Machine<\/a>
Machine Learning Algorithms in Python –\u00a0k-Nearest Neighbors<\/p><\/div>\n
Read about Python Statistics – p-Value, Correlation, T-test, KS Test<\/a><\/strong><\/p>\n
g. k-Means in ML<\/h4>\n
k-Means is an unsupervised algorithm that solves the problem of clustering. It classifies data using several clusters. The data points inside a class are homogeneous and heterogeneous to peer groups.<\/p>\n
>>> import numpy as np\r\n>>> import matplotlib.pyplot as plt\r\n>>> from matplotlib import style\r\n>>> style.use('ggplot')\r\n>>> from sklearn.cluster import KMeans\r\n>>> x=[1,5,1.5,8,1,9]\r\n>>> y=[2,8,1.7,6,0.2,12]\r\n>>> plt.scatter(x,y)<\/pre>\n
<matplotlib.collections.PathCollection object at 0x0642AF30><\/p>\n
>>> x=np.array([[1,2],[5,8],[1.5,1.8],[8,8],[1,0.6],[9,11]])\r\n>>> kmeans=KMeans(n_clusters=2)\r\n>>> kmeans.fit(x)<\/pre>\n
KMeans(algorithm=’auto’, copy_x=True, init=’k-means++’, max_iter=300,
\nn_clusters=2, n_init=10, n_jobs=1, precompute_distances=’auto’,
\nrandom_state=None, tol=0.0001, verbose=0)<\/p>\n
>>> centroids=kmeans.cluster_centers_\r\n>>> labels=kmeans.labels_\r\n>>> centroids<\/pre>\n
array([[1.16666667, 1.46666667],
\n[7.33333333, 9. ]])<\/p>\n
>>> labels<\/pre>\n
array([0, 1, 0, 1, 0, 1])<\/p>\n
>>> colors=['g.','r.','c.','y.']\r\n>>> for i in range(len(x)):\r\n         print(x[i],labels[i])\r\n         plt.plot(x[i][0],x[i][1],colors[labels[i]],markersize=10)<\/pre>\n
[1. 2.] 0
\n[<matplotlib.lines.Line2D object at 0x0642AE10>]
\n[5. 8.] 1
\n[<matplotlib.lines.Line2D object at 0x06438930>]
\n[1.5 1.8] 0
\n[<matplotlib.lines.Line2D object at 0x06438BF0>]
\n[8. 8.] 1
\n[<matplotlib.lines.Line2D object at 0x06438EB0>]
\n[1. 0.6] 0
\n[<matplotlib.lines.Line2D object at 0x06438FB0>]
\n[ 9. 11.] 1
\n[<matplotlib.lines.Line2D object at 0x043B1410>]<\/p>\n
>>> plt.scatter(centroids[:,0],centroids[:,1],marker='x',s=150,linewidths=5,zorder=10)<\/pre>\n
<matplotlib.collections.PathCollection object at 0x043B14D0><\/p>\n
>>> plt.show()<\/pre>\n
\"Machine<\/a>
Machine Learning Algorithms in Python – K-Means<\/p><\/div>\n
Have a Look at Python Descriptive Statistics \u2013 Measuring Central Tendency<\/a><\/strong><\/p>\n
h. Random Forest in ML<\/h4>\n
A random forest is an ensemble of decision trees. Now, to classify every new object based on its attributes, trees vote for a class- each tree provides a classification. The classification with the most votes wins in the forest.<\/p>\n
>>> import numpy as np\r\n>>> import pylab as pl\r\n>>> x=np.random.uniform(1,100,1000)\r\n>>> y=np.log(x)+np.random.normal(0,.3,1000)\r\n>>> pl.scatter(x,y,s=1,label='log(x) with noise')<\/pre>\n
<matplotlib.collections.PathCollection object at 0x0434EC50><\/p>\n
>>> pl.plot(np.arange(1,100),np.log(np.arange(1,100)),c='b',label='log(x) true function')<\/pre>\n
[<matplotlib.lines.Line2D object at 0x0434EB30>]<\/p>\n
>>> pl.xlabel('x')<\/pre>\n
Text(0.5,0,’x’)<\/p>\n
>>> pl.ylabel('f(x)=log(x)')<\/pre>\n
Text(0,0.5,’f(x)=log(x)’)<\/p>\n
>>> pl.legend(loc='best')<\/pre>\n
<matplotlib.legend.Legend object at 0x04386450><\/p>\n
>>> pl.title('A basic log function')\u00a0\r\n<\/pre>\n
Text(0.5,1,’A basic log function’)<\/p>\n
>>> pl.show()<\/pre>\n
\"Machine<\/a>
Machine Learning Algorithms in Python – Random Forest<\/p><\/div>\n
>>> from sklearn.datasets import load_iris\r\n>>> from sklearn.ensemble import RandomForestClassifier\r\n>>> import pandas as pd\r\n>>> import numpy as np\r\n>>> iris=load_iris()\r\n>>> df=pd.DataFrame(iris.data,columns=iris.feature_names)\r\n>>> df['is_train']=np.random.uniform(0,1,len(df))<=.75\r\n>>> df['species']=pd.Categorical.from_codes(iris.target,iris.target_names)\r\n>>> df.head()<\/pre>\n
sepal length (cm) sepal width (cm) … is_train species
\n0\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a05.1\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 3.5 …\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 True setosa
\n1\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a04.9\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 3.0 …\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 True setosa
\n2\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a04.7\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 3.2 …\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 True setosa
\n3\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a04.6\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 3.1 …\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 True setosa
\n4\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a05.0\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 3.6 …\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0False setosa
\n[5 rows x 6 columns]<\/p>\n
>>> train,test=df[df['is_train']==True],df[df['is_train']==False]\r\n>>> features=df.columns[:4]\r\n>>> clf=RandomForestClassifier(n_jobs=2)\r\n>>> y,_=pd.factorize(train['species'])\r\n>>> clf.fit(train[features],y)<\/pre>\n
RandomForestClassifier(bootstrap=True, class_weight=None, criterion=’gini’,
\nmax_depth=None, max_features=’auto’, max_leaf_nodes=None,
\nmin_impurity_decrease=0.0, min_impurity_split=None,
\nmin_samples_leaf=1, min_samples_split=2,
\nmin_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=2,
\noob_score=False, random_state=None, verbose=0,
\nwarm_start=False)<\/p>\n
>>> preds=iris.target_names[clf.predict(test[features])]\r\n>>> pd.crosstab(test['species'],preds,rownames=['actual'],colnames=['preds'])<\/pre>\n
preds\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 setosa\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 versicolor\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0virginica<\/strong>
\nactual
\nsetosa\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 12\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 0\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a00
\nversicolor\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a00\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 17\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a02
\nvirginica\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a00\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a01\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 15<\/p>\n
Other important techniques in AI are deep learning, which includes convolutional neural networks (CNNs) and recurrent neural networks (RNNs).<\/p>\n
These algorithms make up some of the modern preferences that include image and speech recognition, natural language processing, and others. Still, the conventional methods of machine learning, like the ones discussed here, are basic, and deep learning methods have added possibilities and are used in the contemporary methodologies of machine learning and AI.<\/p>\n
So, this was all about Machine Learning Algorithms in Python Tutorial. Hope you like our explanation.<\/p>\n
Conclusion<\/h3>\n
Python has many ready-to-use machine learning algorithms. These are like recipes for solving problems. Some popular ones are Linear Regression, Decision Tree, Random Forest, Support Vector Machine (SVM), K-Nearest Neighbors (KNN), and Naive Bayes. Each algorithm works in a different way and fits different types of problems.<\/p>\n
For example, Linear Regression is good for predicting numbers, like sales or prices. Decision Trees are easy to understand and great for yes\/no problems. Random Forest is a powerful version of decision trees that reduces errors.<\/p>\n
As a result, SVM is strong when there is a clear gap between classes. KNN is simple and works by comparing new data to old data. Naive Bayes is often used for spam detection or sentiment analysis.<\/p>\n","protected":false},"excerpt":{"rendered":"
Previously, we discussed the techniques\u00a0of machine learning with Python. Going deeper, today, we will learn and implement 8 top Machine Learning Algorithms in Python. Think of these 8 algorithms as the only toolkit for...<\/p>\n","protected":false},"author":5,"featured_media":24053,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[36,46],"tags":[3626,7839,8041,8287,8388,8994,10670,11304,13987],"class_list":["post-24036","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-machine-learning","category-python","tag-decision-tree","tag-k-means","tag-knn-k-nearest-neighbors","tag-linear-regression","tag-logistic-regression","tag-naive-bayes","tag-python-machine-learning-algorithm","tag-random-forest","tag-support-vector-machines-svm"],"yoast_head":"\n8 Machine Learning Algorithms in Python - You Must Learn - DataFlair<\/title>\n<meta name=\"description\" content=\"Machine Learning Algorithms in Python - Linear regression,Logistic Regression,Decision Tree, Support Vector Machines,Naive Bayes, kNN,k-Means, Random Forest\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"8 Machine Learning Algorithms in Python - You Must Learn - DataFlair\" \/>\n<meta property=\"og:description\" content=\"Machine Learning Algorithms in Python - Linear regression,Logistic Regression,Decision Tree, Support Vector Machines,Naive Bayes, kNN,k-Means, Random Forest\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/\" \/>\n<meta property=\"og:site_name\" content=\"DataFlair\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/DataFlairWS\/\" \/>\n<meta property=\"article:published_time\" content=\"2018-08-09T03:30:52+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-04-27T12:15:42+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/08\/8-Machine-Learning-Algorithms-to-Learn-01-1.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"DataFlair Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:site\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"DataFlair Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"10 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"8 Machine Learning Algorithms in Python - You Must Learn - DataFlair","description":"Machine Learning Algorithms in Python - Linear regression,Logistic Regression,Decision Tree, Support Vector Machines,Naive Bayes, kNN,k-Means, Random Forest","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/","og_locale":"en_US","og_type":"article","og_title":"8 Machine Learning Algorithms in Python - You Must Learn - DataFlair","og_description":"Machine Learning Algorithms in Python - Linear regression,Logistic Regression,Decision Tree, Support Vector Machines,Naive Bayes, kNN,k-Means, Random Forest","og_url":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2018-08-09T03:30:52+00:00","article_modified_time":"2026-04-27T12:15:42+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/08\/8-Machine-Learning-Algorithms-to-Learn-01-1.jpg","type":"image\/jpeg"}],"author":"DataFlair Team","twitter_card":"summary_large_image","twitter_creator":"@DataFlairWS","twitter_site":"@DataFlairWS","twitter_misc":{"Written by":"DataFlair Team","Est. reading time":"10 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/"},"author":{"name":"DataFlair Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/7f83c342f5d1632d6f7b4b0b0f447823"},"headline":"8 Machine Learning Algorithms in Python – You Must Learn","datePublished":"2018-08-09T03:30:52+00:00","dateModified":"2026-04-27T12:15:42+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/"},"wordCount":1832,"commentCount":3,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/08\/8-Machine-Learning-Algorithms-to-Learn-01-1.jpg","keywords":["Decision Tree","k-Means","kNN (k-Nearest Neighbors)","Linear Regression","Logistic Regression","Naive Bayes","Python Machine learning algorithm","Random Forest","Support Vector Machines (SVM)"],"articleSection":["Machine Learning Tutorials","Python Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/","url":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/","name":"8 Machine Learning Algorithms in Python - You Must Learn - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/08\/8-Machine-Learning-Algorithms-to-Learn-01-1.jpg","datePublished":"2018-08-09T03:30:52+00:00","dateModified":"2026-04-27T12:15:42+00:00","description":"Machine Learning Algorithms in Python - Linear regression,Logistic Regression,Decision Tree, Support Vector Machines,Naive Bayes, kNN,k-Means, Random Forest","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/08\/8-Machine-Learning-Algorithms-to-Learn-01-1.jpg","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/08\/8-Machine-Learning-Algorithms-to-Learn-01-1.jpg","width":1200,"height":628,"caption":"8 Python Machine Learning Algorithms - You Must LEARN"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/machine-learning-algorithms-in-python\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog Home","item":"https:\/\/data-flair.training\/blogs\/"},{"@type":"ListItem","position":2,"name":"Machine Learning Tutorials","item":"https:\/\/data-flair.training\/blogs\/category\/machine-learning\/"},{"@type":"ListItem","position":3,"name":"8 Machine Learning Algorithms in Python – You Must Learn"}]},{"@type":"WebSite","@id":"https:\/\/data-flair.training\/blogs\/#website","url":"https:\/\/data-flair.training\/blogs\/","name":"DataFlair","description":"Learn Today. Lead Tomorrow.","publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/data-flair.training\/blogs\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/data-flair.training\/blogs\/#organization","name":"DataFlair","url":"https:\/\/data-flair.training\/blogs\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","width":106,"height":48,"caption":"DataFlair"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/DataFlairWS\/","https:\/\/x.com\/DataFlairWS","https:\/\/www.linkedin.com\/company\/dataflair-web-services-pvt-ltd\/","https:\/\/www.youtube.com\/user\/DataFlairWS"]},{"@type":"Person","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/7f83c342f5d1632d6f7b4b0b0f447823","name":"DataFlair Team","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/4cf3a74600d131330b8c481d519afd1574093ed89f6d3396a95393ad223eb7cd?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/4cf3a74600d131330b8c481d519afd1574093ed89f6d3396a95393ad223eb7cd?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/4cf3a74600d131330b8c481d519afd1574093ed89f6d3396a95393ad223eb7cd?s=96&d=mm&r=g","caption":"DataFlair Team"},"description":"DataFlair Team creates expert-level guides on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. Our goal is to empower learners with easy-to-understand content. Explore our resources for career growth and practical learning.","url":"https:\/\/data-flair.training\/blogs\/author\/dfteam1\/"}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/24036","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/comments?post=24036"}],"version-history":[{"count":10,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/24036\/revisions"}],"predecessor-version":[{"id":147961,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/24036\/revisions\/147961"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/24053"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=24036"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=24036"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=24036"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}