import tensorflow as tf

from tensorflow import keras

from tensorflow.keras.layers import Dense, Activation, Dropout
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.metrics import Accuracy

• Imports TensorFlow and Keras: The code imports TensorFlow and Keras, which are
libraries for building and training neural networks.

• Model Layers: It imports key layers such as Dense (fully connected layer), Activation
(for activation functions like ReLU, Sigmoid), and Dropout (to prevent overfitting).

• Optimizer: The Adam optimizer is imported, which is an efficient gradient descent

optimization algorithm commonly used in training deep learning models.

• Metrics: Accuracy is imported as a performance metric to evaluate the model’s correctness

during training and testing.

• Foundation for Model Building: This setup allows you to easily define, compile, and
train a neural network model using Keras.

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
from sklearn import metrics
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import classification_report,accuracy_score,roc_curve,confusion_matrix

• Import Data Handling Library: pandas is imported for handling and manipulating
datasets, especially in tabular form.
• Visualization Libraries: matplotlib.pyplot and seaborn are used for data
visualization, where matplotlib provides basic plotting, and seaborn enhances the
aesthetics of the plots.
• Numerical Operations: numpy is imported for efficient numerical computations, such as
array operations.
• Machine Learning Metrics: The metrics module from sklearn is imported to evaluate
model performance, including functions like confusion matrix, ROC curve, and classification
reports.
• Data Preprocessing: LabelEncoder from sklearn is imported to convert categorical data
into numerical form, a common step in preprocessing for machine learning models.

pip install jupyterthemes

• Installs Jupyter Themes: The command installs the jupyterthemes package, which
allows customization of the appearance of Jupyter Notebooks.

• Theme Customization: After installation, you can apply various themes, fonts, and color
schemes to personalize your Jupyter environment.

• Improves Visual Aesthetics: It helps enhance the readability and aesthetics of Jupyter
notebooks, making it visually appealing during presentations.

• Easy Application: Once installed, themes can be applied using simple commands like jt
-t <theme-name> in the terminal.

from jupyterthemes import jtplot

jtplot.style(theme = 'monokai', context = 'notebook', ticks = True, grid =
False)

• Import Jupyter Plot Styling: Imports jtplot from the jupyterthemes package to
customize plot styles in Jupyter Notebooks.

• Apply Monokai Theme: The code sets the plot theme to 'monokai', a dark color scheme
that enhances visual contrast.

• Customize Plot Context: context = 'notebook' sets the visual context of the plots,
optimizing them for use in notebooks.

• Plot Display Settings: ticks = True ensures axis ticks are shown, and grid = False
disables the background grid for a cleaner look.

#Load the training and testing datasets

instagram_df_test = pd.read_csv('test.csv')
instagram_df_train = pd.read_csv('train.csv')

• Load Data with Pandas: The code uses the pandas library to read CSV files, which is a
common format for storing tabular data.

• Training Dataset: instagram_df_train is assigned the data from the 'train.csv' file,
which typically contains examples used to train a machine learning model.
• Testing Dataset: instagram_df_test is assigned the data from the 'test.csv' file, used to
evaluate the model's performance after training.

• DataFrames Creation: Both variables create Pandas DataFrames, allowing for easy
manipulation and analysis of the data.

• Assumption of CSV Structure: The code assumes that both CSV files are structured
correctly with appropriate headers for the features needed in the analysis.

• Preparation for Analysis: Loading the datasets is a crucial step that prepares them for
preprocessing, feature extraction, and model training.

#Getting dataframe info

instagram_df_train.info()

• Display DataFrame Information: The code uses the .info() method of the Pandas
DataFrame to display information about instagram_df_train.

• Overview of DataFrame Structure: It provides a summary of the DataFrame, including

the number of entries (rows) and the number of columns.

• Data Types: The method lists the data types of each column (e.g., integer, float, object),
helping to identify the nature of the data.

• Non-null Count: It shows the count of non-null entries for each column, which is useful
for detecting missing values.

• Memory Usage: The output includes the memory usage of the DataFrame, indicating how
much memory is consumed by the data, which is important for optimizing performance.

• Initial Data Exploration: Using .info() is a fundamental step in data exploration,

providing insights that inform further data cleaning and preprocessing.

#Statistical summary of the dataframe

instagram_df_train.describe()

• Statistical Summary: The code uses the .describe() method of the Pandas DataFrame
to generate a statistical summary of instagram_df_train.
• Numerical Features Analysis: It computes statistics for numerical columns, including
count, mean, standard deviation, minimum, maximum, and quartiles.
• Count of Entries: The output includes the number of non-null entries for each numerical
column, helping identify missing values.
• Understanding Data Distribution: The summary statistics provide insights into the
distribution and central tendencies of the numerical features, useful for understanding the
data.
• Outlier Detection: The minimum and maximum values help in identifying potential
outliers that may need further investigation or preprocessing.
#Check if null values exist
instagram_df_train.isnull().sum()

• Check for Null Values: The code uses the .isnull().sum() method on the
instagram_df_train DataFrame to check for missing values in the dataset.

• Returns Null Count: This method returns a Series with the count of null (missing) values
for each column in the DataFrame.

• Data Quality Assessment: By examining the output, you can assess the quality of the data
and identify columns that may require cleaning or imputation due to missing values.

• Critical Preprocessing Step: Identifying null values is a crucial step in data

preprocessing, as it informs decisions on how to handle them, whether by removing, filling,
or flagging them.

• Understand Impact on Model: Knowing the presence of null values helps evaluate their
potential impact on model training and prediction accuracy.

#Number of unique values in the profile pic column

instagram_df_train['profile pic'].value_counts()

• Count Unique Values: The code uses the .value_counts() method on the 'profile
pic' column of the instagram_df_train DataFrame to count the number of unique values.

• Profile Picture Analysis: This method helps identify how many distinct profile pictures
are present in the dataset, which can be relevant for identifying patterns or behaviors.

• Frequency of Each Value: The output lists each unique profile picture along with the
number of occurrences in the dataset, providing insights into common profile pictures.

• Data Distribution Insight: Understanding the distribution of profile pictures can be useful
for feature engineering, especially if certain images are associated with fake accounts.

• Spotting Anomalies: If there are very few unique values or an unexpected distribution, it
might indicate potential issues or anomalies in the dataset.

• Guidance for Further Analysis: The results can inform further analysis, such as
evaluating the impact of profile pictures on account legitimacy or user engagement.
#Number of accounts having description length over 50
(instagram_df_train['description length'] > 50).sum()

• Check Description Length: The code checks the length of descriptions in the
'description length' column of the instagram_df_train DataFrame to find accounts
with descriptions longer than 50 characters.

• Boolean Condition: The expression (instagram_df_train['description length'] >

50) creates a boolean Series, where each entry is True if the condition is met and False
otherwise.

• Count True Values: The .sum() method counts the number of True values in the boolean
Series, effectively giving the total number of accounts with description lengths greater than
50.

• Insight into Account Profiles: This count provides insights into how many users prefer
longer descriptions, which may correlate with engagement or account type.

• Data Exploration: Analyzing description lengths can help in understanding user behavior
and preferences on the platform, aiding in user classification.

• Guidance for Further Analysis: The result can inform subsequent steps, such as
examining the impact of description length on account legitimacy or user interaction metrics.

#Vislualizing the number of fake and real accounts (using seaborn library)
sns.countplot(instagram_df_train['fake'])

• Visualization of Account Types: The code uses Seaborn’s countplot() function to

visualize the number of fake and real accounts in the 'fake' column of the
instagram_df_train DataFrame.

• Countplot Functionality: The countplot() function automatically counts the

occurrences of each category (fake or real) in the specified column and displays them as bars.

• Categorical Data Representation: This visualization provides a clear representation of

the distribution of account types, making it easy to compare the counts of fake and real
accounts.

• Quick Insights: The plot offers immediate visual insights into the dataset's balance
between fake and real accounts, which is crucial for assessing model training needs.
• Identifying Class Imbalance: If one category significantly outweighs the other, it may
indicate class imbalance, which could impact the performance of machine learning models.

• Enhancing Data Interpretation: Using visualizations like this helps convey findings
more effectively, making it easier for stakeholders to understand the distribution of account
types in the dataset.

#Visualizing the private column

sns.countplot(instagram_df_train['private'],palette = "PuBu")

• Visualization of Privacy Settings: The code uses Seaborn’s countplot() function to

visualize the distribution of accounts based on their privacy settings, represented by the
'private' column in the instagram_df_train DataFrame.

• Categorical Count Representation: The countplot() function counts the occurrences of

each category (private or public) and displays them as bars, allowing for easy comparison.

• Color Palette: The palette = "PuBu" parameter specifies a color palette for the bars,
using shades of blue to enhance visual appeal and clarity in the plot.

• Understanding User Preferences: This visualization provides insights into user

preferences regarding account privacy, which may relate to their engagement and behavior on
the platform.

• Immediate Insights: The plot allows for quick visual assessment of how many accounts
are set to private versus public, aiding in understanding overall account settings.

#Visualizing the profile pic feature

sns.countplot(instagram_df_train['profile pic'],palette = "Pastel2")

• Profile Picture Visualization: The code uses Seaborn’s countplot() function to

visualize the distribution of unique profile pictures in the 'profile pic' column of the
instagram_df_train DataFrame.

• Categorical Count Representation: countplot() automatically counts how many times

each profile picture appears and displays these counts as bars, facilitating comparison among
different pictures.

• Color Palette: The palette = "Pastel2" parameter specifies a soft, pastel color scheme
for the bars, enhancing the visual appeal of the plot.

• Identifying Common Profile Pictures: This visualization helps in identifying the most
common profile pictures used by users, which can be relevant for analyzing user behavior or
account authenticity.
• Understanding Data Distribution: By examining the distribution of profile pictures,
insights can be gained about user tendencies, such as whether certain images are more
frequently associated with fake accounts.

#Visualizing the length of usernames(Histogram)

plt.figure(figsize = (20, 10))
sns.distplot(instagram_df_train['nums/length username'],kde=True)

• Histogram Visualization: The code visualizes the distribution of username lengths in the
'nums/length username' column of the instagram_df_train DataFrame using a
histogram.

• Figure Size Specification: The plt.figure(figsize=(20, 10)) function sets the size of
the figure to 20 inches wide by 10 inches tall, ensuring the plot is large and easy to read.

• Density Plot Overlay: The sns.distplot() function includes a kernel density estimate
(KDE) overlay, providing a smoothed line that represents the distribution of username
lengths alongside the histogram.

• Understanding Username Length Distribution: This visualization helps identify patterns

in username lengths, such as common lengths or outliers, which can be relevant for analyzing
account behavior or legitimacy.

• Assessing Data Characteristics: By examining the distribution, insights can be gained

about the potential impact of username length on user engagement or the likelihood of
accounts being fake.

• Informing Further Analysis: The insights drawn from this histogram can guide further
investigations, such as studying correlations between username length and other account
features.

#Correlation heatmap
plt.figure(figsize=(15,15))
cm = instagram_df_train.corr()
ax = plt.subplot()
sns.heatmap(cm, annot = True, ax = ax)

• Correlation Matrix Calculation: The code computes the correlation matrix of the
instagram_df_train DataFrame using the .corr() method, which quantifies the
relationships between numerical features.

• Figure Size Specification: plt.figure(figsize=(15, 15)) sets the size of the heatmap
to 15 inches by 15 inches, ensuring clear visibility of the heatmap and annotations.
• Creating the Heatmap: The sns.heatmap() function is used to create a heatmap
visualizing the correlation matrix, where color intensity represents the strength of the
correlation between features.

• Annotations on the Heatmap: The annot=True parameter displays the correlation

coefficients on the heatmap, allowing for easy interpretation of the relationships between
features.

plt.plot(epochs_hist.history['loss'])
plt.plot(epochs_hist.history['val_loss'])

plt.title('Model Loss Progressioin During Training/Validation')

plt.xlabel('Epoch Number')
plt.ylabel('Training and Validation Losses')
plt.legend(['Training Loss','Valdiation Loss'])

• Plotting Training and Validation Loss: The code plots the training loss and validation
loss from the model's training history, allowing for visual assessment of the model's
performance over epochs.

• Accessing Loss History: epochs_hist.history['loss'] retrieves the training loss

values, while epochs_hist.history['val_loss'] retrieves the validation loss values for
each epoch.

• Title of the Plot: plt.title() sets the title of the plot to "Model Loss Progression During
Training/Validation," providing context for the visualization.

• Axis Labels: plt.xlabel() and plt.ylabel() specify the labels for the x-axis (Epoch
Number) and y-axis (Training and Validation Losses), enhancing the plot's clarity.

• Legend for Clarity: The plt.legend() function adds a legend to differentiate between
the training loss and validation loss, making it easier to interpret the plot.

• Assessing Overfitting or Underfitting: By analyzing the loss curves, you can identify
potential issues like overfitting (when validation loss increases while training loss decreases)
or underfitting (high loss values for both training and validation).

predicted_value = []
test = []
for i in predicted:
predicted_value.append(np.argmax(i))

for i in Y_test:
test.append(np.argmax(i))
• Initialization of Lists: Two empty lists, predicted_value and test, are initialized to
store the predicted class labels and the true class labels from the test set, respectively.

• Iterating Over Predictions: The first for loop iterates through the predicted array
(assumed to be the output of a model), applying np.argmax() to each element. This function
retrieves the index of the maximum value, effectively converting predicted probabilities to
class labels.

• Storing Predicted Class Labels: Each class label obtained from the np.argmax()
function is appended to the predicted_value list, which will hold the final predicted classes
for evaluation.

• Iterating Over True Labels: The second for loop iterates through the Y_test array
(assumed to be the true labels of the test data), similarly using np.argmax() to convert one-
hot encoded labels into class indices.

• Storing True Class Labels: The class labels from Y_test are appended to the test list,
which will be used to compare against the predicted labels for performance evaluation.

plt.figure(figsize=(10, 10))
con_matrix = confusion_matrix(test,predicted_value)
sns.heatmap(con_matrix, annot=True)

• Figure Size Specification: The code sets up a plot with a specified size of 10 inches by 10
inches using plt.figure(figsize=(10, 10)), ensuring the heatmap will be clearly visible.

• Confusion Matrix Calculation: The confusion_matrix() function computes the

confusion matrix using the true labels (test) and the predicted labels (predicted_value),
summarizing the performance of the classification model.

• Heatmap Visualization: The sns.heatmap() function visualizes the confusion matrix as

a heatmap, where color intensity represents the count of true positives, false positives, true
negatives, and false negatives.

• Annotations for Clarity: By default, annot=True in sns.heatmap() displays the

numerical values in each cell of the heatmap, allowing for easy interpretation of the
confusion matrix.

• Assessing Model Performance: The heatmap provides a visual representation of the

classification performance, making it easier to identify which classes are being correctly
predicted and which are being misclassified.