Documentacion
Explora, Aprende, Entrena. Utiliza el panel izquierdo para navegar por el ecosistema de T-Tensor. A la derecha, encontrarás la guía definitiva de cada módulo con ejemplos prácticos diseñados para arrancar tu próximo gran proyecto de Deep Learning sin fricciones.
Enumera para seleccionar donde se ejecutan tensores y operaciones.
from ttensor import Device, Tensor
x = Tensor(2, 2, Device.GPU, True)
x = Tensor(2, 2, Device.CPU, False)
x.fill(1.0)
x = x.to_gpu()
x = x.to_cpu()
Gestiona GPU activa, informacion de hardware y disponibilidad de VRAM.
from ttensor import DeviceManager
DeviceManager.initialize()
DeviceManager.print_report()
info = DeviceManager.get_info()
print(info.name)
DeviceManager.initialize(preferred_device_id=0)
DeviceManager.set_device(0)
ok = DeviceManager.has_enough_vram(256 * 1024 * 1024)
print("VRAM suficiente:", ok)
Estructura base para datos y autograd dinamico en CPU/GPU.
from ttensor import Tensor, Device
a = Tensor.from_list([1, 2, 3, 4], rows=2, cols=2, device=Device.CPU, requires_grad=True)
b = Tensor.from_list([5, 6, 7, 8], rows=2, cols=2, device=Device.CPU, requires_grad=True)
c = a @ b
c.print()
x = Tensor(2, 2, Device.GPU, True)
x.fill_random(-0.1, 0.1)
z = Tensor.relu(x)
loss = Tensor.mean(z)
loss.backward()
print("grad listo:", x.grad is not None)
Clase base para capas y modelos. Define la interfaz comun de entrenamiento.
# Se usa como base al crear capas personalizadas
class MyLayer(Module):
def forward(self, input):
return input
model.save("mi_modelo.tt")
model.load("mi_modelo.tt")
model.zero_grad()
Capa densa que aplica transformacion lineal X @ W + b.
from ttensor import Linear, Device
fc1 = Linear(16, 32, device=Device.GPU)
output = fc1(input_tensor)
fc1 = Linear(4, 16)
fc2 = Linear(16, 3)
h = fc1(x)
y = fc2(h)
Funciones de activacion para no linealidad y salida de clasificacion.
from ttensor import ReLU, Sigmoid, Softmax
act1 = ReLU()
act2 = Sigmoid()
act3 = Softmax()
h = ReLU()(hidden)
prob_bin = Sigmoid()(logit_bin)
prob_multi = Softmax()(logits_multi)
Encadena capas en orden para construir una red de forma rapida.
from ttensor import Sequential, Linear, ReLU, Sigmoid
model = Sequential([
Linear(2, 16),
ReLU(),
Linear(16, 1),
Sigmoid(),
])
from ttensor import Softmax
model_cls = Sequential([
Linear(4, 32),
ReLU(),
Linear(32, 3),
Softmax(),
])
Optimizador clasico de descenso por gradiente estocastico.
from ttensor import SGD
optimizer = SGD(model.parameters(), lr=0.01)
optimizer.zero_grad()
optimizer.step()
pred = model(x)
loss = criterion.forward(pred, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
Optimizador adaptativo recomendado para la mayoria de tareas iniciales.
from ttensor import Adam
optimizer = Adam(model.parameters(), lr=0.001)
optimizer.zero_grad()
optimizer.step()
optimizer = Adam(model.parameters(), lr=0.0005)
for _ in range(10):
pred = model(x)
loss = criterion.forward(pred, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
Funcion de perdida para problemas de regresion.
from ttensor import MSELoss
criterion = MSELoss()
loss = criterion.forward(pred, y)
pred = model(x_reg)
target = y_reg
criterion = MSELoss()
loss = criterion.forward(pred, target)
Funcion de perdida para clasificacion multiclase con objetivo one-hot.
from ttensor import CrossEntropyLoss
criterion = CrossEntropyLoss()
loss = criterion.forward(pred, y_one_hot)
criterion = CrossEntropyLoss()
pred = model(x_batch) # salida softmax/logits
loss = criterion.forward(pred, y3_one_hot)
Carga datasets desde CSV indicando columnas de etiqueta.
from ttensor import CSVDataset, Device
dataset = CSVDataset("data/train.csv", label_cols=1, device=Device.GPU)
dataset2 = CSVDataset("data/multilabel.csv", label_cols=2, device=Device.CPU)
Itera mini-batches para entrenamiento con opcion de barajado.
from ttensor import DataLoader
loader = DataLoader(dataset, batch_size=32, shuffle=True)
loader.reset()
while loader.has_next():
xb, yb = loader.next_batch()
val_loader = DataLoader(dataset, batch_size=64, shuffle=False)
val_loader.reset()
while val_loader.has_next():
xv, yv = val_loader.next_batch()
Flujo base recomendado: forward, perdida, zero_grad, backward y step.
for epoch in range(num_epochs):
pred = model(x)
loss = criterion.forward(pred, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
for epoch in range(num_epochs):
loader.reset()
while loader.has_next():
xb, yb = loader.next_batch()
pred = model(xb)
loss = criterion.forward(pred, yb)
optimizer.zero_grad()
loss.backward()
optimizer.step()
Script base de puesta en marcha usando DeviceManager, Tensor, Sequential, Linear, ReLU, Softmax, CrossEntropyLoss, Adam, y flujo de entrenamiento completo.
from ttensor import (
Device,
DeviceManager,
Tensor,
Sequential,
Linear,
ReLU,
Softmax,
CrossEntropyLoss,
Adam,
)
# 1) Inicializar dispositivo (CPU/GPU)
DeviceManager.initialize(preferred_device_id=0)
DeviceManager.print_report()
device = Device.GPU
# 2) Crear datos de ejemplo (X: 4x2, y one-hot: 4x2)
X = Tensor.from_list([
0.0, 0.0,
0.0, 1.0,
1.0, 0.0,
1.0, 1.0,
], rows=4, cols=2, device=device, requires_grad=False)
y = Tensor.from_list([
1.0, 0.0,
0.0, 1.0,
0.0, 1.0,
1.0, 0.0,
], rows=4, cols=2, device=device, requires_grad=False)
# 3) Definir modelo (Module/Sequential + capas nn)
model = Sequential([
Linear(2, 8, device=device),
ReLU(),
Linear(8, 2, device=device),
Softmax(),
])
# 4) Definir perdida y optimizador
criterion = CrossEntropyLoss()
optimizer = Adam(model.parameters(), lr=0.01)
# 5) Entrenamiento
num_epochs = 500
for epoch in range(num_epochs):
pred = model(X) # forward
loss = criterion.forward(pred, y) # loss
optimizer.zero_grad() # limpiar gradientes
loss.backward() # backward autograd
optimizer.step() # actualizar pesos
if epoch % 100 == 0:
print(f"epoch={epoch} loss={loss.item():.6f}")
# 6) Inferencia
pred_final = model(X)
print("Predicciones:", pred_final.tolist())
# 7) Opcional: guardar/cargar modelo
model.save("modelo_demo.tt")
# model.load("modelo_demo.tt")