poliflow 0.1.0__tar.gz

poliflow-0.1.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: poliflow
+Version: 0.1.0
+Summary: Framework de deep learning
+Home-page: https://github.com/Th3copolo0X/Poliflow2
+Download-URL: https://github.com/Th3copolo0X/Poliflow2/archive/refs/tags/v0.1.tar.gz
+Author: Eduardo Hernandez,Gerardo Hernandez
+Author-email: Eduardo <correo@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Dynamic: author
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: requires-python
+
+# PoliFlow
+
+PoliFlow es un framework de Machine Learning y Deep Learning desarrollado en Python, diseñado con fines educativos y experimentales.  
+El proyecto busca ofrecer una implementación simple y modular de redes neuronales, optimizadores y herramientas para entrenamiento de modelos.
+
+---
+
+# Características
+
+- Construcción de modelos secuenciales
+- Capas densas (Dense)
+- Funciones de activación
+- Entrenamiento de modelos
+- Predicción de datos
+- Sistema modular
+- Implementación propia sin depender de TensorFlow o PyTorch
+
+---
+
+# Instalación
+
+Clona el repositorio:
+
+```bash
+git clone https://github.com/Th3copolo0X/Poliflow2
+cd poliflow

poliflow-0.1.0/README.md

@@ -0,0 +1,26 @@
+# PoliFlow
+
+PoliFlow es un framework de Machine Learning y Deep Learning desarrollado en Python, diseñado con fines educativos y experimentales.  
+El proyecto busca ofrecer una implementación simple y modular de redes neuronales, optimizadores y herramientas para entrenamiento de modelos.
+
+---
+
+# Características
+
+- Construcción de modelos secuenciales
+- Capas densas (Dense)
+- Funciones de activación
+- Entrenamiento de modelos
+- Predicción de datos
+- Sistema modular
+- Implementación propia sin depender de TensorFlow o PyTorch
+
+---
+
+# Instalación
+
+Clona el repositorio:
+
+```bash
+git clone https://github.com/Th3copolo0X/Poliflow2
+cd poliflow

poliflow-0.1.0/poliflow.egg-info/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: poliflow
+Version: 0.1.0
+Summary: Framework de deep learning
+Home-page: https://github.com/Th3copolo0X/Poliflow2
+Download-URL: https://github.com/Th3copolo0X/Poliflow2/archive/refs/tags/v0.1.tar.gz
+Author: Eduardo Hernandez,Gerardo Hernandez
+Author-email: Eduardo <correo@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Dynamic: author
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: requires-python
+
+# PoliFlow
+
+PoliFlow es un framework de Machine Learning y Deep Learning desarrollado en Python, diseñado con fines educativos y experimentales.  
+El proyecto busca ofrecer una implementación simple y modular de redes neuronales, optimizadores y herramientas para entrenamiento de modelos.
+
+---
+
+# Características
+
+- Construcción de modelos secuenciales
+- Capas densas (Dense)
+- Funciones de activación
+- Entrenamiento de modelos
+- Predicción de datos
+- Sistema modular
+- Implementación propia sin depender de TensorFlow o PyTorch
+
+---
+
+# Instalación
+
+Clona el repositorio:
+
+```bash
+git clone https://github.com/Th3copolo0X/Poliflow2
+cd poliflow

poliflow-0.1.0/poliflow.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+setup.py
+poliflow.egg-info/PKG-INFO
+poliflow.egg-info/SOURCES.txt
+poliflow.egg-info/dependency_links.txt
+poliflow.egg-info/requires.txt
+poliflow.egg-info/top_level.txt
+tests/__init__.py
+tests/test1.py
+tests/test2.py
+tests/test3.py
+tests/test_XOR.py
+tests/test_mseloss.py
+tests/test_sgd.py
+tests/test_tensor.py
+tests/test_tensor_add.py
+tests/test_tensor_mul.py
+tests/test_tensor_sum.py

poliflow-0.1.0/poliflow.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

poliflow-0.1.0/poliflow.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy

poliflow-0.1.0/poliflow.egg-info/top_level.txt

@@ -0,0 +1 @@
+tests

poliflow-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "poliflow"
+version = "0.1.0"
+authors = [
+  { name="Eduardo", email="correo@example.com" }
+]
+description = "Framework de deep learning"
+readme = "README.md"
+requires-python = ">=3.9"
+
+dependencies = [
+  "numpy",
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]

poliflow-0.1.0/setup.cfg

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

poliflow-0.1.0/setup.py

@@ -0,0 +1,37 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as readme:
+    long_description = readme.read()
+
+setup(
+    name="poliflow",
+    version="0.1.2",
+    packages=find_packages(),
+    description="Framework de Machine Learning desarrollado en Python",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="Eduardo Hernandez,Gerardo Hernandez",
+    url="https://github.com/Th3copolo0X/Poliflow2",
+    download_url="https://github.com/Th3copolo0X/Poliflow2/archive/refs/tags/v0.1.tar.gz",
+    keywords=[
+        "machine learning",
+        "deep learning",
+        "framework",
+        "neural networks",
+        "python"
+    ],
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.10",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    license="MIT",
+    include_package_data=True,
+    install_requires=[
+        "numpy",
+    ],
+    python_requires=">=3.10",
+)

poliflow-0.1.0/tests/test1.py

@@ -0,0 +1,92 @@
+import pandas as pd
+import numpy as np
+import sys
+import os
+
+# Para que encuentre poliflow
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+# Importar tu framework
+from poliflow.core.Tensor import Tensor
+from poliflow.nn.Linear import Linear
+from poliflow.nn.Sequential import Sequential
+from poliflow.losses.MSE import MSELoss
+from poliflow.optim.SGD import SGD
+from poliflow.nn.Activation import ReLU
+
+# =========================
+# 1. Cargar datos
+# =========================
+ruta_csv = os.path.join(
+    os.path.dirname(__file__),
+    "house_dataset 2.csv"
+)
+
+df = pd.read_csv(ruta_csv)
+
+# Features y target
+X = df.drop(columns=["House_Price"]).values
+y = df["House_Price"].values.reshape(-1, 1)
+
+# Normalización
+X = (X - X.mean(axis=0)) / X.std(axis=0)
+y = (y - y.mean()) / y.std()
+
+# =========================
+# 2. Convertir a Tensor
+# =========================
+X_tensor = Tensor(X)
+y_tensor = Tensor(y)
+
+# =========================
+# 3. Definir modelo
+# =========================
+input_size = X.shape[1]
+
+model = Sequential(
+    Linear(input_size, 16),
+    ReLU(),
+    Linear(16, 8),
+    ReLU(),
+    Linear(8, 1)
+)
+
+# =========================
+# 4. Loss y optimizador
+# =========================
+criterion = MSELoss()
+optimizer = SGD(model.parameters(), lr=0.01)
+
+# =========================
+# 5. Entrenamiento
+# =========================
+epochs = 10000
+
+for epoch in range(epochs):
+    pred = model(X_tensor)
+    loss = criterion(pred, y_tensor)
+
+    loss.backward()
+    optimizer.step()
+    optimizer.zero_grad()
+
+    if epoch % 1000 == 0:
+        try:
+            print(f"Epoch {epoch}, Loss: {loss.data}")
+        except:
+            print(f"Epoch {epoch}, Loss: {loss}")
+
+# =========================
+# 6. Predicción
+# =========================
+pred_final = model(X_tensor)
+
+try:
+    print("Predicciones:", pred_final.data[:5])
+except:
+    print("Predicciones:", pred_final[:5])
+
+
+for i in range(5):
+    print("Pred:", pred_final.data[i][0],
+          "| Real:", y_tensor.data[i][0])

poliflow-0.1.0/tests/test2.py

@@ -0,0 +1,114 @@
+import pandas as pd
+import numpy as np
+import sys
+import os
+
+
+# Para que encuentre poliflow
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+# Importar tu framework
+from poliflow.grafica.grafo import dibujar_red_desde_modelo
+from poliflow.core.Tensor import Tensor
+from poliflow.nn.Linear import Linear
+from poliflow.nn.Sequential import Sequential
+from poliflow.losses.MSE import MSELoss
+from poliflow.optim.SGD import SGD
+from poliflow.nn.Activation import ReLU
+from poliflow.data.split import train_test_split
+
+# =========================
+# 1. Cargar datos
+# =========================
+ruta_csv = os.path.join(
+    os.path.dirname(__file__),
+    "house_dataset 2.csv"
+)
+
+df = pd.read_csv(ruta_csv)
+
+# Features y target
+X = df.drop(columns=["House_Price"]).values
+y = df["House_Price"].values.reshape(-1, 1)
+
+
+
+X_train, X_test, y_train, y_test = train_test_split(X, y)
+
+# Calcular con TRAIN
+X_mean = X_train.mean(axis=0)
+X_std = X_train.std(axis=0)
+
+y_mean = y_train.mean()
+y_std = y_train.std()
+
+# Normalizar TRAIN
+X_train = (X_train - X_mean) / X_std
+y_train = (y_train - y_mean) / y_std
+
+# Normalizar TEST con los mismos valores
+X_test = (X_test - X_mean) / X_std
+y_test = (y_test - y_mean) / y_std
+
+# =========================
+# 2. Convertir a Tensor
+# =========================
+X_tensor = Tensor(X_train)
+y_tensor = Tensor(y_train)
+
+X_test_tensor = Tensor(X_test)
+y_test_tensor = Tensor(y_test)
+
+# =========================
+# 3. Definir modelo
+# =========================
+input_size = X.shape[1]
+
+model = Sequential(
+    Linear(input_size, 16),
+    ReLU(),
+    Linear(16, 8),
+    ReLU(),
+    Linear(8, 1)
+)
+
+# =========================
+# 4. Loss y optimizador
+# =========================
+criterion = MSELoss()
+optimizer = SGD(model.parameters(), lr=0.01)
+
+# =========================
+# 5. Entrenamiento
+# =========================
+epochs = 10000
+
+for epoch in range(epochs):
+    pred = model(X_tensor)
+    loss = criterion(pred, y_tensor)
+
+    loss.backward()
+    optimizer.step()
+    optimizer.zero_grad()
+
+    if epoch % 1000 == 0:
+        try:
+            print(f"Epoch {epoch}, Loss: {loss.data}")
+        except:
+            print(f"Epoch {epoch}, Loss: {loss}")
+
+# =========================
+# 6. Predicción
+# =========================
+pred_final = model(X_tensor)
+
+try:
+    print("Predicciones:", pred_final.data[:5])
+except:
+    print("Predicciones:", pred_final[:5])
+
+
+for i in range(5):
+    print("Pred:", pred_final.data[i][0],
+          "| Real:", y_tensor.data[i][0])
+    

poliflow-0.1.0/tests/test3.py

@@ -0,0 +1,126 @@
+import pandas as pd
+import numpy as np
+import sys
+import os
+
+# Para que encuentre poliflow
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+# Importar tu framework
+from poliflow.core.Tensor import Tensor
+from poliflow.nn.Linear import Linear
+from poliflow.nn.Sequential import Sequential
+from poliflow.losses.MSE import MSELoss
+from poliflow.optim.SGD import SGD
+from poliflow.nn.Activation import ReLU
+from poliflow.data.split import train_test_split
+
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+
+# =========================
+# 1. Cargar datos
+# =========================
+ruta_csv = os.path.join(
+    os.path.dirname(__file__),
+    "house_dataset 2.csv"
+)
+
+df = pd.read_csv(ruta_csv)
+
+# Features y target
+X = df.drop(columns=["House_Price"]).values
+y = df["House_Price"].values.reshape(-1, 1)
+
+# 🔥 LOG TRANSFORM (CLAVE)
+y = np.log1p(y)
+
+# =========================
+# 2. Split
+# =========================
+X_train, X_test, y_train, y_test = train_test_split(X, y)
+
+# =========================
+# 3. Normalización (solo TRAIN)
+# =========================
+X_mean = X_train.mean(axis=0)
+X_std = X_train.std(axis=0) + 1e-8  
+
+y_mean = y_train.mean()
+y_std = y_train.std() + 1e-8
+
+# Normalizar TRAIN
+X_train = (X_train - X_mean) / X_std
+y_train = (y_train - y_mean) / y_std
+
+# Normalizar TEST
+X_test = (X_test - X_mean) / X_std
+y_test = (y_test - y_mean) / y_std
+
+# =========================
+# 4. Tensor
+# =========================
+X_tensor = Tensor(X_train)
+y_tensor = Tensor(y_train)
+
+X_test_tensor = Tensor(X_test)
+
+# =========================
+# 5. Modelo
+# =========================
+input_size = X.shape[1]
+
+model = Sequential(
+    Linear(input_size, 16),
+    ReLU(),
+    Linear(16, 8),
+    ReLU(),
+    Linear(8, 1)
+)
+
+# =========================
+# 6. Loss y optimizador
+# =========================
+criterion = MSELoss()
+optimizer = SGD(model.parameters(), lr=0.01)
+
+# =========================
+# 7. Entrenamiento
+# =========================
+epochs = 10000  # 🔥 bajamos epochs (10000 era excesivo)
+
+for epoch in range(epochs):
+    pred = model(X_tensor)
+    loss = criterion(pred, y_tensor)
+
+    loss.backward()
+    optimizer.step()
+    optimizer.zero_grad()
+
+    if epoch % 500 == 0:
+        print(f"Epoch {epoch}, Loss: {loss.data}")
+
+# =========================
+# 8. Predicción en TEST
+# =========================
+pred_test = model(X_test_tensor).data
+
+# 🔄 Desnormalizar
+y_pred_log = pred_test * y_std + y_mean
+y_true_log = y_test * y_std + y_mean
+
+# 🔄 Invertir log
+y_pred = np.expm1(y_pred_log)
+y_true = np.expm1(y_true_log)
+
+# =========================
+# 9. Métricas
+# =========================
+mse = mean_squared_error(y_true, y_pred)
+rmse = np.sqrt(mse)
+mae = mean_absolute_error(y_true, y_pred)
+r2 = r2_score(y_true, y_pred)
+
+print("\n=== RESULTADOS ===")
+print(f"RMSE: {rmse:.2f}")
+print(f"MAE: {mae:.2f}")
+print(f"R²: {r2:.4f}")

poliflow-0.1.0/tests/test_XOR.py

@@ -0,0 +1,50 @@
+import numpy as np
+from poliflow.core.Tensor import Tensor
+from poliflow.nn.Linear import Linear
+from poliflow.nn.Activation import Sigmoid
+from poliflow.nn.Sequential import Sequential
+from poliflow.losses.MSE import MSELoss
+from poliflow.optim.SGD import SGD
+
+# Datos XOR
+X = Tensor(np.array([
+    [0, 0],
+    [0, 1],
+    [1, 0],
+    [1, 1]
+]), requires_grad=False)
+
+y = Tensor(np.array([
+    [0],
+    [1],
+    [1],
+    [0]
+]), requires_grad=False)
+
+# Modelo (con capa oculta)
+model = Sequential(
+    Linear(2, 4),
+    Sigmoid(),
+    Linear(4, 1),
+    Sigmoid()
+)
+
+loss_fn = MSELoss()
+optimizer = SGD(model.parameters(), lr=0.5)
+
+# Entrenamiento
+for epoch in range(5000):
+    y_pred = model(X)
+    
+    loss = loss_fn(y_pred, y)
+    
+    loss.backward()
+    optimizer.step()
+    optimizer.zero_grad()
+    
+    if epoch % 500 == 0:
+        print(f"Epoch {epoch}, Loss: {loss.data}")
+
+# Resultados
+print("\nPredicciones XOR:")
+print(model(X).data)

poliflow-0.1.0/tests/test_mseloss.py

@@ -0,0 +1,14 @@
+from poliflow.core.Tensor import Tensor
+from poliflow.losses import MSELoss, MAELoss
+
+y_pred = Tensor([2.0, 3.0], requires_grad=True)
+y_true = Tensor([1.0, 5.0])
+
+# MSE
+mse = MSELoss()
+loss1 = mse(y_pred, y_true)
+
+loss1.backward()
+
+print("MSE loss:", loss1.data)
+print("grad:", y_pred.grad)

poliflow-0.1.0/tests/test_sgd.py

@@ -0,0 +1,26 @@
+from poliflow.core.Tensor import Tensor
+from poliflow.losses import MSELoss
+from poliflow.optim import SGD
+
+# datos
+x = Tensor(2.0)
+y_true = Tensor(4.0)
+
+# parametro (peso)
+w = Tensor(1.0, requires_grad=True)
+
+# loss y optimizador
+loss_fn = MSELoss()
+optimizer = SGD([w], lr=0.15)
+
+for epoch in range(10):
+
+    y_pred = w * x
+
+    loss = loss_fn(y_pred, y_true)
+
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+
+    print(f"Epoch {epoch}: w={w.data}, loss={loss.data}")

poliflow-0.1.0/tests/test_tensor.py

@@ -0,0 +1,15 @@
+from poliflow.core.tensor import Tensor
+
+a = Tensor(2.0, requires_grad=True)
+b = Tensor(3.0, requires_grad=True)
+
+c = a * b
+d = c + a
+
+d.backward()
+
+print("a.grad:", a.grad)
+print("b.grad:", b.grad)
+
+
+

poliflow-0.1.0/tests/test_tensor_add.py

@@ -0,0 +1,14 @@
+
+from poliflow.core.tensor import Tensor
+
+a = Tensor(2.0, requires_grad=True)
+b = Tensor(3.0, requires_grad=True)
+
+c = a + b
+
+c.backward()
+
+print("a.grad:", a.grad)
+print("b.grad:", b.grad)
+
+

poliflow-0.1.0/tests/test_tensor_mul.py

@@ -0,0 +1,14 @@
+from poliflow.core.tensor import Tensor
+
+a = Tensor(2.0, requires_grad=True)
+b = Tensor(3.0, requires_grad=True)
+
+c = a * b
+
+c.backward()
+
+print("a.grad:", a.grad)
+print("b.grad:", b.grad)
+
+
+

poliflow-0.1.0/tests/test_tensor_sum.py

@@ -0,0 +1,17 @@
+# tests/test_sum_mean.py
+
+from poliflow.core.Tensor import Tensor
+
+x = Tensor([1.0, 2.0, 3.0], requires_grad=True)
+
+y = x.sum()
+y.backward()
+
+print("sum grad:", x.grad)
+
+x = Tensor([1.0, 2.0, 3.0], requires_grad=True)
+
+y = x.mean()
+y.backward()
+
+print("mean grad:", x.grad)