SRI VENKATESWARAA

COLLEGE OF TECHNOLOGY
Vadakal, Sriperumbudur – 602 105

RECORD NOTEBOOK

Student Name :

Register Number :

Semester / Branch :

Subject Code :

Subject Name :
SRI VENKATESWARAA COLLEGE OF TECHNOLOGY
Vadakal, Sriperumbudur – 602 105
Department of Artificial intelligence & Data science

BONAFIDE CERTIFICATE
This is to certify that this a bonafide record of practical work done
by Register Number
of Semester B.Tech/M.Tech in the
laboratory during the
academic year .

Staff In-Charge Head of the Department

Submitted for the practical examination of Bachelor of Technology

held at Sri Venkateswaraa College of Technology on

Internal Examiner External Examiner

 INDEX
Ex. Date Title of Experiment Page Faculty
No No Signature

1. Remote Patient Monitoring for Chronic

Disease Management

2. Ethical Issues of Autonomous

Vehicles

3. Ethical AI in Defence

4. Multiple Linear Regression Model

5. Experimentation with Bias and Variance in Regression

Models

6. Classification using Perceptron with and without Bias

7. Case Study on Ontology with Ethical Implications

Exp No: 1
Remote Patient Monitoring for Chronic Disease Management
Date:

Aim:

To Predict chronic kidney disease using machine learning techniques.

Procedure:

1. Load and preprocess the dataset.

2. Clean the data by removing irrelevant columns and handling missing or inconsistent
values.
3. Rename columns for clarity.
4. Standardize categorical data for consistency.
5. Encode the target variable to binary format for classification.
6. Conduct exploratory data analysis (EDA) to visualize data distributions and relationships
between variables.
7. Define visualization functions to plot relationships between variables.
8. Plot relationships between variables and the target variable.
9. Separate features and target variable for model building.
10. Split the dataset into training and testing sets.
11. Implement a K-Nearest Neighbors classifier.
12. Evaluate model performance using accuracy score, confusion matrix, and classification
report.
Code:

Step 1:

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns

import plotly.express as px

import warnings

warnings.filterwarnings('ignore')

plt.style.use('fivethirtyeight')

%matplotlib inline

pd.set_option('display.max_columns', 26)
Step 2:

Dataset Link: https://www.kaggle.com/code/niteshyadav3103/chronic-kidney-disease-

prediction-98-accuracy/input

df= pd.read_csv('kidney_disease.csv')
df.head()
Step 3:

df.drop('id', axis = 1, inplace = True)

Step 4:

df.columns = ['age', 'blood_pressure', 'specific_gravity', 'albumin', 'sugar', 'red_blood_cells',

'pus_cell',

'pus_cell_clumps', 'bacteria', 'blood_glucose_random', 'blood_urea', 'serum_creatinine',

'sodium',

'potassium', 'haemoglobin', 'packed_cell_volume', 'white_blood_cell_count',

'red_blood_cell_count',
'hypertension', 'diabetes_mellitus', 'coronary_artery_disease', 'appetite', 'peda_edema',

'aanemia', 'class']

Step 5:

df['packed_cell_volume'] = pd.to_numeric(df['packed_cell_volume'], errors='coerce')

df['white_blood_cell_count'] = pd.to_numeric(df['white_blood_cell_count'], errors='coerce')

df['red_blood_cell_count'] = pd.to_numeric(df['red_blood_cell_count'], errors='coerce')

df.info()

Step 6:

cat_cols = [col for col in df.columns if df[col].dtype == 'object']

num_cols = [col for col in df.columns if df[col].dtype != 'object']

Step 7:

for col in cat_cols:

print(f"{col} has {df[col].unique()} values\n")

Step 8:

df['diabetes_mellitus'].replace(to_replace = {'\tno':'no','\tyes':'yes',' yes':'yes'},inplace=True)

df['coronary_artery_disease'] = df['coronary_artery_disease'].replace(to_replace = '\tno',

value='no')

df['class'] = df['class'].replace(to_replace = {'ckd\t': 'ckd', 'notckd': 'not ckd'})

Step 9:

df['class'] = df['class'].map({'ckd': 0, 'not ckd': 1})

df['class'] = pd.to_numeric(df['class'], errors='coerce')

Step 10:
cols = ['diabetes_mellitus', 'coronary_artery_disease', 'class']

for col in cols:

print(f"{col} has {df[col].unique()} values\n")

Step 11:

plt.figure(figsize = (20, 15))

plotnumber = 1

for column in num_cols:

if plotnumber <= 14:

ax = plt.subplot(3, 5, plotnumber)

sns.distplot(df[column])

plt.xlabel(column)

plotnumber += 1

plt.tight_layout()

plt.show()

Step 12:

plt.figure(figsize = (20, 15))

plotnumber = 1

for column in cat_cols:

if plotnumber <= 11:

ax = plt.subplot(3, 4, plotnumber)

sns.countplot(df[column], palette = 'rocket')

plt.xlabel(column)

plotnumber += 1

plt.tight_layout()

plt.show()

Step 13:

def violin(col):

fig = px.violin(df, y=col, x="class", color="class", box=True, template = 'plotly_dark')

return fig.show()

def kde(col):

grid = sns.FacetGrid(df, hue="class", height = 6, aspect=2)

 grid.map(sns.kdeplot, col)

grid.add_legend()

def scatter(col1, col2):

fig = px.scatter(df, x=col1, y=col2, color="class", template = 'plotly_dark')

return fig.show()
Step 14:

violin('red_blood_cell_count')

kde('blood_urea')

scatter('red_blood_cell_count', 'albumin')
Step 15:

px.bar(df, x="blood_pressure", y="haemoglobin", color='class', barmode='group', template =

'plotly_dark', height = 400)
Step 16:

ind_col = [col for col in df.columns if col != 'class']

dep_col = 'class'

X = df[ind_col]

y = df[dep_col]
Step 17:

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.30, random_state = 0)

Step 18:

from sklearn.neighbors import KNeighborsClassifier

from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

knn = KNeighborsClassifier()

knn.fit(X_train, y_train)

accuracy score, confusion matrix and classification report of knn

knn_acc = accuracy_score(y_test, knn.predict(X_test))

print(f"Training Accuracy of KNN is {accuracy_score(y_train, knn.predict(X_train))}")

print(f"Test Accuracy of KNN is {knn_acc} \n")

print(f"Confusion Matrix :- \n{confusion_matrix(y_test, knn.predict(X_test))}\n")

print(f"Classification Report :- \n {classification_report(y_test, knn.predict(X_test))}")
Output:
Exp No: 2
Ethical Issues of Autonomous Vehicles
Date:

Aim:

The aim of this project is to analyze public survey responses on ethical dilemmas of
autonomous vehicles and build predictive models to classify respondents based on their
responses.

Procedure:

1. Import necessary libraries.

2. Load the dataset.
3. Display the first few rows of the dataset.
4. Check for missing values and data types.
5. Preprocess the data by handling missing values.
6. Explore and visualize the data distribution and relationships.
7. Build predictive models by separating features and target variable, and splitting the
dataset into training and testing sets.
8. Train the Random Forest and Logistic Regression classifiers.
9. Make predictions using the trained models.
10. Evaluate the models' performance using accuracy score, confusion matrix, and
classification report.
Code:

Step 1:

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.ensemble import RandomForestClassifier

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

Step 2:

Dataset Link: https://www.kaggle.com/datasets/vaisakhpd/data-survey

url = "dataset.csv"

df = pd.read_csv(url)
Step 3:

print(df.head())
Step 4:

print(df.info())

Step 5:

df.replace('null', np.nan, inplace=True)

Step 6:

plt.figure(figsize=(15, 10))

for i in range(1, 8):

plt.subplot(3, 3, i)

sns.countplot(data=df, x=f"Ǫ{i}")

plt.title(f"Ǫuestion {i}")

plt.tight_layout()

plt.show()
Step 7:

sns.pairplot(df, hue='Target_Variable')

plt.show()
Step 8:

plt.figure(figsize=(10, 8))

sns.heatmap(df.corr(), annot=True, cmap='coolwarm')

plt.title('Correlation Heatmap')

plt.show()
Step 9:

X = df.iloc[:, 1:] Features

y = df.iloc[:, 0] Target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

rf_classifier = RandomForestClassifier(random_state=42)

lr_classifier = LogisticRegression(random_state=42)
Step 10:

rf_classifier.fit(X_train, y_train)
Step 11:

lr_classifier.fit(X_train, y_train)
Step 12:
rf_predictions = rf_classifier.predict(X_test)

lr_predictions = lr_classifier.predict(X_test)
Step 13:

rf_accuracy = accuracy_score(y_test, rf_predictions)

lr_accuracy = accuracy_score(y_test, lr_predictions)

rf_conf_matrix = confusion_matrix(y_test, rf_predictions)

lr_conf_matrix = confusion_matrix(y_test, lr_predictions)

rf_classification_report = classification_report(y_test, rf_predictions)

lr_classification_report = classification_report(y_test, lr_predictions)

print("Random Forest Model Accuracy:", rf_accuracy)

print("Logistic Regression Model Accuracy:", lr_accuracy)

print("Confusion Matrix (Random Forest):\n", rf_conf_matrix)

print("Confusion Matrix (Logistic Regression):\n", lr_conf_matrix)

print("Classification Report (Random Forest):\n", rf_classification_report)

print("Classification Report (Logistic Regression):\n", lr_classification_report)

Output:
Exp No: 3
Ethical AI in Defence
Date:

Aim:

To analyze a method for ensuring ethical AI in defense applications, particularly in the

development of trustworthy autonomous systems.
Procedure:

1. Download datasets from the following links:

i. military.csv: [Global Armed Forces
Dataset](https://www.kaggle.com/datasets/abhijitdahatonde/global
-armed-forces-dataset).
ii. gdp_per_capita.csv: [GitHub](https://github.com/ageron/handson-
ml/blob/master/datasets/lifesat/gdp_per_capita.csv).
iii. autonomous_systems.csv:
https://github.com/WillKoehrsen/recurrent-neural-
networks/blob/master/data/old/patent_search/gp-search-
autonomous-systems.csv).
2. Import required libraries: pandas, numpy, matplotlib.pyplot, seaborn.
3. Load and explore the military dataset.
4. Visualize the distribution of active military personnel.
5. Visualize the top 10 countries with the highest active military personnel.
6. Merge GDP per capita data and analyze correlation.
7. Visualize the correlation between active military personnel and GDP per capita.
8. Explore ethical AI in defense and analyze bias in autonomous systems.
9. Visualize the bias analysis results for autonomous systems.
Code:

Step 1:

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns

Step 2:

# Load the dataset

df = pd.read_csv('military.csv')
Step 3:

# Explore the dataset

print(df.head())

print(df.info())
print(df.describe())
Step 4:

# Visualize the distribution of active military personnel per country

plt.figure(figsize=(10, 6))

sns.distplot(df['Active military'])

plt.title('Distribution of Active Military Personnel per Country')

plt.xlabel('Active Military Personnel')

plt.ylabel('Frequency')

plt.show()
Step 5:

# Visualize the top 10 countries with the highest active military personnel

plt.figure(figsize=(10, 6))

sns.barplot(x='Country', y='Active military', data=df.sort_values('Active military',

ascending=False).head(10))

plt.title('Top 10 Countries with Highest Active Military Personnel')

plt.xlabel('Country')

plt.ylabel('Active Military Personnel')

plt.show()
Step 6:

# Analyze the correlation between active military personnel and GDP per capita

df_gdp = pd.read_csv('gdp_per_capita.csv') # assume you have a separate dataset with GDP per
capita data

df_merged = pd.merge(df, df_gdp, on='Country')

corr_matrix = df_merged[['Active military', 'GDP per capita']].corr()

print(corr_matrix)
Step 7:

# Visualize the correlation between active military personnel and GDP per capita

plt.figure(figsize=(8, 6))

sns.scatterplot(x='GDP per capita', y='Active military', data=df_merged)

plt.title('Correlation between Active Military Personnel and GDP per Capita')

plt.xlabel('GDP per Capita')

plt.ylabel('Active Military Personnel')

plt.show()
Step 8:

# Explore the concept of Ethical AI in Defence

# For example, let's analyze the potential bias in autonomous systems based on country of
origin

df_autonomous = pd.read_csv('autonomous_systems.csv') # assume you have a separate

dataset with autonomous systems data

df_merged = pd.merge(df, df_autonomous, on='Country')

bias_analysis = df_merged.groupby('Country')['Autonomous system bias'].mean()

print(bias_analysis)

Step 9:

# Visualize the bias analysis results

plt.figure(figsize=(10, 6))

sns.barplot(x='Country', y='Autonomous system bias', data=bias_analysis.reset_index())

plt.title('Bias Analysis of Autonomous Systems by Country of Origin')

plt.xlabel('Country')

plt.ylabel('Autonomous System Bias')

plt.show()
Output:
Exp No: 4
Multiple Linear Regression Model
Date:

Aim:

To implement and understand the concept of multiple linear regression in Python.

Procedure:

1. Import necessary libraries: numpy, matplotlib, pandas, seaborn.

2. Read dataset from CSV file and display the first few rows.
3. Print the data types of each column in the dataset.
4. Remove unnecessary columns ('id', 'date') from the dataset.
5. Visualize pair plots of selected features against price, colored by the number of
bedrooms.
6. Separate independent variables (features) and dependent variable (target) from the
dataset.
7. Split the dataset into training and testing sets using train_test_split from sklearn.
8. Import LinearRegression from sklearn and initialize the regressor.
9. Fit the regressor to the training data.
10. Predict the dependent variable using the trained model on the test set.
11. Import statsmodels for backward elimination method.
12. Define a function for backward elimination of features based on p-values.
13. Set significance level (SL) for feature elimination.
14. Perform backward elimination iteratively to remove features with p-values above SL.
15. Print the summary of the OLS regression model after each elimination step.
16. Return the optimized feature set (X_Modeled) after backward elimination.
Code:

Dataset Link:https://www.kaggle.com/code/divan0/multiple-linear-regression/input

Step 1:

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd

import seaborn as sns

%matplotlib inline

#importing dataset using panda

dataset = pd.read_csv('../input/kc_house_data.csv')

#to see what my dataset is comprised of

dataset.head()

Step 2:

print(dataset.dtypes)
Step 3:

dataset = dataset.drop(['id','date'], axis = 1)

Step 4:

with sns.plotting_context("notebook",font_scale=2.5):

g = sns.pairplot(dataset[['sqft_lot','sqft_above','price','sqft_living','bedrooms']],

hue='bedrooms', palette='tab20',size=6)

g.set(xticklabels=[]);
Step 5:

X = dataset.iloc[:,1:].values

y = dataset.iloc[:,0].values

#splitting dataset into training and testing dataset

from sklearn.cross_validation import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 1/3, random_state = 0)

Step 6:

from sklearn.linear_model import LinearRegression

regressor = LinearRegression()

regressor.fit(X_train, y_train)

# Predicting the Test set results

y_pred = regressor.predict(X_test)
Step 7:

import statsmodels.formula.api as sm

def backwardElimination(x, SL):

numVars = len(x[0])

temp = np.zeros((21613,19)).astype(int)
for i in range(0, numVars):

regressor_OLS = sm.OLS(y, x).fit()

maxVar = max(regressor_OLS.pvalues).astype(float)

adjR_before = regressor_OLS.rsquared_adj.astype(float)

if maxVar > SL:

for j in range(0, numVars - i):

if (regressor_OLS.pvalues[j].astype(float) == maxVar):
 temp[:,j] = x[:, j]

x = np.delete(x, j, 1)

tmp_regressor = sm.OLS(y, x).fit()

adjR_after = tmp_regressor.rsquared_adj.astype(float)

if (adjR_before >= adjR_after):

x_rollback = np.hstack((x, temp[:,[0,j]]))

x_rollback = np.delete(x_rollback, j, 1)

print (regressor_OLS.summary())

return x_rollback

else:

continue

regressor_OLS.summary()

return x

SL = 0.05

X_opt = X[:, [0, 1, 2, 3, 4, 5,6,7,8,9,10,11,12,13,14,15,16,17]]

X_Modeled = backwardElimination(X_opt, SL)

Output:
Exp No: 05
Experimentation with Bias and Variance in Regression Models.
Date:

Aim:

The aim of this experiment is to understand and analyze the impact of bias and variance on
regression models. We will experiment with regression models both with and without bias to
evaluate their performance and characteristics.
Procedure:

Data Preparation

1. Load the dataset suitable for regression analysis.

2. Split the dataset into training and testing sets.
Model Building

1. Model A: Train a regression model without introducing bias (Low Bias, High Variance).
2. Model B: Train a regression model with high bias (High Bias, Low Variance).

Model Evaluation

1. Evaluate both models using metrics such as Mean Squared Error (MSE), R-squared, and
other relevant metrics.
2. Visualize the bias-variance tradeoff using plots like bias-variance decomposition plots
or learning curves.
Analysis

1. Compare the performance of Model A and Model B.

2. Understand how bias and variance impact the model's ability to generalize to unseen
data.
3. Discuss the trade-offs between bias and variance in regression models.
Program :

Step 1 :

# Importing necessary libraries

import numpy as np

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

from sklearn.preprocessing import PolynomialFeatures

from sklearn.metrics import mean_squared_error, r2_score

Step 2 :

# Generate synthetic dataset

np.random.seed(0)

X = np.sort(5 * np.random.rand(80, 1), axis=0)

y = np.sin(X).ravel() + np.random.randn(80) * 0.5

# Split dataset into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# Function to plot the data and regression line

def plot_data_and_model(X, y, y_pred, title):

plt.scatter(X, y, color='blue', label='Data')

plt.plot(X, y_pred, color='red', linewidth=2, label='Model')

plt.title(title)

plt.xlabel('X')

plt.ylabel('y')

plt.legend()

plt.show()
Step 3 :

# Model A: Linear Regression without Bias (High Variance)

model_A = LinearRegression()

model_A.fit(X_train, y_train)

y_pred_A = model_A.predict(X_test)

# Plot Model A

plot_data_and_model(X_test, y_test, y_pred_A, 'Model A (Low Bias, High Variance)')

# Model B: Polynomial Regression with High Bias (Low Variance)

degree = 3 # Polynomial degree for high bias

poly_features = PolynomialFeatures(degree=degree)

X_poly_train = poly_features.fit_transform(X_train)

X_poly_test = poly_features.transform(X_test)

model_B = LinearRegression()

model_B.fit(X_poly_train, y_train)

y_pred_B = model_B.predict(X_poly_test)

# Plot Model B

plot_data_and_model(X_test, y_test, y_pred_B, 'Model B (High Bias, Low Variance)')

Step 4 :

# Model Evaluation

def evaluate_model(y_true, y_pred):

mse = mean_squared_error(y_true, y_pred)

r2 = r2_score(y_true, y_pred)

print(f'Mean Squared Error (MSE): {mse:.2f}')

print(f'R-squared: {r2:.2f}')

print('Model A Evaluation:')

evaluate_model(y_test, y_pred_A)

print('\nModel B Evaluation:')

evaluate_model(y_test, y_pred_B)

Sample Output :

Model A Evaluation:
Mean Squared Error (MSE): 0.50
R-squared: 0.36

Model B Evaluation:
Mean Squared Error (MSE): 0.24
R-squared: 0.70
Exp No: 06
Classification using Perceptron with and without Bias.
Date:

Aim:

To classify a dataset from the UCI repository using a perceptron algorithm with and without
bias.
Procedure:

Data Preprocessing:

1. Load the dataset from the UCI repository.

2. Preprocess the data by handling missing values, normalization, or any other required
preprocessing steps.
Initialize Weights and Bias (if applicable):

1. Initialize weights w
2. w to small random values.
3. Initialize bias b
4. b to zero (if using bias).

Training:

1. For each data point in the dataset:

2. Compute the predicted output using the perceptron formula.
3. Update weights and bias based on the error (if any).
4. Repeat the training process until convergence or for a specified number of epochs.
Evaluation:

1. Calculate the accuracy, precision, recall, and F1-score of the perceptron classifier on
the test dataset.
2. Compare the performance of the perceptron with and without bias.
Program :

Perceptron with Bias :

class Perceptron:

def init (self, learning_rate, num_features):

self.learning_rate = learning_rate

self.weights = np.random.rand(num_features + 1) # +1 for bias

# Set bias weight to 1 (common practice)

self.weights[-1] = 1

def predict(self, x):

# Include bias term (append 1 to input vector)

x_with_bias = np.append(x, 1)
 activation = np.dot(self.weights, x_with_bias)

return 1 if activation > 0 else 0

def train(self, X, y, epochs):

# Similar training loop, including bias in weight update

for epoch in range(epochs):

for i in range(len(X)):

x = X[i]

x_with_bias = np.append(x, 1)

predicted = self.predict(x)

error = y[i] - predicted

self.weights += self.learning_rate * error * x_with_bias

Perceptron without Bias :

class Perceptron:

def init (self, learning_rate, num_features):

self.learning_rate = learning_rate

self.weights = np.random.rand(num_features + 1) # +1 for bias

# Set bias weight to 1 (common practice)

self.weights[-1] = 1
def predict(self, x):

# Include bias term (append 1 to input vector)

x_with_bias = np.append(x, 1)

activation = np.dot(self.weights, x_with_bias)

return 1 if activation > 0 else 0

def train(self, X, y, epochs):

# Similar training loop, including bias in weight update

for epoch in range(epochs):

for i in range(len(X)):

x = X[i]

x_with_bias = np.append(x, 1)

predicted = self.predict(x)
 error = y[i] - predicted

self.weights += self.learning_rate * error * x_with_bias

Output :

Perceptron without Bias:

Accuracy: 1.00, Precision: 1.00, Recall: 1.00, F1-score: 1.00
Perceptron with Bias:
Accuracy: 1.00, Precision: 1.00, Recall: 1.00, F1-score: 1.00

Result :

Since you're currently reviewing the lab manual and materials, the results section will likely be
filled out after completing the experiment. Here, you would report the performance metrics for
each model and discuss any observed differences in their effectiveness for classifying the
chosen dataset.This investigation will provide insights into the role of bias in a perceptron model
and its impact on classification accuracy.
Exp No: 07
Case Study on Ontology with Ethical Implications.
Date:

Aim:

The aim of this experiment is to analyze a case study involving ontology where ethical
considerations are at stake.
Procedure :
Preliminary Review:
1. Access the provided GitHub repository containing the case study.
2. Familiarize yourself with the documentation, ontology files, and related materials.
Ontology Examination:
1. Examine the ontology structure, including classes, properties, and relationships.
2. Identify the main concepts, entities, and their interconnections within the ontology.
Ethical Implications Assessment:

1. Evaluate the ontology for potential ethical issues related to data privacy, accuracy, bias,
accessibility, and consent.
2. Document any ethical concerns or implications identified during the assessment.
Data Privacy and Security Review:

1. Check the security measures implemented to protect sensitive medical information.

2. Assess the encryption methods, access controls, and data storage practices.
Accuracy and Validation Check:

1. Review the ontology's accuracy by comparing it with established medical knowledge

and literature.
2. Check for biases or inaccuracies that may affect the ontology's reliability and
usefulness.
Accessibility Evaluation:

1. Evaluate the ontology's accessibility features for different user groups, including
patients, healthcare providers, and researchers.
2. Check for accessibility barriers and identify potential improvements.
Informed Consent and Ethics Review:
1. Assess the process of obtaining informed consent for using patient data in the ontology.
2. Review the ethical considerations and compliance with relevant regulations and
guidelines.
Documentation and Transparency Assessment:

1. Review the documentation provided with the ontology, including design methodologies,
data sources, and usage guidelines.
2. Evaluate the transparency of the ontology's development process and decision-making.
Recommendations and Suggestions:
 1. Based on the assessment, provide recommendations to address identified ethical
implications and improve the ontology's quality, security, and accessibility.Document
suggestions for further research, validation, and collaboration with stakeholders.
Conclusion and Summary:

2. Summarize the findings from the ontology examination and ethical implications
assessment. Conclude with a comprehensive overview of the case study's strengths,
weaknesses, and areas for improvement.
Program :

from rdflib import Graph, Literal, Namespace, RDF, RDFS

# Create a Graph

g = Graph()

# Define Namespaces

ex = Namespace("http://example.org/ontology#")

# Define Classes

g.add((ex.MedicalCondition, RDF.type, RDFS.Class))

g.add((ex.MedicalCondition, RDFS.label, Literal("Medical Condition")))

g.add((ex.Treatment, RDF.type, RDFS.Class))

g.add((ex.Treatment, RDFS.label, Literal("Treatment")))

# Define Properties

g.add((ex.hasTreatment, RDF.type, RDF.Property))

g.add((ex.hasTreatment, RDFS.domain, ex.MedicalCondition))

g.add((ex.hasTreatment, RDFS.range, ex.Treatment))

g.add((ex.hasTreatment, RDFS.label, Literal("has Treatment")))

g.add((ex.isAssociatedWith, RDF.type, RDF.Property))

g.add((ex.isAssociatedWith, RDFS.domain, ex.MedicalCondition))

g.add((ex.isAssociatedWith, RDFS.range, ex.MedicalCondition))

g.add((ex.isAssociatedWith, RDFS.label, Literal("is Associated With")))

# Individuals

g.add((ex.Diabetes, RDF.type, ex.MedicalCondition))

g.add((ex.Diabetes, RDFS.label, Literal("Diabetes")))

g.add((ex.InsulinTherapy, RDF.type, ex.Treatment))

g.add((ex.InsulinTherapy, RDFS.label, Literal("Insulin Therapy")))

# Relationships
g.add((ex.Diabetes, ex.hasTreatment, ex.InsulinTherapy))

g.add((ex.Diabetes, ex.isAssociatedWith, ex.Diabetes))

# Serialize and print the graph (Turtle format)

print(g.serialize(format="turtle").decode("utf-8"))
Output :

@prefix ex: <http://example.org/ontology#> .

@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
ex:Diabetes a ex:MedicalCondition ;
rdfs:label "Diabetes" .
ex:InsulinTherapy a ex:Treatment ;
rdfs:label "Insulin Therapy" .
ex:MedicalCondition a rdfs:Class ;
rdfs:label "Medical Condition" .
ex:Treatment a rdfs:Class ;
rdfs:label "Treatment" .
ex:hasTreatment a rdf:Property ;
rdfs:domain ex:MedicalCondition ;
rdfs:label "has Treatment" ;
rdfs:range ex:Treatment .
ex:isAssociatedWith a rdf:Property ;
rdfs:domain ex:MedicalCondition ;
rdfs:label "is Associated With" ;
rdfs:range ex:MedicalCondition .
ex:Diabetes ex:hasTreatment ex:InsulinTherapy ;
ex:isAssociatedWith ex:Diabetes .