DjPractLelo 0.1.2__tar.gz → 0.1.3__tar.gz

djpractlelo-0.1.3/DjPractLelo/resources/soft_computing/10a_simple_genetic algorithm.py

@@ -0,0 +1,48 @@
+import numpy as np
+import random
+
+def activate_function(x):
+    return 1 / (1 + np.exp(-x))
+
+
+n = int(input("Enter Number of inputs you want:"))
+
+# Initial weights (only once)
+weights = np.random.randn(n)
+
+bias = np.random.uniform(0.1, 0.9)
+
+# User inputs
+inputs = []
+for i in range(n):
+    inputs.append(float(input("Enter your input: ")))
+
+inputs = np.array(inputs)
+
+print("\nInitial Weights (First Generation):")
+print(weights)
+
+# Crossover (self crossover using split)
+crossover_point = random.randint(1, n-1)
+child_weights = np.concatenate((weights[:crossover_point], weights[crossover_point:]))
+
+print("\nAfter Crossover:")
+print(child_weights)
+
+# Mutation (change one weight)
+mutation_index = random.randint(0, n-1)
+old_weight = child_weights[mutation_index]
+child_weights[mutation_index] += np.random.randn()
+
+print("\nAfter Mutation:")
+print(f"Weight {mutation_index} changed from {old_weight} to {child_weights[mutation_index]}")
+
+# Neuron output using evolved weights
+z = 0
+for i in range(n):
+    z += inputs[i] * child_weights[i]
+
+z += bias
+
+print("\nFinal Output:")
+print(activate_function(z))

djpractlelo-0.1.3/DjPractLelo/resources/soft_computing/1a_simple_nueral.py

@@ -0,0 +1,34 @@
+import numpy as np
+import random
+
+def activate_function(x):
+    return 1 / (1 + np.exp(-x))
+
+    
+n=int(input("Enter Number of inputs you want:"))
+
+weights = np.random.randn(n)
+
+bias = np.random.uniform(low=0.1, high=0.9)
+
+#User input
+inputs = []
+for i in range(number):
+    val = float(input(f"Enter your input: "))
+    inputs.append(val)
+
+z=0
+for i in range(n):
+    z += (inputs[i] * weights[i])
+
+z = z + bias
+
+# Apply activation function
+print(activate_function(z))
+
+
+
+
+
+
+

djpractlelo-0.1.3/DjPractLelo/resources/soft_computing/1b_binary_bipolar.py

@@ -0,0 +1,25 @@
+import math
+import numpy as np
+
+n=int(input("Enter Number of inputs you want:"))
+
+weights = np.random.randn(n)
+
+bias = np.random.uniform(low=0.1, high=0.9)
+
+inputs = []
+for i in range(n):
+    val = float(input(f"Enter your input: "))
+    inputs.append(val)
+
+z=0
+for i in range(n):
+    z += (inputs[i] * weights[i])
+
+z = z + bias
+
+binary_sigmoidal = 1 / (1 + np.exp(-z))
+bipolar_sigmoidal = 2 / (1 + np.exp(-z)) - 1
+
+print("Binary Sigmoidal = ", round(binary_sigmoidal, 3))
+print("Bipolar Sigmoidal = ", round(bipolar_sigmoidal, 3))

djpractlelo-0.1.3/DjPractLelo/resources/soft_computing/2a_macclouch_AND.py

@@ -0,0 +1,24 @@
+#Mcclouch AND
+
+x1inputs = [0, 0, 1, 1]
+x2inputs = [0, 1, 0, 1]
+
+# Weights (excitatory)
+w1 = 1
+w2 = 1
+
+# Threshold(must be sum of weights to fire only when both inputs are 1)
+threshold = w1+w2  
+
+print("x1  x2  sum  Y")
+for x1, x2 in zip(x1inputs, x2inputs):
+    
+    addittion = x1 * w1 + x2 * w2
+    
+    # Apply threshold
+    if addittion >= threshold:
+        Y = 1
+    else:
+        Y = 0
+    
+    print(f"{x1}   {x2}   {addittion}    {Y}")

djpractlelo-0.1.3/DjPractLelo/resources/soft_computing/2b_macclouch_OR.py

@@ -0,0 +1,24 @@
+# McCulloch-Pitts OR
+
+x1inputs = [0, 0, 1, 1]
+x2inputs = [0, 1, 0, 1]
+
+# Weights (excitatory)
+w1 = 1
+w2 = 1
+
+# Threshold (must be 1 to fire when at least one input is 1)
+threshold = 1  # minimum excitatory input to fire
+
+print("x1  x2  sum  Y")
+for x1, x2 in zip(x1inputs, x2inputs):
+    
+    addition = x1 * w1 + x2 * w2
+    
+    # Apply threshold
+    if addition >= threshold:
+        Y = 1
+    else:
+        Y = 0
+    
+    print(f"{x1}   {x2}   {addition}    {Y}")

djpractlelo-0.1.3/DjPractLelo/resources/soft_computing/2c_macclouch_XOR.py

@@ -0,0 +1,36 @@
+'''XOR= '''
+''' 0 if inputs are same,else 1'''
+
+x1inputs = [0, 0, 1, 1]
+x2inputs = [0, 1, 0, 1]
+
+print("x1  x2  Y")
+
+for x1, x2 in zip(x1inputs, x2inputs):
+    
+    # First layer neurons
+    # Neuron1 = x1 AND NOT x2
+    neuron1_sum = x1 * 1 + x2 * -1
+    neuron1_threshold = 1
+    if neuron1_sum >= neuron1_threshold:
+        neuron1 = 1
+    else:
+        neuron1 = 0
+    
+    # Neuron2 = NOT x1 AND x2
+    neuron2_sum = x1 * -1 + x2 * 1
+    neuron2_threshold = 1
+    if neuron2_sum >= neuron2_threshold:
+        neuron2 = 1
+    else:
+        neuron2 = 0
+    
+    # Output neuron = Neuron1 OR Neuron2
+    output_sum = neuron1 * 1 + neuron2 * 1
+    output_threshold = 1
+    if output_sum >= output_threshold:
+        Y = 1
+    else:
+        Y = 0
+    
+    print(f"{x1}   {x2}   {Y}")

djpractlelo-0.1.3/DjPractLelo/resources/soft_computing/3a_hebb_rule.py

@@ -0,0 +1,56 @@
+import numpy as np
+
+# Sigmoid activation function
+def activate_function(x):
+    return 1 / (1 + np.exp(-x))
+
+# Learning rate for Hebbian learning
+learning_rate = 0.1
+
+n = int(input("Enter number of inputs you want: "))
+
+weights = np.random.randn(n)
+bias = np.random.randn()
+
+print("\nInitial weights:", weights)
+print("Bias:", bias, "\n")
+
+inputs = []
+for i in range(n):
+    val = float(input(f"Enter input {i+1}: "))
+    inputs.append(val)
+
+inputs = np.array(inputs)
+
+y=0
+for i in range(n):
+    y += (inputs[i] * weights[i])
+
+y = y + bias
+print("\nWeighted sum (z) before Hebbian update:", y)
+
+output = activate_function(y)
+print("Output before Hebbian update:", round(output, 3))
+
+
+
+
+#Hebbian Learning Rule
+target = round(output)
+
+# Update weights according to Hebb's rule
+weights += learning_rate * inputs
+bias += learning_rate   
+
+print("\nWeights after Hebbian learning:", weights)
+print("Bias after Hebbian learning:", bias)
+
+#Compute new sum and output after learning
+for i in range(n):
+    y += (inputs[i] * weights[i])
+
+y= y + bias
+output_new = activate_function(y)
+
+print("\nSum after Hebbian update:",y)
+print("Output after Hebbian update:",output)

djpractlelo-0.1.3/DjPractLelo/resources/soft_computing/3b_delta_rule.py

@@ -0,0 +1,63 @@
+import numpy as np
+
+# Sigmoid activation function
+def activate_function(x):
+    return 1 / (1 + np.exp(-x))
+
+# Learning rate
+learning_rate = 0.1
+
+n = int(input("Enter number of inputs you want: "))
+
+weights = np.random.randn(n)
+bias = np.random.randn()
+
+print("\nInitial weights:", weights)
+print("Bias:", bias, "\n")
+
+inputs = []
+for i in range(n):
+    val = float(input(f"Enter input {i+1}: "))
+    inputs.append(val)
+
+inputs = np.array(inputs)
+
+y = 0
+for i in range(n):
+    y += (inputs[i] * weights[i])
+
+y = y + bias
+print("\nWeighted sum (z) before learning:", y)
+
+output = activate_function(y)
+print("Output before learning:",output)
+
+
+
+
+
+
+# -------- Delta Rule --------
+target = float(input("Enter target output (0 or 1): "))
+
+error = target - output
+print(error)
+
+
+# Update weights and bias using Delta rule
+weights += learning_rate * inputs*error
+bias += learning_rate
+
+print("\nWeights after Delta learning:", weights)
+print("Bias after Delta learning:", bias)
+
+#New sum and output after learning
+y = 0
+for i in range(n):
+    y += (inputs[i] * weights[i])
+
+y = y + bias
+output = activate_function(y)
+
+print("\nSum after Delta update:", y)
+print("Output after Delta update:", output)

djpractlelo-0.1.3/DjPractLelo/resources/soft_computing/4a_back-prop.py

@@ -0,0 +1,31 @@
+import numpy as np
+
+# Activation function and derivative
+sig = lambda x: 1/(1+np.exp(-x))
+dsig = lambda x: x*(1-x)
+
+# Number of inputs
+n = int(input("Enter number of inputs: "))
+
+# Initialize weights and bias
+weights = np.random.randn(n)
+bias = np.random.rand()
+
+# User input
+inputs = np.array([float(input(f"Enter input {i+1}: ")) for i in range(n)])
+target = float(input("Enter target output: "))
+
+# Training
+lr = 0.1
+for _ in range(1000):
+    out = sig(np.dot(inputs, weights) + bias)
+    error = target - out
+    delta = error * dsig(out)
+    weights += lr * delta * inputs
+    bias += lr * delta
+
+# Output
+out = sig(np.dot(inputs, weights) + bias)
+print("Trained output:", out)
+print("Trained weights:", weights)
+print("Trained bias:", bias)

djpractlelo-0.1.3/DjPractLelo/resources/soft_computing/4b_back-prop-error.py

@@ -0,0 +1,34 @@
+import numpy as np
+
+# Sigmoid and derivative
+sig = lambda x: 1/(1+np.exp(-x))
+dsig = lambda x: x*(1-x)
+
+# Number of inputs
+n = int(input("Enter number of inputs: "))
+
+# User inputs
+inputs = np.array([float(input(f"Enter input {i+1}: ")) for i in range(n)])
+target = float(input("Enter target output: "))
+
+# Initialize weights and bias
+weights = np.random.randn(n)
+bias = np.random.rand()
+
+# Learning rate and epochs
+lr = 0.1
+epochs = 1000
+
+# Training loop (backpropagation)
+for _ in range(epochs):
+    out = sig(np.dot(inputs, weights) + bias)  # Forward pass
+    error = target - out
+    delta = error * dsig(out)
+    weights += lr * delta * inputs            # Update weights
+    bias += lr * delta                         # Update bias
+
+# Final output
+out = sig(np.dot(inputs, weights) + bias)
+print("Trained output:", out)
+print("Trained weights:", weights)
+print("Trained bias:", bias)

djpractlelo-0.1.3/DjPractLelo/resources/soft_computing/6a_kohonen_self.py

@@ -0,0 +1,38 @@
+import random
+cities = [
+    [0, 0],      # Kudal
+    [-25, 0],    # Malvan
+    [0, -18],    # Sawantwadi
+    [0, 35],     # Kanakavali
+    [0, 65],     # Vaibhavwadi
+    [-35, 65],   # Devgad
+    [-20, -18]   # Vengurle
+]
+
+city_names = ["Kudal", "Malvan", "Sawantwadi", "Kanakavali", "Vaibhavwadi", "Devgad", "Vengurle"]
+
+neurons = 3          # number of clusters.
+learning_rate = 0.3
+epochs = 50
+
+# Initialize neuron positions randomly
+weights = [[random.uniform(-50, 70), random.uniform(-20, 70)] for _ in range(neurons)]
+
+#Training
+for _ in range(epochs):
+    for city in cities:
+        winner = min(range(neurons), key=lambda i: (city[0]-weights[i][0])**2 + (city[1]-weights[i][1])**2)
+        for j in range(2):
+            weights[winner][j] += learning_rate * (city[j] - weights[winner][j])
+
+# Print cluster centers
+print("Neuron positions (cluster centers):")
+for i, w in enumerate(weights):
+    print(f"Neuron {i}: {w}")
+
+# Assign each city to its nearest neuron
+print("\nCity assignments:")
+for idx, city in enumerate(cities):
+    nearest = min(range(neurons), key=lambda i: (city[0]-weights[i][0])**2 + (city[1]-weights[i][1])**2)
+    print(f"{city_names[idx]} -> Cluster {nearest}")
+

djpractlelo-0.1.3/DjPractLelo/resources/soft_computing/9a_ratios_fuzzy.py

@@ -0,0 +1,25 @@
+#membership function
+def fuzzy(x, a=4, b=7, c=10):
+    if x <= a or x >= c:
+        return 0
+    elif x <= b:
+        return (x - a) / (b - a)
+    else:
+        return (c - x) / (c - b)
+
+n = int(input("Enter number of shops: "))
+ratings = []
+
+# User input
+for i in range(n):
+    ratings.append(float(input(f"Enter rating for Shop {i+1}: ")))
+
+# Fuzzification
+memberships = [fuzzy(r) for r in ratings]
+total = sum(memberships)
+
+# Fuzzy ratios
+print("\nShop  Membership  Fuzzy Ratio")
+for i in range(n):
+    ratio = memberships[i] / total if total != 0 else 0
+    print(f"{i+1:>3}    {memberships[i]:.2f}        {ratio:.2f}")

djpractlelo-0.1.3/DjPractLelo/resources/soft_computing/9b_tipping problem.py

@@ -0,0 +1,31 @@
+def fuzzy(x, a, b, c):
+    if x <= a or x >= c:
+        return 0
+    elif x <= b:
+        return (x - a) / (b - a)
+    else:
+        return (c - x) / (c - b)
+
+# ---- User Input ----
+service = float(input("Enter service quality (0-10): "))
+food = float(input("Enter food quality (0-10): "))
+
+# ---- Fuzzification ----
+service_poor = fuzzy(service, 0, 0, 5)
+service_avg  = fuzzy(service, 3, 5, 7)
+service_good = fuzzy(service, 5, 10, 10)
+
+food_bad  = fuzzy(food, 0, 0, 5)
+food_avg  = fuzzy(food, 3, 5, 7)
+food_good = fuzzy(food, 5, 10, 10)
+
+# ---- Rule Evaluation ----
+low_tip    = max(service_poor, food_bad)
+medium_tip = service_avg
+high_tip   = min(service_good, food_good)
+
+# ---- Defuzzification (Weighted Average) ----
+tip = (low_tip*5 + medium_tip*15 + high_tip*25) / \
+      (low_tip + medium_tip + high_tip)
+
+print(f"\nRecommended Tip: {tip:.2f}%")

{djpractlelo-0.1.2 → djpractlelo-0.1.3}/DjPractLelo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DjPractLelo
-Version: 0.1.2
+Version: 0.1.3
 Summary: My first Python package
 Author: DjPractVala
 Author-email: DjPractVala <youremail@example.com>

{djpractlelo-0.1.2 → djpractlelo-0.1.3}/DjPractLelo.egg-info/SOURCES.txt

@@ -56,4 +56,17 @@ DjPractLelo/resources/data_science/transform_data.py
 DjPractLelo/resources/data_science/video-to-horus.py
 DjPractLelo/resources/data_science/warehouse_location.py
 DjPractLelo/resources/data_science/xml-to-horus.py
+DjPractLelo/resources/soft_computing/10a_simple_genetic algorithm.py
+DjPractLelo/resources/soft_computing/1a_simple_nueral.py
+DjPractLelo/resources/soft_computing/1b_binary_bipolar.py
+DjPractLelo/resources/soft_computing/2a_macclouch_AND.py
+DjPractLelo/resources/soft_computing/2b_macclouch_OR.py
+DjPractLelo/resources/soft_computing/2c_macclouch_XOR.py
+DjPractLelo/resources/soft_computing/3a_hebb_rule.py
+DjPractLelo/resources/soft_computing/3b_delta_rule.py
+DjPractLelo/resources/soft_computing/4a_back-prop.py
+DjPractLelo/resources/soft_computing/4b_back-prop-error.py
+DjPractLelo/resources/soft_computing/6a_kohonen_self.py
+DjPractLelo/resources/soft_computing/9a_ratios_fuzzy.py
+DjPractLelo/resources/soft_computing/9b_tipping problem.py
 DjPractLelo/resources/soft_computing/practical_manual.docx

{djpractlelo-0.1.2 → djpractlelo-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DjPractLelo
-Version: 0.1.2
+Version: 0.1.3
 Summary: My first Python package
 Author: DjPractVala
 Author-email: DjPractVala <youremail@example.com>

{djpractlelo-0.1.2 → djpractlelo-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "DjPractLelo"
-version = "0.1.2"
+version = "0.1.3"
 description = "My first Python package"
 readme = "README.md"
 requires-python = ">=3.7"

{djpractlelo-0.1.2 → djpractlelo-0.1.3}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="DjPractLelo",
-    version="0.1.2",
+    version="0.1.3",
     author="DjPractVala",
     description="My demo Python package",
     packages=find_packages(),