StasesNeuralNet 0.1.0__tar.gz

stasesneuralnet-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: StasesNeuralNet
+Version: 0.1.0
+Summary: My own neural network library
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown

stasesneuralnet-0.1.0/README.txt

@@ -0,0 +1,37 @@
+This is my first neural network.
+
+How to use:
+
+1.Import
+
+    from StasesNeuralNet import Network
+
+2.Create net
+
+    Net = Network(
+            2.1.first_input_len
+                length of first layer and input vector (int)
+
+            2.2.layers_and_their_len
+                list of layers and their length (list)
+                example: [10, 20, 15, 10, 5, 2, 1]
+
+            2.3.you can also set the learnint rate but its already 0.0001
+                learning_rate=0.0001
+        )
+
+2.Fill the network
+
+    Net.fill_network()
+
+4.Make your dataset
+
+5.Train net
+
+    Net.train(input_vector, target_vector)
+
+6.When the network is done, to get answer, use forward()
+
+    answer = Net.forward(input_vector)
+
+This litle project have only RELU

stasesneuralnet-0.1.0/StasesNeuralNet/__init__.py

@@ -0,0 +1 @@
+from .network import Network

stasesneuralnet-0.1.0/StasesNeuralNet/network.py

@@ -0,0 +1,142 @@
+import random
+
+class Neuron:
+    def __init__(self, weights, bias=0):
+        self.weights=weights
+        self.bias =bias
+        self.error =0
+        self.weight_delta =[]
+        self.bias_delta =0
+
+    def forward(self, input_vector):
+        self.last_input=input_vector
+        answer=0
+        for i in range(len(input_vector)):
+            answer += input_vector[i] *self.weights[i]
+        answer+=self.bias
+        self.z=answer
+        answer=self.activation_func(answer)
+        self.output=answer
+        return answer
+
+    def activation_func(self, answer):
+        return max(0, answer)
+
+    def count_delta(self, learning_rate):
+        self.weight_delta =[]
+        for w in range( len( self.weights)):
+            self.weight_delta.append( self.last_input[ w] *self.error *learning_rate)
+
+        self.bias_delta =self.error *learning_rate
+
+    def apply_delta(self):
+        for w in range( len( self.weights)):
+            self.weights[w] +=self.weight_delta[w]
+        self.bias +=self.bias_delta
+
+        self.weight_delta =[]
+        self.bias_delta =0
+        self.error =0
+
+    def show_info(self):
+        print('weights:',self.weights)
+        print('bias:',self.bias)
+        print('error:',self.error)
+        print('weight delta:',self.weight_delta)
+        print('bias delta:',self.bias_delta,'\n')
+
+    def activation_derivative(self):
+        if self.z <=0: return 0
+        else: return 1
+
+class Network:
+    def __init__(self, first_input_len, layers_and_their_len, learning_rate=0.0001):
+        self.layers =[]
+        self.input_len=first_input_len
+        self.LAndTLen=layers_and_their_len
+        self.learning_rate=learning_rate
+
+    def create_neuron(self, weights_count, weights=None):
+        if not weights:
+            weights=[]
+            std = (2 / weights_count) ** 0.5
+
+            for i in range(weights_count):
+                weights.append(random.gauss(0, std))
+        return Neuron(weights)
+
+    def fill_network(self):
+        for lyr in range(len(self.LAndTLen)):
+            layer=[]
+            if lyr ==0:
+                weights_count=self.input_len
+            else:
+                weights_count=self.LAndTLen[lyr-1]
+            for n in range(self.LAndTLen[lyr]):
+                layer.append( self.create_neuron(weights_count))
+            self.layers.append(layer)
+
+    def show_info(self):
+        for l in range(len(self.layers)):  # перевірка
+            print('\n=#$%#*=~- ' + str(l + 1) + ' layer -~=*#%$#=')
+            for n in range(len(self.layers[l])):
+                self.layers[l][n].show_info()
+
+    def layer_forward(self, layer, input_vector):
+        new_vector=[]
+        for neuron in self.layers[ layer]:
+            new_vector.append( neuron.forward( input_vector))
+        return new_vector
+
+    def forward(self, input_vector):
+        result=[]
+        for lyr in range(len(self.layers)):
+            result =self.layer_forward(lyr,input_vector)
+            input_vector=result
+        self.output=result
+        return result
+
+    def train(self, input_vector, target):
+        self.forward(input_vector)
+        self.calculate_output_error(target)
+        loss =self.calculate_loss(target)
+        self.calculate_hidden_errors()
+        self.count_deltas()
+        self.apply_deltas()
+        return loss
+
+    def calculate_output_error(self, target):
+        last_layer = self.layers[-1]
+        for i, neuron in enumerate(last_layer):
+            error = (target[i] - neuron.output) * neuron.activation_derivative()
+            neuron.error = error
+
+    def calculate_hidden_errors(self):
+        for layer_index in range((len(self.layers) -2), -1, -1):
+            current_layer =self.layers[layer_index]
+            next_layer =self.layers[layer_index +1]
+            for i, neuron in enumerate(current_layer):
+                sum_error=0
+                for next_neuron in next_layer:
+                    sum_error +=next_neuron.error *next_neuron.weights[i]
+
+                sum_error *=neuron.activation_derivative()
+                neuron.error =sum_error
+
+    def count_deltas(self):
+        for layer in self.layers:
+            for neuron in layer:
+                neuron.count_delta(self.learning_rate)
+
+    def apply_deltas(self):
+        for layer in self.layers:
+            for neuron in layer:
+                neuron.apply_delta()
+
+    def calculate_loss(self,target):
+        loss =0
+        last_layer = self.layers[-1]
+        for i, neuron in enumerate(last_layer):
+            loss +=(target[i] -neuron.output) **2
+        loss /= len(last_layer)
+        return loss

stasesneuralnet-0.1.0/StasesNeuralNet.egg-info/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: StasesNeuralNet
+Version: 0.1.0
+Summary: My own neural network library
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown

stasesneuralnet-0.1.0/StasesNeuralNet.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.txt
+pyproject.toml
+StasesNeuralNet/__init__.py
+StasesNeuralNet/network.py
+StasesNeuralNet.egg-info/PKG-INFO
+StasesNeuralNet.egg-info/SOURCES.txt
+StasesNeuralNet.egg-info/dependency_links.txt
+StasesNeuralNet.egg-info/top_level.txt

stasesneuralnet-0.1.0/StasesNeuralNet.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

stasesneuralnet-0.1.0/StasesNeuralNet.egg-info/top_level.txt

@@ -0,0 +1 @@
+StasesNeuralNet

stasesneuralnet-0.1.0/pyproject.toml

@@ -0,0 +1,10 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "StasesNeuralNet"
+version = "0.1.0"
+description = "My own neural network library"
+readme = "README.md"
+requires-python = ">=3.10"

stasesneuralnet-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+