stdpneuron 0.0.2__tar.gz → 0.1.1__tar.gz

{stdpneuron-0.0.2 → stdpneuron-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: stdpneuron
-Version: 0.0.2
+Version: 0.1.1
 Summary: idk
 Project-URL: Documentation, https://github.com/Guille-ux/stdpneuron#readme
 Project-URL: Issues, https://github.com/Guille-ux/stdpneuron/issues

{stdpneuron-0.0.2 → stdpneuron-0.1.1}/src/stdpneuron/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2026-present Guille-ux <guilleleiratemes@gmail.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.0.2"
+__version__ = "0.1.1"

stdpneuron-0.1.1/src/stdpneuron/brain.py

@@ -0,0 +1,80 @@
+import json
+import random
+
+class NeuronMass:
+    def __init__(self, n_neurons=100, n_cons=50, v_decay=0.5, t_decay=0.5):
+        self.n_neurons = n_neurons
+        self.n_cons = n_cons
+        self.total_cons = n_cons * n_neurons
+        self.connections_in = [0] * self.total_cons # en q neurona entra
+        self.connections_out = [0] * self.total_cons # de q neurona sale
+        self.threeholds = [1] * self.n_neurons
+        self.voltage = [0] * self.n_neurons
+        self.temperature = [0] * self.total_cons
+        self.plasticity = [1] * self.total_cons
+        self.bias = [1] * self.total_cons
+        self.pr = 0
+        self.outputs = [0] * self.n_neurons
+        self.v_decay = v_decay
+        self.t_decay = t_decay
+    def save_model(self, name):
+        dict = {"n_neurons":self.n_neurons,
+            "n_cons":self.n_cons,
+            "total_cons":self.total_cons,
+            "connections_in":self.connections_in,
+            "connections_out":self.connections_out,
+            "threeholds":self.threeholds,
+            "plasticity":self.plasticity,
+            "biases":self.bias,
+            "v_decay":self.v_decay,
+            "t_decay":self.t_decay
+            }
+        with open(name, "w") as f:
+            json.dump(dict, f)
+    def load_model(self, name):
+        with open(name, "r") as f:
+            dict = json.load(f)
+            self.n_neurons = dict["n_neurons"]
+            self.n_cons = dict["n_cons"]
+            self.total_cons = dict["total_cons"]
+            self.connections_in = dict["connections_in"]
+            self.connections_out = dict["connections_out"]
+            self.threeholds = dict["threeholds"]
+            self.plasticity = dict["plasticity"]
+            self.bias = dict["biases"]
+            self.v_decay = dict["v_decay"]
+            self.t_decay = dict["t_decay"]
+    def generate_connections(self):
+        for i in range(self.n_neurons):
+            for j in range(self.n_cons):
+                self.connections_out[i*self.n_cons+j] = i
+                self.connections_in[i*self.n_cons+j] = random.randint(0, self.n_neurons)
+		# esta función genera conexiones neuronales aleatorias, bruh	
+    def tick(self):
+		# PROCESAR ACTIVACIÓN DE NEURONAS
+        for i in range(self.n_neurons):
+            cons_ids = []
+            delta_voltage = 0
+            for j in range(self.total_cons):
+                if self.connections_in[j] == i: # es decir, esta conexión entra en la neurona q estamos mirando?
+                    cons_ids.append(j)
+                    delta_voltage += self.bias[j]*self.outputs[self.connections_out[j]] * self.voltage[self.connections_out[j]]
+                    self.temperature[j] += 1
+            self.voltage[i] += delta_voltage
+            if self.voltage[i] > self.threeholds[i]:
+                self.outputs[i] = 1
+            else:
+                self.outputs[i] = 0
+            self.voltage[i] *= self.v_decay
+		# CALCULAR CAMBIOS EN LAS CONEXIONES Y APLICARLOS
+        for i in range(self.total_cons):
+            neuron_in = self.connections_in[i]
+            neuron_out = self.connections_out[i]
+            if self.outputs[neuron_in] == 1:
+                self.bias[i] += self.plasticity[i] * (self.temperature[i])
+            else:
+                self.bias[i] -= self.plasticity[i] * self.temperature[i]
+
+            self.bias[i] += self.pr * self.plasticity[i] * self.temperature[i]
+
+            self.temperature[i] *= self.t_decay

stdpneuron-0.0.2/src/stdpneuron/brain.py

@@ -1,80 +0,0 @@
-import json
-import random
-
-class NeuronMass:
-	def __init__(self, n_neurons=100, n_cons=50, v_decay=0.5, t_decay=0.5):
-		self.n_neurons = n_neurons
-		self.n_cons = n_cons
-		self.total_cons = n_cons * n_neurons
-		self.connections_in = [0] * self.total_cons # en q neurona entra
-		self.connections_out = [0] * self.total_cons # de q neurona sale
-		self.threeholds = [1] * self.n_neurons
-		self.voltage = [0] * self.n_neurons
-		self.temperature = [0] * self.total_cons
-		self.plasticity = [1] * self.total_cons
-		self.bias = [1] * self.total_cons
-		self.pr = 0
-		self.outputs = [0] * self.n_neurons
-		self.v_decay = v_decay
-		self.t_decay = t_decay
-	def save_model(self, name):
-		dict = {"n_neurons":self.n_neurons,
-			"n_cons":self.n_cons,
-			"total_cons":self.total_cons,
-			"connections_in":self.connections_in,
-			"connections_out":self.connections_out,
-			"threeholds":self.threeholds,
-			"plasticity":self.plasticity,
-			"biases":self.bias,
-			"v_decay":self.v_decay,
-			"t_decay":self.t_decay
-			}
-		with open(name, "w") as f:
-			json.dump(dict, f)
-	def load_model(self, name):
-		with open(name, "r") as f:
-			dict = json.load(f)
-			self.n_neurons = dict["n_neurons"]
-			self.n_cons = dict["n_cons"]
-			self.total_cons = dict["total_cons"]
-			self.connections_in = dict["connections_in"]
-			self.connections_out = dict["connections_out"]
-			self.threeholds = dict["threeholds"]
-			self.plasticity = dict["plasticity"]
-			self.bias = dict["biases"]
-			self.v_decay = dict["v_decay"]
-			self.t_decay = dict["t_decay"]
-	def generate_connections(self):
-		for i in range(self.n_neurons):
-			for j in range(self.n_cons):
-				self.connections_out[i*self.n_cons+j] = i
-				self.connections_in[i*self.n_cons+j] = random.randint(0, self.n_neurons)
-		# esta función genera conexiones neuronales aleatorias, bruh	
-	def tick(self):
-		# PROCESAR ACTIVACIÓN DE NEURONAS
-		for i in range(self.n_neurons):
-			cons_ids = []
-			delta_voltage = 0
-			for j in range(self.total_cons):
-				if self.connections_in[j] == i: # es decir, esta conexión entra en la neurona q estamos mirando?
-					cons_ids.append(j)
-					delta_voltage += self.bias[j]*self.outputs[self.connections_out[j]] * self.voltage[self.connections_out[j]]
-                    self.temperature[j] += 1
-			self.voltage[i] += delta_voltage
-			if self.voltage[i] > self.threeholds[i]:
-				self.outputs[i] = 1
-			else:
-				self.outputs[i] = 0
-			self.voltage[i] *= self.v_decay
-		# CALCULAR CAMBIOS EN LAS CONEXIONES Y APLICARLOS
-        for i in range(self.total_cons):
-            neuron_in = self.connections_in[i]
-            neuron_out = self.connections_out[i]
-            if self.outputs[neuron_in] == 1:
-                self.bias[i] += self.plasticity[i] * (self.temperature[i])
-            else:
-                self.bias[i] -= self.plasticity[i] * self.temperature[i]
-
-            self.bias[i] += self.pr * self.plasticity[i] * self.temperature[i]
-
-            self.temperature[i] *= self.t_decay