Scribd
Upload
19 views

Deep Learning Assignments

Uploaded by

Ashutosh A
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
19 views

Deep Learning Assignments

Uploaded by

Ashutosh A
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 5

Ashutosh Anand

DL Assignment Lab 3 Penguin

202318035

DATASET: PENGIUN LTER


In [7]: import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report
import numpy as np

# Load the dataset


df = pd.read_csv('/content/penguins_lter.csv')

# Data cleaning
# Dropping rows with missing values in specific columns
relevant_columns = ['Culmen Length (mm)', 'Culmen Depth (mm)', 'Flipper Length (mm)', 'Body Ma
df = df.dropna(subset=relevant_columns)

# Converting 'Sex' from categorical to binary labels


df['Sex'] = df['Sex'].map({'MALE': 1, 'FEMALE': 0})

# Dropping irrelevant columns


columns_to_drop = ['studyName', 'Sample Number', 'Species', 'Region', 'Island', 'Stage',
'Individual ID', 'Clutch Completion', 'Date Egg', 'Comments', 'Delta 15 N
df = df.drop(columns=columns_to_drop)

In [8]: df.head()

Out[8]: Culmen Length (mm) Culmen Depth (mm) Flipper Length (mm) Body Mass (g) Sex

0 39.5 17.4 186 3800 0

1 40.3 18.0 195 3250 0

2 36.7 19.3 193 3450 0

3 38.9 17.8 181 3625 0

4 41.1 17.6 182 3200 0

In [9]: import seaborn as sns


import matplotlib.pyplot as plt

# Pairplot to visualize relationships between numerical variables and the target variable 'Sex
sns.pairplot(df, hue='Sex', diag_kind='kde', palette='viridis')
plt.show()

# Correlation Matrix to check relationships between features


plt.figure(figsize=(8, 6))
# Using a different colormap
sns.heatmap(df.corr(), annot=True, cmap='inferno')
plt.title("Correlation Matrix")
plt.show()
Logistic regression - Classifying SEX based on the Dataset
In [10]: X = df.drop(columns=['Sex']) # Features
y = df['Sex'] # Target

In [11]: scaler = StandardScaler()


X_scaled = scaler.fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=4

In [12]: log_reg = LogisticRegression()

log_reg.fit(X_train, y_train)

y_pred = log_reg.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)


classification_report_result = classification_report(y_test, y_pred)

print(f"Accuracy: {accuracy}")
print("Classification Report:\n", classification_report_result)
Accuracy: 0.8656716417910447
Classification Report:
precision recall f1-score support

0 0.86 0.88 0.87 34


1 0.88 0.85 0.86 33

accuracy 0.87 67
macro avg 0.87 0.87 0.87 67
weighted avg 0.87 0.87 0.87 67

ANN Pytorch

In [13]: import torch


import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

In [14]: X_train_tensor = torch.tensor(X_train, dtype=torch.float32)


X_test_tensor = torch.tensor(X_test, dtype=torch.float32)
y_train_tensor = torch.tensor(y_train.values, dtype=torch.float32).view(-1, 1)
y_test_tensor = torch.tensor(y_test.values, dtype=torch.float32).view(-1, 1)

train_dataset = TensorDataset(X_train_tensor, y_train_tensor)


test_dataset = TensorDataset(X_test_tensor, y_test_tensor)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)


test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

In [15]: class ANNModel(nn.Module):


def __init__(self):
super(ANNModel, self).__init__()
self.layer1 = nn.Linear(X_train_tensor.shape[1], 64)
self.layer2 = nn.Linear(64, 64)
self.output_layer = nn.Linear(64, 1)

def forward(self, x):


x = torch.relu(self.layer1(x))
x = torch.relu(self.layer2(x))
x = torch.sigmoid(self.output_layer(x))
return x

In [16]: model = ANNModel()


criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

In [17]: epochs = 50
for epoch in range(epochs):
model.train()
running_loss = 0.0
for inputs, targets in train_loader:
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, targets)
loss.backward()
optimizer.step()
running_loss += loss.item()

In [18]: model.eval()
y_pred = []
with torch.no_grad():
for inputs, _ in test_loader:
outputs = model(inputs)
y_pred.append(outputs)

In [19]: y_pred = torch.cat(y_pred).numpy()


y_pred = (y_pred > 0.5).astype(int)

accuracy = accuracy_score(y_test, y_pred)


classification_report_result = classification_report(y_test, y_pred)

print(f"Accuracy: {accuracy}")
print(f"Classification Report:\n{classification_report_result}")

Accuracy: 0.8805970149253731
Classification Report:
precision recall f1-score support

0 0.91 0.85 0.88 34


1 0.86 0.91 0.88 33

accuracy 0.88 67
macro avg 0.88 0.88 0.88 67
weighted avg 0.88 0.88 0.88 67

You might also like