Mini Framework Deep Learning T-Tensor

Deep Learning ligero con enfoque practico y colaborativo

Construye, entrena y experimenta con redes neuronales de forma clara. T-Tensor busca ser una base simple para aprender, prototipar y crecer en comunidad.

Comenzar guia Como colaborar

Resumen rapido

  • Lenguaje base: C++
  • Objetivo: aprendizaje y experimentacion
  • Integracion: Python (.pyd)
  • Repositorio: publico en GitHub

Introduccion de uso

Como comenzar con T-Tensor

T-Tensor esta disenado para que puedas entender el flujo de trabajo de una red neuronal sin depender de una arquitectura pesada. Es ideal para aprender fundamentos y construir pruebas rapidas.

  1. Configura el entorno y compila el proyecto.
  2. Crea un modelo con capas basicas.
  3. Entrena, evalua y ajusta hiperparametros.

Ejemplo en C++ (core)

// Definir y entrenar modelo
#include "ttensor/model.h"

int main() {
  Model model;
  model.add(Dense(128, "relu"));
  model.add(Dense(10, "softmax"));
  
  model.compile("adam", "crossentropy");
  model.fit(x_train, y_train, 20);
  return 0;
}

Ejemplo en Python (.pyd)

import ttensor as tt

model = tt.Model()
model.add_layer('dense', 128, activation='relu')
model.add_layer('dense', 10, activation='softmax')

model.compile('adam', 'categorical_crossentropy')
model.fit(X_train, y_train, epochs=20, batch_size=32)

loss, acc = model.evaluate(X_test, y_test)
print(f'Accuracy: {acc:.4f}')

Guia completa

Ruta de aprendizaje y puesta en marcha

Indice rapido

  • RUTA A: PROBAR (TestPyPI)
  • 1. Instalacion desde TestPyPI
  • 2. Primeras pruebas en Python
  • RUTA B: DESARROLLAR (Desde fuente)
  • 3. Preparar entorno Python (venv + pybind11)
  • 4. Configuracion y compilacion con CMake
  • 5. Primer entrenamiento en C++
  • 6. Integracion y prueba desde Python (.pyd)
  • 7. Solucion de errores comunes

Objetivo: instalar y probar T-Tensor en minutos sin necesidad de compilar. Perfecta para explorar el framework antes de modificar codigo.

Requisito: Python 3.8+

  1. Abre la terminal y ejecuta: python -m pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple ttensor==0.1.0
  2. Verifica instalacion: python -c "import ttensor; print('OK')"
  3. Listo, ya puedes usar T-Tensor desde Python.

Referencia: TestPyPI - T-Tensor v0.1.0

Objetivo: verificar que T-Tensor funciona correctamente con un script simple.

from ttensor import Device, DeviceManager, Tensor

DeviceManager.initialize()
DeviceManager.print_report()

# Crear tensor simple
x = Tensor(2, 2, Device.CPU, requires_grad=False)
x.fill(1.0)
print("Tensor:", x.tolist())

Nota: si todo funciona, ya puedes explorar ejemplos en la seccion "Documentacion".

Objetivo: compilar T-Tensor desde codigo fuente para modificar, extender y contribuir.

Requisitos:

  • Visual Studio 2019+ (Desktop development with C++).
  • CMake 3.15 o superior.
  • Python 3.8+ (para modulo .pyd).
  • CUDA Toolkit (si vas a usar aceleracion GPU).

Comandos base:

  1. Clona el repositorio: git clone https://github.com/Gilberto-Galan/Mini-Framework-Deep-Learning-T-Tensor
  2. Accede a la carpeta: cd Mini-Framework-Deep-Learning-T-Tensor
  3. Verifica herramientas: cmake --version y python --version

Objetivo: configurar el entorno para compilar y usar los bindings de Python.

  1. Crea entorno virtual: python -m venv venv
  2. Activa entorno (PowerShell): venv\Scripts\Activate.ps1
  3. Actualiza pip: python -m pip install --upgrade pip
  4. Instala pybind11: pip install pybind11

Tip: confirma la ruta con python -m pybind11 --cmakedir para usarla luego en CMake.

Objetivo: generar build para C++ y modulo Python en Windows x64 de forma estable para usuarios nuevos.

  1. Activa tu entorno virtual e instala pybind11: python -m pip install pybind11
  2. Obtiene la ruta de CMake para pybind11 (PowerShell):
$PYBIND11_DIR = python -m pybind11 --cmakedir
  1. Crea la carpeta de compilacion: mkdir build
  1. Configura CMake (paso correcto despues de crear build):
cmake -S . -B build -G "Visual Studio 18 2026" -A x64 -Dpybind11_DIR="$PYBIND11_DIR" -DCMAKE_CUDA_FLAGS="--allow-unsupported-compiler"
  1. Compila en Release: cmake --build build --config Release
  1. Prueba la importacion en Python: python -c "import ttensor; print('OK')"

Notas:

  • Si no usas CUDA, elimina -DCMAKE_CUDA_FLAGS="--allow-unsupported-compiler".
  • Si tienes Visual Studio mas reciente y CMake la reconoce, cambia el generador segun tu version instalada.
  • En PowerShell, usa la linea exacta $PYBIND11_DIR = python -m pybind11 --cmakedir.

Objetivo: validar que el core C++ funciona con un ejemplo simple.

// Estructura basica de entrenamiento en C++
#include "ttensor/model.h"

int main() {
  Model model;
  model.add(Dense(128, "relu"));
  model.add(Dense(10, "softmax"));
  model.compile("adam", "crossentropy");
  model.fit(x_train, y_train, 20);
  return 0;
}

Si este flujo corre correctamente, ya tienes la puesta en marcha del core.

Objetivo: importar y usar el modulo generado desde Python.

  1. Ubica el archivo .pyd generado en la carpeta de build.
  2. Agrega la ruta al PYTHONPATH o copia el .pyd al entorno virtual.
  3. Prueba la importacion:
python -c "import ttensor; print(ttensor.__version__)"

Ejemplo rapido:

import ttensor as tt

model = tt.Model()
model.add_layer('dense', 128, activation='relu')
model.add_layer('dense', 10, activation='softmax')
model.compile('adam', 'categorical_crossentropy')

  • CMake no encontrado: agrega CMake al PATH y reinicia terminal.
  • Error de generador VS: revisa que tengas instalado Desktop development with C++.
  • CUDA incompatible: usa -DCMAKE_CUDA_FLAGS="-allow-unsupported-compiler".
  • pybind11_DIR invalido: usa python -m pybind11 --cmakedir para obtener la ruta correcta.
  • Modulo .pyd no carga: valida version de Python y arquitectura (x64 en todo el flujo).

Tipos de proyectos

Que puedes construir con T-Tensor

Inicial

Clasificacion de imagenes

Prototipos para datasets pequenos con redes densas o convolucionales basicas.

Ver mas
Intermedio

Regresion y prediccion

Modelos para series temporales, datos tabulares y analisis de tendencias.

Ver mas
Educativo

Laboratorios academicos

Practicas para cursos de IA donde importa entender cada etapa del entrenamiento.

Ver mas

Colaboracion

Como apoyar y mejorar el proyecto

La comunidad puede impulsar T-Tensor con codigo, documentacion, pruebas y ejemplos. Cualquier aporte claro y bien documentado suma valor al framework.

  • Abrir issues con pasos para reproducir errores.
  • Proponer mejoras de arquitectura o rendimiento.
  • Crear pull requests pequenos y enfocados.
  • Agregar ejemplos de redes y datasets reales.

Herramientas recomendadas

Git + GitHub CMake Visual Studio (Desktop development with C++) CUDA Toolkit Compiler C++ Python
Contribuir en GitHub Ver proyecto

Roadmap

Vision y planes futuros

En desarrollo

Capas convolucionales

Conv1D, Conv2D con padding y stride optimizado.

En desarrollo

Regularizacion avanzada

BatchNorm, Dropout, L1/L2 con configuracion flexible.

Planificado

Soporte multi-GPU

Paralelizacion para CUDA y entrenamiento distribuido.

Planificado

Herramientas visuales

Dashboard para monitoreo de entrenamiento en tiempo real.