Scribd
Upload
17 views

Deep Learning Assignments

Uploaded by

Ashutosh A
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
17 views

Deep Learning Assignments

Uploaded by

Ashutosh A
Copyright
© © All Rights Reserved
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