0% found this document useful (0 votes)
13 views14 pages

DWM Final Exps

Uploaded by

manujamanav01
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
13 views14 pages

DWM Final Exps

Uploaded by

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

DWM

EXP 1 PERFECT

EXP 2 PERFECT

EXP 3 PERFECT

EXP 4 PERFECT

EXP 4 EXCEL

EXP 5

def predict(test, p_pass, p_fail):

p_pass_result = p_study.get(test[0], 0) * p_sports.get(test[1], 0) * p_grade.get(test[2], 0) * p_pass

p_fail_result = p_study.get(test[0], 0) * p_sports.get(test[1], 0) * p_grade.get(test[2], 0) * p_fail

sum_prob = p_pass_result + p_fail_result

if sum_prob == 0:

print("Prediction: Fail")

else:

p_pass_result = p_pass_result / sum_prob

p_fail_result = p_fail_result / sum_prob

print("Probability of passing: ", p_pass_result)

print("Probability of failing: ", p_fail_result)

if p_pass_result > p_fail_result:

print("Prediction: Pass")

else:

print("Cannot make a prediction due to insufficient data.")

def testInput():

string = input("Enter comma-separated test tuple (e.g., 'Good','High','A'): ")

test = string.split(',')

return test

data = [

['Good', 'High', 'A', 'Pass'],

['Good', 'Low', 'B', 'Pass'],


['Poor', 'High', 'C', 'Fail'],

['Poor', 'Low', 'B', 'Fail'],

['Good', 'Low', 'A', 'Pass'],

['Good', 'High', 'C', 'Pass'],

p_study = {}

p_sports = {}

p_grade = {}

p_pass_count = 0

p_fail_count = 0

for row in data:

study, sports, grade, result = row

if result == "Pass":

p_study[study] = p_study.get(study, 0) + 1

p_sports[sports] = p_sports.get(sports, 0) + 1

p_grade[grade] = p_grade.get(grade, 0) + 1

p_pass_count += 1

else:

p_fail_count += 1

total_students = len(data)

p_pass = p_pass_count / total_students

p_fail = p_fail_count / total_students

for key in p_study:

p_study[key] /= total_students

for key in p_sports:

p_sports[key] /= total_students
for key in p_grade:

p_grade[key] /= total_students

test = testInput()

predict(test, p_pass, p_fail)

EXP 6 PERFECT

EXP 7

import java.io.*;

class Kmean {

public static void main(String args[]) {

int N = 9;

int arr[] = { 2, 4, 10, 12, 3, 20, 30, 11, 25 }; // initial data

int i, m1, m2, a, b, n = 0;

boolean flag = true;

float sum1 = 0, sum2 = 0;

a = arr[0];

b = arr[1];

m1 = a;

m2 = b;

int cluster1[] = new int[9];

int cluster2[] = new int[9];

int k, j; // Declare k and j outside the loop

for (i = 0; i < 9; i++)

System.out.print(arr[i] + "\t");

System.out.println();
do {

n++;

k = 0;

j = 0;

for (i = 0; i < 9; i++) {

if (Math.abs(arr[i] - m1) <= Math.abs(arr[i] - m2)) {

cluster1[k] = arr[i];

k++;

} else {

cluster2[j] = arr[i];

j++;

sum1 = 0;

sum2 = 0;

for (i = 0; i < k; i++)

sum1 = sum1 + cluster1[i];

for (i = 0; i < j; i++)

sum2 = sum2 + cluster2[i];

a = m1;

b = m2;

m1 = Math.round(sum1 / k);

m2 = Math.round(sum2 / j);

if (m1 == a && m2 == b)

flag = false;
else

flag = true;

System.out.println("After iteration " + n + " , cluster 1 :\n");

for (i = 0; i < k; i++) {

if (cluster1[i] != 0) {

System.out.print(cluster1[i] + "\t");

System.out.println("\n");

System.out.println("After iteration " + n + " , cluster 2 :\n");

for (i = 0; i < j; i++) {

if (cluster2[i] != 0) {

System.out.print(cluster2[i] + "\t");

} while (flag);

System.out.println("Final cluster 1 :\n");

for (i = 0; i < k; i++) {

if (cluster1[i] != 0) {

System.out.print(cluster1[i] + "\t");

System.out.println();

System.out.println("Final cluster 2 :\n");


for (i = 0; i < j; i++) {

if (cluster2[i] != 0) {

System.out.print(cluster2[i] + "\t");

EXP 8

import numpy as np

import matplotlib.pyplot as plt

from scipy.cluster.hierarchy import dendrogram, linkage

# Sample data

data = np.array([[1, 2], [2, 3], [8, 7], [8, 8]])

# Function to compute pairwise distances

def compute_distances(data):

n = len(data)

distances = np.zeros((n, n))

for i in range(n):

for j in range(n):

distances[i, j] = np.sqrt(np.sum((data[i] - data[j]) ** 2))

return distances

# Function for single linkage clustering


def single_linkage(data):

distances = compute_distances(data)

linkage_matrix = linkage(distances, method='single')

return linkage_matrix

# Function for complete linkage clustering

def complete_linkage(data):

distances = compute_distances(data)

linkage_matrix = linkage(distances, method='complete')

return linkage_matrix

# Function for average linkage clustering

def average_linkage(data):

distances = compute_distances(data)

linkage_matrix = linkage(distances, method='average')

return linkage_matrix

# Function to display a dendrogram

def display_dendrogram(linkage_matrix, linkage_type):

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

dendrogram(linkage_matrix)

plt.title(f'{linkage_type.capitalize()} Linkage Dendrogram')

plt.show()

# Function to calculate minimum, maximum, and average linkage distances

def calculate_distances(linkage_matrix):

min_distance = linkage_matrix[0, 2]

max_distance = linkage_matrix[-1, 2]

avg_distance = np.mean(linkage_matrix[:, 2])

return min_distance, max_distance, avg_distance


# User input for linkage type

linkage_type = input("Choose linkage type (single, complete, or average): ").lower()

# Ensure the user's choice is one of the accepted options

if linkage_type not in ['single', 'complete', 'average']:

print("Invalid linkage type. Please choose from 'single', 'complete', or 'average'.")

else:

if linkage_type == 'single':

linkage_matrix = single_linkage(data)

elif linkage_type == 'complete':

linkage_matrix = complete_linkage(data)

else:

linkage_matrix = average_linkage(data)

display_dendrogram(linkage_matrix, linkage_type)

min_dist, max_dist, avg_dist = calculate_distances(linkage_matrix)

print(f"Minimum Linkage Distance: {min_dist}")

print(f"Maximum Linkage Distance: {max_dist}")

print(f"Average Linkage Distance: {avg_dist}")

EXP 9

from collections import Counter


from itertools import combinations

data = [
['T100', ['I1', 'I2', 'I5']],
['T200', ['I2', 'I4']],
['T300', ['I2', 'I3']],
['T400', ['I1', 'I2', 'I4']],
['T500', ['I1', 'I3']],
['T600', ['I2', 'I3']],
['T700', ['I1', 'I3']],
['T800', ['I1', 'I2', 'I3', 'I5']],
['T900', ['I1', 'I2', 'I3']]
]

init = []
for i in data:
for q in i[1]:
if(q not in init):
init.append(q)
init = sorted(init)

# Minimum support threshold


sp = 0.4
s = int(sp * len(init))

c = Counter()
for i in init:
for d in data:
if i in d[1]:
c[i] += 1

print("C1:")
for i in c:
print(f"{[i]}: {c[i]}")
print()

l = Counter()
for i in c:
if c[i] >= s:
l[frozenset([i])] += c[i]

print("L1:")
for i in l:
print(f"{list(i)}: {l[i]}")
print()

pl = l
pos = 1
for count in range(2, 1000):
nc = set()
temp = list(l)
for i in range(0, len(temp)):
for j in range(i + 1, len(temp)):
t = temp[i].union(temp[j])
if len(t) == count:
nc.add(temp[i].union(temp[j]))
nc = list(nc)
c = Counter()
for i in nc:
c[i] = 0
for q in data:
temp = set(q[1])
if i.issubset(temp):
c[i] += 1

print(f"C{count}:")
for i in c:
print(f"{list(i)}: {c[i]}")
print()

l = Counter()
for i in c:
if c[i] >= s:
l[i] += c[i]

print(f"L{count}:")
for i in l:
print(f"{list(i)}: {l[i]}")
print()

if len(l) == 0:
break
pl = l
pos = count

print("Result:")
print(f"L{pos}:")
for i in pl:
print(f"{list(i)}: {pl[i]}")
print()

for l in pl:
c = [frozenset(q) for q in combinations(l, len(l) - 1)]
mmax = 0
for a in c:
b=l-a
ab = l
sab = 0
sa = 0
sb = 0
for q in data:
temp = set(q[1])
if a.issubset(temp):
sa += 1
if b.issubset(temp):
sb += 1
if ab.issubset(temp):
sab += 1
print(f"{list(a)} -> {list(b)} = {sab / sa * 100}%")
print(f"{list(b)} -> {list(a)} = {sab / sb * 100}%")
print()

EXP 10

# Step 1: Define a different dataset

data = [

["A", "B", "C"],

["B", "C", "D"],

["C", "A"],

["D", "A", "B"],

["E", "D"],

# Step 2: Initialize page rank for each webpage


web_pages = {}

for row in data:

web_pages[row[0]] = 1

# Damping factor

damping_factor = 0.85

# Step 5: Repeat until convergence

convergence_criteria = 0.0001

delta = 1

while delta > convergence_criteria:

new_ranks = {}

for page, rank in web_pages.items():

total_links = sum(1 for row in data if page in row[1:])

linked_pages = [row[0] for row in data if page in row[1:]]

linked_rank = sum(web_pages[other_page] / sum(1 for row in data if


other_page in row) for other_page in linked_pages)

new_rank = (1 - damping_factor) + damping_factor * linked_rank

new_ranks[page] = new_rank

delta = sum(abs(new_ranks[page] - web_pages[page]) for page in


web_pages)

web_pages = new_ranks
# Step 6: Find the page with the highest rank

highest_page = max(web_pages, key=web_pages.get)

# Store the results in a list of lists

table = [["Page", "Page Rank"]]

for page, rank in web_pages.items():

table.append([page, rank])

# Print the results in a table format

for row in table:

print(row)

print(f"\nWebpage with the highest Page Rank: {highest_page}")

You might also like