Iris Dataset: Exploratory Data Analysis, Data Visualization, and Classification¶
About dataset: https://en.wikipedia.org/wiki/Iris_flower_data_set
Iris Dataset: Simple Exploratory Data Analysis (EDA)¶
Import Modules¶
In [1]:
import pandas as pd # import modules pandas as pd
Load Dataset¶
In [2]:
iris_df = pd.read_csv('./dataset/iris/Iris.csv') # load file from csv .extension to be data frame
iris_df.head() # show the first 5 rows of data
Out[2]:
Drop Column 'Id'¶
In [3]:
iris_df.drop(columns='Id', inplace=True) # delete Columns 'Id'
# True so we can modify current data frame without make another data frame
iris_df.head() # show the first 5 rows of data
Out[3]:
Identify the Shape of the Dataset¶
In [4]:
iris_df.shape # show the dimension of the dataset with row and column
Out[4]:
Get the List of Columns¶
In [5]:
iris_df.columns # list of columns
Out[5]:
Identify Data Types For Each Column¶
In [6]:
iris_df.dtypes # datatype for every column
Out[6]:
Get Basic Dataset Information¶
In [7]:
iris_df.info() # information of the dataset
Identify Missing Values¶
In [8]:
iris_df.isna().values.any() # detect is there any NULL value in the dataset
Out[8]:
Identify Duplicate Entries/Rows¶
In [9]:
iris_df[iris_df.duplicated(keep=False)] # show all rows with duplication
Out[9]:
In [10]:
iris_df.duplicated().value_counts() # count the total of duplicated data
Out[10]:
Drop Duplicate Entries/Rows¶
In [11]:
iris_df.drop_duplicates(inplace=True) # delete duplicate data
iris_df.shape
Out[11]:
Describe the Dataset¶
In [12]:
iris_df.describe() # data description
Out[12]:
Correlation Matrix¶
In [13]:
iris_df.corr() # correlation between column
Out[13]:
Iris Dataset: Data Visualization¶
Import Modules¶
In [14]:
import matplotlib.pyplot as plt # import maplotlib as plt for data visualization
import seaborn as sns # import seaborn as sns for data visualization
%matplotlib inline
# output from data visualization data will be directed to notebook
Heatmap¶
In [15]:
sns.heatmap(data=iris_df.corr()) # visualization using Heatmap
Out[15]:
Bar Plot¶
In [16]:
iris_df['Species'].value_counts() # count every species (Iris)
Out[16]:
In [17]:
iris_df['Species'].value_counts().plot.bar() # visualization using Bar plot
plt.tight_layout() # maximize visualization with current screen
plt.show()
In [18]:
sns.countplot(data=iris_df, x='Species') # visualization using Bar plot with seaborn (colorized)
plt.tight_layout()
Pie Chart¶
In [19]:
iris_df['Species'].value_counts().plot.pie(autopct='%1.1f%%', labels=None, legend=True) # visualization using pie chart using percentage
plt.tight_layout()
Line Plot¶
In [20]:
fig,ax = plt.subplots(nrows=2, ncols=2, figsize=(8,8)) # visualization using Line Plot
iris_df['SepalLengthCm'].plot.line(ax=ax[0][0]) # visualize sepal length
ax[0][0].set_title('Sepal Length')
iris_df['SepalWidthCm'].plot.line(ax=ax[0][1]) # visualize sepal width
ax[0][1].set_title('Sepal Width')
iris_df.PetalLengthCm.plot.line(ax=ax[1][0]) # visualize petal length
ax[1][0].set_title('Petal Length')
iris_df.PetalWidthCm.plot.line(ax=ax[1][1]) # visualize petal width
ax[1][1].set_title('Petal Width')
Out[20]:
In [21]:
iris_df.plot() # visualization using Line Plot as one plot
plt.tight_layout()
Histogram¶
In [22]:
iris_df.hist(figsize=(6,6), bins=10) # visualization using Histogram # bins=10 to expanse it more
plt.tight_layout()
Boxplot¶
In [23]:
iris_df.boxplot() # visualization using Box Plot (Quarter 1,2,3, Min, Max, Outlier)
plt.tight_layout()
In [24]:
iris_df.boxplot(by="Species", figsize=(8,8)) # visualization using Line Plot based on species
plt.tight_layout()
Scatter Plot¶
In [25]:
sns.scatterplot(x='SepalLengthCm', y='SepalWidthCm', data=iris_df, hue='Species') # visualization using Scatter Plot
plt.tight_layout()
Pair Plot¶
In [26]:
sns.pairplot(iris_df, hue='Species', markers='+') # visualization using Pair Plot
plt.tight_layout()
Violin Plot¶
In [27]:
sns.violinplot(data=iris_df, y='Species', x='SepalLengthCm', inner='quartile') # visualization using Violin Plot
plt.tight_layout()
Iris Dataset: Classification Models¶
Import Modules¶
In [28]:
from sklearn.model_selection import train_test_split # as splitter dataset into training and testing set
from sklearn.metrics import accuracy_score,confusion_matrix, classification_report # evaluate model performance
Dataset: Features & Class Label¶
In [29]:
X = iris_df.drop(columns='Species') # put features into variable X
X.head() # show the first 5 rows of X
Out[29]:
In [30]:
y = iris_df['Species'] # put class label (target) into variabel y
y.head() # show the first 5 rows of y
Out[30]:
Split the Dataset Into A Training Set and A Testing Set¶
In [31]:
# split dataset into training and testing set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=10)
print('training dataset')
print(X_train.shape)
print(y_train.shape)
print()
print('testing dataset:')
print(X_test.shape)
print(y_test.shape)
K Nearest Neighbors¶
In [32]:
from sklearn.neighbors import KNeighborsClassifier # using KNN as classifier
In [33]:
k_range = list(range(1,26)) # specify neighbors 1-25, 26 is the max
scores = []
for k in k_range:
model_knn = KNeighborsClassifier(n_neighbors=k) # config algorithm
model_knn.fit(X_train, y_train) # training model/classifier
y_pred = model_knn.predict(X_test) # prediction
scores.append(accuracy_score(y_test, y_pred)) # performance evaluate
In [34]:
plt.plot(k_range, scores) # (x-axis) total neighbor (y-axis) accuracy value
plt.xlabel('Value of k for KNN')
plt.ylabel('Accuracy Score')
plt.title('Accuracy Scores for Values of k of k-Nearest-Neighbors')
plt.tight_layout()
plt.show()
In [35]:
model_knn = KNeighborsClassifier(n_neighbors=3) # config algorithm with 3 neighbors
model_knn.fit(X_train,y_train) # training model/classifier
y_pred = model_knn.predict(X_test) # prediction
Accuracy Score¶
In [36]:
print(accuracy_score(y_test, y_pred)) # accuracy evaluate
Confusion Matrix¶
In [37]:
print(confusion_matrix(y_test, y_pred)) # evaluate confusion matrix
Classification Report¶
In [38]:
print(classification_report(y_test, y_pred)) # classification evaluate
Logistic Regression¶
In [39]:
from sklearn.linear_model import LogisticRegression # import Logistic Regression as classifier
In [40]:
model_logreg = LogisticRegression(solver='lbfgs', multi_class='auto')
model_logreg.fit(X_train,y_train)
y_pred = model_logreg.predict(X_test)
Accuracy Score¶
In [41]:
print(accuracy_score(y_test, y_pred))
Confusion Matrix¶
In [42]:
print(confusion_matrix(y_test, y_pred))
Classification Report¶
In [43]:
print(classification_report(y_test, y_pred))
Support Vector Classifier¶
In [44]:
from sklearn.svm import SVC # import SVC as classifier
In [45]:
model_svc = SVC(gamma='scale')
model_svc.fit(X_train,y_train)
y_pred = model_svc.predict(X_test)
Accuracy Score¶
In [46]:
print(accuracy_score(y_test, y_pred))
Confusion Matrix¶
In [47]:
print(confusion_matrix(y_test, y_pred))
Classification Report¶
In [48]:
print(classification_report(y_test, y_pred))
Decision Tree Classifier¶
In [49]:
from sklearn.tree import DecisionTreeClassifier # import Decision Tree Classifier as classifier
In [50]:
model_dt = DecisionTreeClassifier()
model_dt.fit(X_train,y_train)
y_pred = model_dt.predict(X_test)
Accuracy Score¶
In [51]:
print(accuracy_score(y_test, y_pred))
Confusion Matrix¶
In [52]:
print(confusion_matrix(y_test, y_pred))
Classification Report¶
In [53]:
print(classification_report(y_test, y_pred))
Random Forest Classifier¶
In [54]:
from sklearn.ensemble import RandomForestClassifier # import Random Forest Classifier as classifier
In [55]:
model_rf = RandomForestClassifier(n_estimators=100) # (100 means 100 trees)
model_rf.fit(X_train,y_train)
pred_rf = model_rf.predict(X_test)
Accuracy Score¶
In [56]:
print(accuracy_score(y_test, y_pred))
Confusion Matrix¶
In [57]:
print(confusion_matrix(y_test, y_pred))
Classification Report¶
In [58]:
print(classification_report(y_test, y_pred))
Accuracy Comparison For Various Models.¶
In [59]:
models = [model_knn, model_logreg, model_svc, model_dt, model_rf] # compare model that already created
accuracy_scores = []
for model in models:
y_pred = model.predict(X_test) # make prediction
accuracy = accuracy_score(y_test, y_pred) # accuracy score
accuracy_scores.append(accuracy)
print(accuracy_scores)
In [60]:
plt.bar(['KNN', 'LogReg', 'SVC', 'DT', 'RF'],accuracy_scores) # visualize 5 algorithm performance
plt.ylim(0.90,1.01)
plt.title('Accuracy comparison For Various Models', fontsize=15, color='r')
plt.xlabel('Models', fontsize=18, color='g')
plt.ylabel('Accuracy Score', fontsize=18, color='g')
plt.tight_layout()
plt.show()
