perceptron training

Author: Null-Tree

content/Assets/Pasted image 20250829121703.png

@@ -0,0 +1,97 @@
+```python
+
+class Vector:
+    def __init__(self,vlist):
+        self.vlist=vlist.copy()
+        self.n_dim=len(vlist)
+        
+
+    def __repr__(self):
+        return str(self.vlist)
+
+    def len(self):
+        return len(self.vlist)
+    
+    def __getitem__(self,index):
+        return self.vlist[index]
+    
+    def __setitem__(self, index, val):
+        self.vlist[index] = val
+
+    def copy(self):
+        new=Vector(self.vlist)
+        return new
+
+    def check_dim(self,v2):
+        if type(v2) != Vector:
+            raise Exception("vector expected")                  
+        if self.n_dim != v2.n_dim:
+            raise Exception("v not same size")  
+
+    def __eq__(self, v2):
+        self.check_dim(v2)
+        
+        for i in range(self.len()):
+            if self[i]!=v2[i]:
+                return False
+        return True
+    
+    def __add__(self,v2):
+        self.check_dim(v2)
+        new=[None for _ in range(self.len())]
+        for i in range(self.len()):
+            new[i]=self[i]+v2[i]
+
+        vnew=Vector(new)
+        return vnew
+    
+    def __sub__(self,v2):
+        self.check_dim(v2)
+        new=[None for _ in range(self.len())]
+        for i in range(self.len()):
+            new[i]=self[i]-v2[i]
+        vnew=Vector(new)
+        return vnew
+
+    def __mul__(self,v2):
+        if type(v2)==Vector:
+            return self.dotP(v2)
+        else:
+            return self.scalar_mul(v2)
+        
+    def __div__(self,v2):
+        if type(v2)==Vector:
+            raise Exception("scalar div only")
+        return self.scalar_div(v2)
+    
+    def scalar_mul(self,v2:float):
+        new=[None for _ in range(self.len())]
+        for i in range(self.len()):
+            new[i]=self[i]*v2
+
+        vnew=Vector(new)
+        return vnew
+
+    def scalar_div(self,v2:float):
+        new=[None for _ in range(self.len())]
+        for i in range(self.len()):
+            new[i]=self[i]/v2
+
+        vnew=Vector(new)
+        return vnew
+
+
+    def dotP(self,v2):
+        """DOT PRODUCT"""
+        self.check_dim(v2)
+        new=[None for _ in range(self.len())]
+        for i in range(self.len()):
+            new[i]=self[i]*v2[i]
+        return sum(new)
+
+    def norm(self)->float:
+        sqsum=0
+        for v in self.vlist:
+            sqsum+=v**2
+        return sqsum**(0.5)
+```

content/Excalidraw/Drawing 2025-08-27 18.48.54.excalidraw.md

@@ -16,6 +16,7 @@ Using [[Vector notation for weight and data]]
 
 Let $h(x)=x\cdot w+b$ ($b$=bias)
 If $h(x)=0$ represents the decision boundary, then $h(x)=k,k\neq{0}$ represents margin boundaries.
+Note that $\dots+b$ and $\dots-b$ in the formula is often interchangeable, as b can be negative or positive, and is adjusted during training anyways, just need to ensure its consistant.
 
 More specifically
 - **Class +1 boundary**

content/Python/Personal Modules/Vectors.md

@@ -1,4 +1,6 @@
 A program/algorithm (in this case artificial intelligence) with the goal of divides data points into predefined groups called classes.
 
+Often make use of [[Perceptron|Perceptron/s]]
+
 Take the IRIS data set as an example, which contains measurements of many flowers.
 Classification in this data set could involve classifying flowers into their types based on the measurements from the dataset.

content/Unit 4/Artificial Intelligence/Machine Learning/Classification/Classification types/Linear classification/Margin boundaries (Linear).md

@@ -42,5 +42,6 @@ You may recognise this from Specialist Maths as the cartesian equation for a pla
 Here $r$, or the position vector, is represented by $x$.
 This makes $w$ the normal vector.
 **$w$ will always be normal to classification (decision and margin) boundaries**.
-%% NOT SUREL Note that the magnitude of $w$ is not significant as the bias and $w$ are both adjusted during training. %%
-![[Pasted image 20250828221537.png]]
+$w$ affects the margin.
+
+![[Pasted image 20250829121703.png]]

content/Unit 4/Artificial Intelligence/Machine Learning/Classification/Classification.md

@@ -54,6 +54,160 @@ Linear seperation
 - requires labelled data for training
 [[Multi-layer Perceptron]] overcomes these limitations.
 
+
+
+# Code
+
+
+## Example of a perceptron
+```python
+def perceptron(feature_l,weight_l,bias):
+    product_list=[feature_l[i]*weight_l[i] for i in range(len(feature_l))]
+    result=sum(product_list)+bias
+    if result>0:
+        return 1
+    else:
+        return 0
+```
+
+
+## Example of perceptron training
+
+**NOTE:** This uses a vector module, which can be copied here: [[Vectors]]
+
+```python
+from ucimlrepo import fetch_ucirepo 
+from dataclasses import dataclass
+import random
+from tqdm import tqdm
+
+#This uses a personal vector module, which can be copied from 
+# algo25/python/Personal Modules/Vectors
+# Use the folling import line, or just copy paste the entire vector class here
+from Vector import Vector
+
+
+@dataclass         
+class AIconfig:
+    data_points: list[Vector]=None
+    targets:list=None
+    weights:Vector=None
+    bias:float=None
+
+
+def get_data():
+    # fetch dataset 
+    iris = fetch_ucirepo(id=53) 
+    
+    # data (as pandas dataframes) 
+    iris_features = iris.data.features 
+    iris_targets = iris.data.targets 
+    
+    # get features as seperate lists
+    SL=iris_features["sepal length"]
+    SW=iris_features["sepal width"]
+    PL=iris_features["petal length"]
+    PW=iris_features["petal width"]
+
+    qty=len(SL)
+
+    # obtain features by combining data points
+    X1=[SL[i]*SW[i] for i in range(qty)]
+    X2=[PL[i]*PW[i] for i in range(qty)]
+
+    # obtain lists of targets, or correct answers
+    Y=[(1 if fclass == "Iris-setosa" else 0) for fclass in iris_targets["class"]]
+
+    # we will store all data points as vectors
+    vectorlist=[]
+    for i in range(len(X1)):
+        vl=[X1[i],X2[i]]
+        vectorlist.append(Vector(vl))
+
+    return vectorlist,Y
+
+
+
+def perceptron(x:Vector,w:Vector,b):
+    # simple perceptron
+    # DOT PRODUCT OF x and w vectors + bias
+    result=x*w+b
+    if result>0:
+        return 1
+    else:
+        return 0
+
+
+def normal_train(config:AIconfig,nEpoch=1000,learnRate=0.01):
+    # training
+
+    # gets list of data vectors (x)
+    x_l=config.data_points
+    
+    # finds number of entries, 
+    n_entries=len(x_l)
+    # finds number of features
+    n_features=x_l[0].len()
+
+    # populates a weight vector with samed dimensions as data vector
+    wl=[0 for _ in range(n_features)]
+    config.weights=Vector(wl)
+    del wl
+
+    targets=config.targets
+
+    # initiate a bias
+    config.bias=0
+    
+    for _ in tqdm(range(nEpoch)): #
+        
+        # iterate through all data items in random order
+        i_list=list(range(n_entries))
+        random.shuffle(i_list)
+        for i in i_list:
+            x=x_l[i]
+            w=config.weights
+            bias=config.bias
+
+            res=perceptron(x,w,bias)
+            
+            # calculates error (if correct, error = 0)
+            error=targets[i]-res
+
+            # modifies bias and weights
+            bias+= error * learnRate
+            config.weights+=(x*error)*learnRate
+    return config
+
+
+def main():
+    # extract data
+    x_l,targets=get_data()
+    
+    # initiate config
+    config=AIconfig()
+    config.data_points=x_l
+    config.targets=targets
+
+    # initiates training
+    normal_train(config)
+    
+    # outputs the final configuration
+    print(f"weights {config.weights}")
+    print(f"bias {config.bias}")
+
+main()
+
+```
+
+
+
+
+
+
+
+
+
 [^1]: https://www.geeksforgeeks.org/machine-learning/what-is-perceptron-the-simplest-artificial-neural-network/
 
 [^2]: https://www.w3schools.com/ai/ai_perceptrons.asp