Soft Computing Lab Manual
Index
1. Experiment 1: Implement Rough Sets and Fuzzy Logic
2. Experiment 2: Implement Discretization on a Continuous Dataset
3. Experiment 3: Implement Decisive Discernibility Matrix and Function for Decision
Rules
4. Experiment 4: Write and Implement Pseudocode for Discretization in Rough Sets
5. Experiment 5: Implement Arithmetic Operations in Fuzzy Sets
6. Experiment 6: Implement Genetic Algorithm for Function Optimization
7. Experiment 7: Implement Ant Colony Optimization for Pathfinding
Experiment 1: Implement Rough Sets and Fuzzy Logic
Theory:
Rough Sets are a mathematical tool to deal with vagueness and uncertainty, introduced by Zdzisław
Pawlak. The core idea is to approximate a set by a pair of lower and upper bounds using equivalence
relations on the data. Objects that surely belong to a concept form the lower approximation, while
objects that possibly belong form the upper approximation.
Fuzzy Logic, developed by Lotfi Zadeh, extends classical logic by allowing truth values between 0 and
1. A fuzzy set represents data where elements have degrees of membership. This logic is useful when
boundaries between concepts are not crisp.
Python Code:
# Rough Set Example
def lower_upper_approx(universe, target_set, equivalence_classes):
lower = set()
upper = set()
for eq_class in equivalence_classes:
if eq_class.issubset(target_set):
lower.update(eq_class)
if eq_class & target_set:
upper.update(eq_class)
return lower, upper
U = {1, 2, 3, 4, 5, 6}
target = {1, 2, 3}
equivalence = [{1, 2}, {3, 4}, {5, 6}]
lower, upper = lower_upper_approx(U, target, equivalence)
print("Lower Approximation:", lower)
print("Upper Approximation:", upper)
# Fuzzy Set Operations
A = {'cold': 0.3, 'warm': 0.7, 'hot': 0.9}
B = {'cold': 0.4, 'warm': 0.6, 'hot': 0.8}
# Intersection (min)
intersection = {x: min(A[x], B[x]) for x in A}
# Union (max)
union = {x: max(A[x], B[x]) for x in A}
print("Fuzzy Intersection:", intersection)
print("Fuzzy Union:", union)
Experiment 2: Implement Discretization on a Continuous Dataset
Theory:
Discretization is a preprocessing technique in which continuous data attributes are divided into
discrete intervals or categories. It is particularly important in rough set theory where attribute values
need to be categorical.
Python Code:
import pandas as pd
import numpy as np
def equal_width_discretization(data, bins):
return pd.cut(data, bins=bins, labels=False)
data = pd.Series([2.5, 3.6, 4.1, 5.0, 6.7, 7.8])
discrete_data = equal_width_discretization(data, 3)
print("Discretized Data:\n", discrete_data)
Experiment 3: Implement Decisive Discernibility Matrix and Function for Decision Rules
Theory:
The discernibility matrix is a table that identifies which attributes differentiate objects with different
decisions. The discernibility function, derived from this matrix, is expressed in disjunctive normal
form (DNF) and helps in determining reducts and decision rules.
Python Code:
import numpy as np
def discernibility_matrix(data, decision):
n = len(data)
matrix = [[[] for _ in range(n)] for _ in range(n)]
for i in range(n):
for j in range(i+1, n):
if decision[i] != decision[j]:
matrix[i][j] = [attr for attr in range(len(data[0])) if data[i][attr] != data[j][attr]]
return matrix
data = [[1, 0], [1, 1], [0, 1]]
decision = [1, 1, 0]
dm = discernibility_matrix(data, decision)
print("Discernibility Matrix:")
for row in dm:
print(row)
Experiment 4: Write and Implement Pseudocode for Discretization in Rough Sets
Theory:
In rough set theory, discretization is required to transform continuous attributes into intervals. This
enables equivalence class formation and approximation calculations. Proper discretization enhances
rule generation and accuracy.
Pseudocode:
1. Sort the dataset by the selected attribute and the decision.
2. Identify boundary points where decision changes.
3. Calculate midpoints of these boundaries to find cut points.
4. Assign intervals or bins based on these cut points.
Python Code:
import pandas as pd
def find_cut_points(df, attribute, decision_attribute):
sorted_df = df[[attribute, decision_attribute]].sort_values(by=attribute).reset_index(drop=True)
cut_points = []
for i in range(len(sorted_df) - 1):
if sorted_df.loc[i, decision_attribute] != sorted_df.loc[i + 1, decision_attribute]:
val1 = sorted_df.loc[i, attribute]
val2 = sorted_df.loc[i + 1, attribute]
cut_points.append((val1 + val2) / 2.0)
return sorted(set(cut_points))
def discretize_attribute(value, cut_points):
for i, cp in enumerate(cut_points):
if value <= cp:
return f"bin_{i}"
return f"bin_{len(cut_points)}"
def discretize_dataset(df, attributes, decision_attribute):
discretized_df = df.copy()
for attribute in attributes:
cuts = find_cut_points(df, attribute, decision_attribute)
discretized_df[attribute] = df[attribute].apply(lambda x: discretize_attribute(x, cuts))
return discretized_df
# Example usage
data = {
'Attribute1': [1.2, 2.5, 3.1, 3.8, 4.5, 5.2],
'Attribute2': [10, 20, 20, 30, 40, 50],
'Decision': ['A', 'A', 'B', 'B', 'C', 'C']
df = pd.DataFrame(data)
attributes = ['Attribute1', 'Attribute2']
discretized_df = discretize_dataset(df, attributes, 'Decision')
print(discretized_df)
Experiment 5: Implement Arithmetic Operations in Fuzzy Sets
Theory:
Fuzzy set arithmetic enables combining or comparing fuzzy values using operations such as union,
intersection, complement, addition, subtraction, multiplication, and division.
Union (A ∪ B): max(μA(x), μB(x))
Intersection (A ∩ B): min(μA(x), μB(x))
Complement: 1 - μA(x)
Addition: min(1, μA(x) + μB(x))
Subtraction: max(0, μA(x) - μB(x))
Multiplication: μA(x) * μB(x)
Division: μA(x) / μB(x), provided μB(x) ≠ 0
Python Code:
import numpy as np
U = np.linspace(0, 10, 11)
A = {x: round(np.exp(-abs(x - 3) / 3), 2) for x in U}
B = {x: round(np.exp(-abs(x - 7) / 2), 2) for x in U}
def fuzzy_add(A, B):
return {x: min(1, A[x] + B[x]) for x in A}
def fuzzy_subtract(A, B):
return {x: max(0, A[x] - B[x]) for x in A}
def fuzzy_multiply(A, B):
return {x: A[x] * B[x] for x in A}
def fuzzy_divide(A, B):
return {x: A[x] / B[x] if B[x] != 0 else 0 for x in A}
print("Addition:", fuzzy_add(A, B))
print("Subtraction:", fuzzy_subtract(A, B))
print("Multiplication:", fuzzy_multiply(A, B))
print("Division:", fuzzy_divide(A, B))
Experiment 6: Implement Genetic Algorithm for Function Optimization
Theory:
Genetic Algorithms (GAs) simulate natural evolution. They maintain a population of candidate
solutions and evolve them through:
Selection based on fitness
Crossover for combination
Mutation for diversity
Python Code:
import random
def fitness(x):
return x ** 2
def create_chromosome():
return random.randint(0, 31)
def crossover(p1, p2):
point = random.randint(1, 4)
mask = (1 << point) - 1
return (p1 & mask) | (p2 & ~mask & 0b11111)
def mutate(chrom, rate=0.1):
if random.random() < rate:
bit = 1 << random.randint(0, 4)
chrom ^= bit
return chrom
def genetic_algorithm(generations=50, size=10):
pop = [create_chromosome() for _ in range(size)]
for g in range(generations):
pop = sorted(pop, key=fitness, reverse=True)
print(f"Gen {g}: Best = {pop[0]}, f(x) = {fitness(pop[0])}")
next_gen = pop[:size//2]
while len(next_gen) < size:
p1, p2 = random.sample(next_gen, 2)
child = mutate(crossover(p1, p2))
next_gen.append(child)
pop = next_gen
return pop[0]
best = genetic_algorithm()
print(f"Best Solution: x = {best}, f(x) = {fitness(best)}")
Experiment 7: Implement Ant Colony Optimization for Pathfinding Problem
Theory:
Ant Colony Optimization (ACO) is a probabilistic technique that mimics the behavior of ants laying
down pheromone trails to discover shortest paths in a graph.
Python Code:
import numpy as np
def ant_colony_optimization(dist, n_ants=5, n_iter=10, alpha=1, beta=2, evap=0.5):
n = dist.shape[0]
pheromone = np.ones_like(dist)
best_path = None
best_length = float('inf')
for _ in range(n_iter):
for _ in range(n_ants):
path = [0]
while len(path) < n:
i = path[-1]
probs = [(pheromone[i][j] ** alpha) * ((1 / dist[i][j]) ** beta) if j not in path else 0 for j in
range(n)]
probs = np.array(probs)
probs = probs / probs.sum()
path.append(np.random.choice(range(n), p=probs))
length = sum(dist[path[i]][path[i+1]] for i in range(n-1)) + dist[path[-1]][path[0]]
if length < best_length:
best_length = length
best_path = path
pheromone *= (1 - evap)
for i in range(n - 1):
pheromone[path[i]][path[i+1]] += 1 / length
return best_path, best_length
matrix = np.array([[0, 2, 2, 5], [2, 0, 3, 4], [2, 3, 0, 2], [5, 4, 2, 0]])
path, length = ant_colony_optimization(matrix)
print("Best path:", path)
print("Shortest distance:", length)
