<jupyter_start><jupyter_text>Assignment 1  Fuzzy set operations<jupyter_code>A= [(1,0.8),(2,0.7),(3,0.1),(4,1.0),(5,0.9),(6,0.3)]
B= [(1,0.3),(2,0.4),(3,0.4),(4,1),(5,0),(6,0)]
def algSum(A,B):
    sum=[]
    
    for i in A:
        for j in B:
            if i[0]==j[0]:
                sum.append((i[0],(i[1]+j[1]-i[1]*j[1])))
    return sum

                         
def cart(A,B):
    c=[]
    
    for i in A:
        for j in B:
            c.append(((i[0],j[0]), min(i[1],j[1])))
    return c
  
    
def union(A,B):
    union=[]

    for i in A:
        for j in B:
            if i[0] == j[0]:
                union.append((i[0],max(i[1],j[1])))

    return union
     
def intersect(A,B):
    intersection=[]
    for i in A:
        for j in B:
            if i[0] == j[0]:
                intersection.append((i[0],min(i[1],j[1])))
    return intersection
      
    
def complement(A):
    A_=[]

    for i in A:
        A_.append((i[0],1-i[1]))
    return A_

def diff(A,B):
    d=[]
    B_=complement(B)
    for i in A:
        for j in B_:
            if i[0]==j[0]:
                d.append((i[0],min(i[1],j[1])))
    return d            
print("Set A : ", A,"\n")
print("Set B : ", B,"\n")

asum=algSum(A,B)
print("Algebraic sum: ",asum,"\n")

dif=diff(A,B)
print("Algebraic difference: ",dif,"\n")

c=cart(A,B)
print("Cartesian product: ",c,"\n")

u=union(A,B)
print("Union: ",u,"\n")

inter=intersect(A,B)
print("Intersection: ", inter,"\n")

com=complement(A)
print("Complement of A: ",com,"\n")

com=complement(B)
print("Complement of B: ",com,'\n')

print("complement(A) union complement(B): ", union(complement(A),complement(B)),"\n")
print("complement(A) intersection complement(B): ", intersect(complement(A),complement(B)))<jupyter_output>Set A :  [(1, 0.8), (2, 0.7), (3, 0.1), (4, 1.0), (5, 0.9), (6, 0.3)] 

Set B :  [(1, 0.3), (2, 0.4), (3, 0.4), (4, 1), (5, 0), (6, 0)] 

Algebraic sum:  [(1, 0.8600000000000001), (2, 0.8200000000000001), (3, 0.45999999999999996), (4, 1.0), (5, 0.9), (6, 0.3)] 

Algebraic difference:  [(1, 0.7), (2, 0.6), (3, 0.1), (4, 0), (5, 0.9), (6, 0.3)] 

Cartesian product:  [((1, 1), 0.3), ((1, 2), 0.4), ((1, 3), 0.4), ((1, 4), 0.8), ((1, 5), 0), ((1, 6), 0), ((2, 1), 0.3), ((2, 2), 0.4), ((2, 3), 0.4), ((2, 4), 0.7), ((2, 5), 0), ((2, 6), 0), ((3, 1), 0.1), ((3, 2), 0.1), ((3, 3), 0.1), ((3, 4), 0.1), ((3, 5), 0), ((3, 6), 0), ((4, 1), 0.3), ((4, 2), 0.4), ((4, 3), 0.4), ((4, 4), 1.0), ((4, 5), 0), ((4, 6), 0), ((5, 1), 0.3), ((5, 2), 0.4), ((5, 3), 0.4), ((5, 4), 0.9), ((5, 5), 0), ((5, 6), 0), ((6, 1), 0.3), ((6, 2), 0.3), ((6, 3), 0.3), ((6, 4), 0.3), ((6, 5), 0), ((6, 6), 0)] 

Union:  [(1, 0.8), (2, 0.7), (3, 0.4), (4, 1.0), (5, 0.9), (6, 0.3)] 

Intersection:  [(1, 0.3), (2, 0.4), (3, 0.1[...]<jupyter_text>Assignment 2  Triangular membership function<jupyter_code>a=float(input("Enter a: "))
b=float(input("Enter b: "))
m=(a+b)/2
X=(a,m,b)
Y=(0,1,0)
plt.plot(X,Y)
plt.show()
x=float(input("Enter the element: "))
if x<=a:
    mem = 0
elif x>a and x<=m:
    mem = (x-a)/(m-a)
elif x>m and x<b:
    mem = (b-x)/(b-m)
else:
    mem=0
    
print("Membership : ",mem)<jupyter_output>Enter the element: 2.5
Membership :  0.25<jupyter_text>Trapezoidal membership function<jupyter_code>print("Enter a: ")
a=input()
a=float(a)
print("Enter b: ")
b=input()
b=float(b)
print("Enter c: ")
c=input()
c=float(c)
print("Enter d: ")
d=input()
d=float(d)
X=(a,b,c,d)
Y=(0,1,1,0)
plt.plot(X,Y)
plt.show()
x=float(input("Enter the element: "))
if x <= a:
    mem = 0
elif x > a and x <= b :
    mem = (x - a) / (b - a)
elif x > b and x < c :
    mem = 1
elif x >= c and x <= d :
    mem = (d - x) / (d - c)
else :    
    mem=0
    
print("Membership :",mem)<jupyter_output>Enter the element: 4
Membership : 0.75<jupyter_text>Gaussian Distribution<jupyter_code>c=float(input("Enter the mean: "))
var=float(input("Enter the variance: "))
sig=np.sqrt(var)
x_axis = np.arange(-10, 10, 0.001)
#mean = c, Standard deviation = sig.
plt.plot(x_axis, norm.pdf(x_axis,c,sig))
plt.show()
x=float(input("Enter the element: "))

mem = np.exp((-1*(x-c)**2)/(2*var))
    
print("membership: ",mem)<jupyter_output>Enter the element: 2.4
membership:  0.23692775868212176<jupyter_text>Generalized bell function<jupyter_code>x= np.arange(20)
a=float(input("Enter a:"))
b=float(input("Enter b:"))
c=float(input("Enter c:"))
mf=skfuzzy.gbellmf(x,a,b,c)
plt.plot(x,mf)
plt.show()
x=float(input("Enter the element:"))
mem = 1/(1+abs((x-c)/a)**(2 * b))
print("Membership: ", mem)<jupyter_output>Enter a:5
Enter b:3.5
Enter c:10<jupyter_text>Sigmoid function<jupyter_code>a = float(input("Enter a :"))
c = float(input("Enter c :"))
x=np.arange(20)

sig = skfuzzy.membership.sigmf(x,a,c)
plt.plot(x,sig)
plt.show()
x=float(input("Enter the member : "))
mem= 1/(1+np.exp(-1*a*(x-c)))
print("Membership : ",mem)
x=float(input("Enter the member : "))
mem=1/(1+np.exp(-1*a*(x-c)))
print('Membership : ', mem)<jupyter_output>Enter the member : 9
Membership :  0.9820137900379085<jupyter_text>Assignment 3  Q. Find applications where you find fuzzy logic to be suitableFuzzy logic as I understand is a form of reasoning where the reasoning may be true, somewhat true, very much true and so on. It is the reasoning for the statements or hypothesis that can not be quantified or measured. Apart from this, fuzzy logic differs from the conventional logic in notations too. A simple and fairly easy example that will distinguish the two and would let us know the need of fuzzy logic is as follows:So this application of fuzzy logic is in 'Automated braking system' in vehicles. If we think of the normal logic i.e. the if-then rules then we may specify as, say "If the distance from the vehicle ahead is less than equal to 5 meters then apply brakes".Here, the car would stop as soon as it is in the pre-defined range but there might be situations when we do not require breakes as the speed of the vechicles is slow or on an express highway where the vehicles are at a pretty high speed and hence the distance could be maintained. In that condiction too, the system would stop the car applying the complete strength of the braking system. This is crisp, "Either brakes or no brakes at all".Whereas in the same scenario, if we apply fuzzy logic then, we can assign membership over a range of values that denote the distance between two vehicles.Say, if the distance is 15 meters, the membership is 0.2. Hence the brakes will be applied slightly just to decrease a certain amount of speed that will prevent the accident and maintain a safe distance. Similarly, as the distance decreases, the membership of the pressure applied on brakes becomes higher.This way, fuzzy logic comes handy in automated braking system. There are numerous other applications as well. Like in Particle physics, neuro-science etc. For simpler examples we could consider the braking system and for the supply of oxygen to a patients as the condition gets more and more critical etc.  Assignment 4  Q. Scenarios where Gaussian Membership function can be applied.In general, A Gaussian curve/Normal distriburtion curve depicts a smooth symmetrical curve centered at the mean(μ) and spread over a varivance(σ). Hence the Gaussian membership function could be associated to some problem that requires a ascent in membership in the first half and a symmetric descent in the other.For simpler examples, if we talk about attaining youth. Though being "young" is relative concept and no specified age define a boundry with a flag saying "youth". Still, when a child is born, their membership of being considered in the youth bracket is very low. The membership increases with the age of the child and reaches the peak in the middle ages. And then slowly the membership starts to decrease.Further there are a lot of applications of fuzzy logic and Gaussian membership function in many fields of study. For instance, I few of the research works I have encountered, a paper by Reddy et al. applied fuzzy logic and used the Gaussian membership fucntion to propose a fuzzy approach for COCOMO's effort estimation[1].Gaussian membership function also has uses in design of neuro-fuzzy circuits as shown in the research by Basterretxa et al[2]. Gaussian MF can also be used for tuning the parameters of fuzzy models as carred out in the research work by Pieczyński et al[3].A fuzzy-neural sliding-mode control system was developed to control power electronic converters by Cheng et al. An asymmetric fuzzy neural network is utilized to mimic an ideal controller. It is applied to control a pulsewidth-modulation-based forward dc-dc converter. Experimental results show that the proposed FNSM control system is found to achieve favorable regulation performances even under input-voltage and load-resistance variations.[4]It could also be used in time series predictions, like in the work proposed by <NAME> Song. They proposed a dynamic evolving neural-fuzzy inference system.[5]References:[1] https://www.researchgate.net/publication/42804622_An_Improved_Fuzzy_Approach_for_COCOMO's_Effort_Estimation_Using_Gaussian_Membership_Function[2]http://digital-library.theiet.org/content/journals/10.1049/el_20063712[3]https://ieeexplore.ieee.org/abstract/document/4156354/[4]https://ieeexplore.ieee.org/abstract/document/4156354/[5]https://ieeexplore.ieee.org/abstract/document/995117/  Assignment 5  Composition<jupyter_code>def mmcomp(A,B):
    
    a=A.shape
    b=B.shape
    c=[]
    for i in A:
        for j in B.T:
            c.append(max(np.minimum(i,j)))
    return c        
    
def mpcomp(A,B):
    a=A.shape
    b=B.shape
    c=[]
    for i in A:
        for j in B.T:
            c.append(max(i*j))
    return c        
    
R=np.array([[0.4,0.6,0],[0.9,1,0.1]])
S=np.array([[0.5,0.8],[0.1,1],[0,0.6]])
print("R :",R,"\n")
print("S :",S,"\n")
#print(np.matmul(R,S))
mm=np.array(mmcomp(R,S))
print("The max-min composition of R and S: \n",mm.reshape(2,2),"\n")
mp=np.array(mpcomp(R,S))
print("The max-product composition of R and S: \n",mp.reshape(2,2),"\n")<jupyter_output>The max-min composition of R and S: 
 [[0.4 0.6]
 [0.5 1. ]] 

The max-product composition of R and S: 
 [[0.2  0.6 ]
 [0.45 1.  ]]<jupyter_text>Assignment 6<jupyter_code>temperature = [(16,0.4),(18,0.8),(20,1),(22,1),(24,0.8),(26, 0.5)]
humidity = [(0,0.2),(20,0.8),(40,1.0),(60,0.6),(80,0.2)]

threshold_temp = float(input('Enter temperature threshold '))
threshold_humid = float(input('Enter humidity threshold '))

accepted_temperature = []
accepted_humidity = []

for t in temperature:
    if t[1] >= threshold_temp:
        accepted_temperature.append((t))
        
for h in humidity:
    if h[1] >= threshold_humid:
        accepted_humidity.append((h))    
        
print("Accepted temperature: ", temperature)
print("Accepted humidity: ", humidity)

print("------------------------------------------------------------------------------------------")

print("Accepted humidity or accepted temperature:")
cp = cart(accepted_humidity,accepted_temperature)
cp1 = []
for i in cp:
    cp1.append(i[0])
df = pd.DataFrame(data=cp1, columns=["Humidity","Temperature"])
print(df)<jupyter_output>Enter temperature threshold 0.7
Enter humidity threshold 0.7
Accepted temperature:  [(16, 0.4), (18, 0.8), (20, 1), (22, 1), (24, 0.8), (26, 0.5)]
Accepted humidity:  [(0, 0.2), (20, 0.8), (40, 1.0), (60, 0.6), (80, 0.2)]
------------------------------------------------------------------------------------------
Accepted humidity or accepted temperature:
   Humidity  Temperature
0        20           18
1        20           20
2        20           22
3        20           24
4        40           18
5        40           20
6        40           22
7        40           24<jupyter_text>Assignment 7<jupyter_code>x=float(input("Enter the element:"))
mem_young = 1/(1+abs((x-0)/20)**(2 * 2))
mem_old = 1/(1+abs((x-100)/30)**(2 * 3))
print(' 1. More or less young --> {}'.format(np.sqrt(mem_young))) # dialte

print(' 2. Not young and not old --> ', min((1-mem_young),(1-mem_old)))

print(' 3. Young but not too young --> ', min(mem_young,(1-(mem_young)**2)))

print(' 4. Extremely old --> {}'.format((mem_old)**2))<jupyter_output>Enter the element:40
 1. More or less young --> 0.24253562503633297
 2. Not young and not old -->  0.9411764705882353
 3. Young but not too young -->  0.058823529411764705
 4. Extremely old --> 0.0002366863905325444<jupyter_text>Assignment 8<jupyter_code>R1 = np.array([[0.4,0.6,0,0.74],[0.9,1,0.6,0.1],[0.7,0.1,1,0]]) # 3 x 4
R2 = np.array([[0.5,0.8],[0.1,1],[0,0.6],[0.2,0.65]])  # 4 x 2

M = mmcomp(R1,R2) # calling the min-max method defined earlier.
M = np.array(M)
M = M.reshape(3,2) # 3 x 2
print(M)

# now for x = 3 and z = one,
print("The min-max composition for (3,one) is", M[2][0])<jupyter_output>[[0.4  0.65]
 [0.5  1.  ]
 [0.5  0.7 ]]
The min-max composition for (3,one) is 0.5<jupyter_text>Assignment 9<jupyter_code>'''
dict = {}

x = input()
for i in x.split(" "):
    dict[i.split(":")[0]] = i.split(":")[1]
'''
dict = {0:0.1, 0.1:0.1, 0.2:0.1, 0.3:0.2, 0.4:0.2, 0.5:0.2, 0.6:0.2, 0.7:0.5, 0.8:0.5, 0.9:0.5, 1.0:0.5}
cent = 0

sum_xi_wi = 0
sum_wi = 0

for i in dict:
    sum_wi += dict[i]
    sum_xi_wi += i*dict[i]

cent = sum_xi_wi/sum_wi

print("Centroid is:",cent)

dict = {0:0.1, 0.1:0.1, 0.2:1, 0.3:0.2, 0.4:0.8, 0.5:0.2, 0.6:1, 0.7:0.5, 0.8:1, 0.9:0.5, 1.0:0.1}
sum_of_max = 0
list_of_max = []
count = 0

for i in dict:
    if(dict[i]==1 or dict[i]==1.0):
        list_of_max.append(i)
        sum_of_max += dict[i]
        count += 1

mean_of_max = sum_of_max/count    
print("Mean of Maximum : ",mean_of_max)

small_of_max = min(list_of_max)
larg_of_max = max(list_of_max)

print("Smallest of Maximum :", small_of_max)
print("Largest of Maximum: ",larg_of_max)

list_of_mem = []

for i in dict:
    list_of_mem.append(dict[i])

print("Bisector of Area: ", sum(list_of_mem)/len(list_of_mem))<jupyter_output>Centroid is: 0.6741935483870968
Mean od Maximum :  1.0
Smallest of Maximum : 0.2
Largest of Maximum:  0.8
Bisector of Area:  0.5<jupyter_text>Assignment 10 Rule 1 --> If BP is high and temperature is high then health is poor.Rule 2 --> If BP is normal and temperature is normal then health is good.Rule 3 --> If BP is low and temperature is normal then health is normal<jupyter_code># Blood-pressure

bp = np.arange(60,140)
bp_low = skfuzzy.sigmf(bp, 100, -0.2)
bp_normal = skfuzzy.gaussmf(bp, 100, 20)
bp_high = skfuzzy.sigmf(bp, 100, 0.2)

a = plt.plot(bp, bp_low, label='low')
b = plt.plot(bp, bp_normal, label='normal')
c = plt.plot(bp, bp_high, label='high')
plt.title('BP comparisons')
plt.legend()
plt.xlabel('BP')
plt.ylabel('Membership')
plt.show()

#BP_low = {60:0.9, 70:0.8, 80:0.6, 90:0.5, 100:0.4, 110:0.3, 120:0.2, 130:0.1, 140:0}
#BP_normal = {60:0.2, 70:0.4, 80:0.7, 90:0.9, 100:0.9, 110:0.7, 120:0.7, 130:0.4, 140:0}
#BP_high = {60:0, 70:0.1, 80:0.2, 90:0.3, 100:0.4, 110:0.5, 120:0.6, 130:0.8, 140:0.9}
# Temperature(F)
temp = np.arange(90,104)
temp_low = skfuzzy.sigmf(temp, 97, -1.1)
temp_normal = skfuzzy.gaussmf(temp, 97, 2.5)
temp_high = skfuzzy.sigmf(temp, 97, 1.1)

plt.plot(temp, temp_low, label = 'low')
plt.plot(temp, temp_normal, label = 'normal')
plt.plot(temp, temp_high, label = 'high')
plt.title('Temperature comparisons')
plt.legend()
plt.xlabel('Temperature')
plt.ylabel('Membership')
plt.show()
plt.show()


#temp_low = {94:0.9, 95:0.8, 96:0.7, 97:0.6, 98:0.5, 99:0.4, 100:0.3, 101:0.2, 102:0.1}
#temp_normal = {94:0.2, 95:0.4, 96:0.6, 97:0.8, 98:0.9, 99:0.8, 100:0.5, 101:0.3, 102:0.1}
#temp_high = {94:0.1, 95:0.2, 96:0.3, 97:0.4, 98:0.5, 99:0.6, 100:0.7, 101:0.8, 102:0.9}
def health(temperature, blood_pressure):
    
    temp_low = skfuzzy.sigmf(temperature, 97, -1.1)
    temp_normal = skfuzzy.gaussmf(temperature, 97, 2.5)
    temp_high = skfuzzy.sigmf(temperature, 97, 1.1)
    
    temp_cond = ''
    
    if temp_low > temp_normal and temp_low > temp_high:
        temp_cond = 'low'
    elif temp_normal > temp_low and temp_normal > temp_high:
        temp_cond = 'normal'
    elif temp_high > temp_low and temp_high > temp_normal:
        temp_cond = 'high'
    
    bp_low = skfuzzy.sigmf(blood_pressure, 100, -0.2)
    bp_normal = skfuzzy.gaussmf(blood_pressure, 100, 20)
    bp_high = skfuzzy.sigmf(blood_pressure, 100, 0.2)
    
    bp_cond = ''
    
    if bp_low > bp_normal and bp_low > bp_high:
        bp_cond = 'low'
    elif bp_normal > bp_low and bp_normal > bp_high:
        bp_cond = 'normal'
    elif bp_high > bp_low and bp_high > bp_normal:
        bp_cond = 'high'
        
    health_cond = ''
    
    if temp_cond == 'high'and bp_cond == 'high':
        health_cond = 'Poor'
        
    if temp_cond == 'normal'and bp_cond == 'normal':
        health_cond = 'Good'
        
    if temp_cond == 'normal'and bp_cond == 'low':
        health_cond = 'Normal'  
        
    return health_cond    
temp = float(input("Enter the temperature: "))
bp = float(input("Enter the blood pressure: "))

print('The health is :', health(temp, bp))<jupyter_output>Enter the temperature: 104
Enter the blood pressure: 120
The health is : Poor<jupyter_text>Assignment 11  Assignment 12<jupyter_code>amount_of_water = float(input("Enter amount of water in liters:"))
amount_of_dirt = input("Enter dirt(low/normal/high) :")
amount_of_washing_powder = float(input("Enter amount of washing powder in grams:"))

a1 = 7 
c1 = 0.5
x1 = np.arange(0,15)
water = skfuzzy.sigmf(x1,a1,c1)

a2 = 25 
c2 = 0.2

x2 = np.arange(0,50)
powder = skfuzzy.sigmf(x2,a2,c2)

#plt.plot(x1, water)
#plt.plot(x2, powder)
#plt.show()

if amount_of_dirt == 'high':
    if skfuzzy.sigmf(amount_of_water, a1, c1) >= 0.5:
        if skfuzzy.sigmf(amount_of_washing_powder, a2, c2) >= 0.5:
            TIME = '5-7 minutes'
        else:
            TIME = 'approximately 10 minutes'
    else:
        TIME = 'less than 15 minutes'
    
elif amount_of_dirt == 'low':
    if skfuzzy.sigmf(amount_of_water, a1, c1) >= 0.5:
        if skfuzzy.sigmf(amount_of_washing_powder, a2, c2) >= 0.5:
            TIME = '2 minutes'
        else:
            TIME = '4-5 minutes'
    else:
        TIME = '7-10 minutes'
        
else:
    if skfuzzy.sigmf(amount_of_water, a1, c1) >= 0.5:
        if skfuzzy.sigmf(amount_of_washing_powder, a2, c2) >= 0.5:
            TIME = '3 minutes'
        else:
            TIME = '5-6 minutes'
    else:
        TIME = '10-12 minutes'
        
print('The time remaining is ',TIME)<jupyter_output>Enter amount of water in liters:7
Enter dirt(low/normal/high) :high
Enter amount of washing powder in grams:20
The time remaining is  approximately 10 minutes<jupyter_text>Assignment 13  Travelling Salesman problem **Order Encoding**<jupyter_code>def tsp(n):
    
    p = random.sample(range(n),n)

    random.shuffle(p)
    
    return p
n_cities = int(input('No. of cities '))

p1 = tsp(n_cities)
print("Parent 1: ",p1)
p2 = tsp(n_cities)
print("Parent 2: ",p2)<jupyter_output>No. of cities 10
Parent 1:  [6, 4, 5, 3, 7, 8, 2, 0, 9, 1]
Parent 2:  [1, 5, 8, 0, 7, 3, 4, 9, 2, 6]<jupyter_text>Assignment 14  Knapsack problem**Problem**: There are things with given value and size. The knapsack has given capacity. Select things to maximize the value of things in knapsack, but do not extend knapsack capacity. **Encoding**: Each bit says, whether the corresponding thing is in knapsack.<jupyter_code>W = 5
weight = [3, 2, 4, 1]
value = [100, 20, 60, 40]

item = []

for i in range(len(weight)):
    for j in range(len(value)):
        if i == j:
            item.append((weight[i], value[j]))

def parent():
    possible_vals = 0,1
    p = []
    for i in range(4):
        a = random.randint(0,1)
        p.append(a)
    return p    
p1 = parent()
print('Parent 1: ', p1)

p2 = parent()
print('Parent 2: ', p2)<jupyter_output>Parent 1:  [0, 1, 1, 0]
Parent 2:  [0, 1, 1, 1]<jupyter_text>Assignment 15 **8-queen problem**<jupyter_code>def queens(n = 8):
    q = random.sample(range(n),n)
    random.shuffle(q)
    
    return q
p1 = queens()
print("Parent 1: ", p1)
p2 = queens()
print("Parent 2: ", p2)<jupyter_output>Parent 1:  [2, 3, 1, 6, 0, 7, 5, 4]
Parent 2:  [7, 5, 2, 4, 1, 3, 0, 6]<jupyter_text>Assignment 16<jupyter_code>N = 100
N_p = int(input("Enter N_p: "))<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.17400957126646605, 'fraction_numerical': 0.07129113424441265, 'mean_word_length': 3.3817552961521833, 'pattern_counts': {'":': 2, '<': 61, '<?xml version=': 0, '>': 90, 'https://': 4, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 3, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '17', 'dir': 'jupyter-structured-clean-dedup', 'id': '345878', 'license': 'MIT', 'n_tokens_mistral': 8734, 'n_tokens_neox': 7814, 'n_words': 2236, 'path': 'Soft Computing lab manual.ipynb', 'repo_name': 'chauhanakash23/fuzzy-set-operations-and-membership-functions', 'size': '20274'}