from core.tensor import Tensor, tensor, randn, zeros, ones

# 创建张量
a = tensor([[1, 2, 3], [4, 5, 6]], requires_grad=True)
b = tensor([[2, 3], [4, 5], [6, 7]], requires_grad=True)

# 矩阵乘法
c = a @ b
print(c)

# 反向传播
loss = c.sum()
loss.backward()
print(a.grad.data)  # 查看梯度

from core.nn.tensor_nn import Sequential, Linear, ReLU, MSELoss, Adam
from core.tensor import randn

# 创建模型
model = Sequential(
    Linear(10, 20),
    ReLU(),
    Linear(20, 1)
)

# 创建数据
X = randn(100, 10)
y = randn(100, 1)

# 定义损失函数和优化器
criterion = MSELoss()
optimizer = Adam(model.parameters(), lr=0.01)

# 训练循环
for epoch in range(100):
    # 前向传播
    output = model(X)
    loss = criterion(output, y)
    
    # 反向传播
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if epoch % 10 == 0:
        print(f'Epoch {epoch}, Loss: {loss.data:.4f}')

from core.tensor import tensor

# 创建CPU张量
cpu_tensor = tensor([[1, 2], [3, 4]], requires_grad=True)

# 移动到GPU
gpu_tensor = cpu_tensor.cuda()

# GPU上进行运算
result = gpu_tensor @ gpu_tensor.T

# 移回CPU
cpu_result = result.cpu()

from core.utils.memory_utils import memory_context, memory_summary

# 使用内存上下文管理器
with memory_context(monitor=True, clear_on_exit=True):
    large_tensor = randn(1000, 1000)
    # 自动清理内存

# 查看内存使用情况
memory_summary()

from core.tensor import Tensor, tensor, zeros, ones, randn, eye

# 从数据创建
a = tensor([1, 2, 3], requires_grad=True)
b = tensor([[1, 2], [3, 4]], device='cuda')

# 特殊张量
zeros_tensor = zeros(3, 4)
ones_tensor = ones(2, 3)
random_tensor = randn(5, 5)
identity_matrix = eye(4)

print(a.shape)      # 形状
print(a.ndim)       # 维度数
print(a.size)       # 元素总数
print(a.dtype)      # 数据类型
print(a.device)     # 设备

# 基础运算
c = a + b           # 加法
c = a * b           # 乘法
c = a / b           # 除法
c = a ** 2          # 幂运算

# 矩阵运算
c = a @ b           # 矩阵乘法
c = a.T             # 转置

# 聚合运算
c = a.sum()         # 求和
c = a.mean(axis=1)  # 按轴求均值

# 激活函数
c = a.relu()        # ReLU
c = a.sigmoid()     # Sigmoid
c = a.tanh()        # Tanh

# 改变形状
b = a.reshape(2, 3)

# 转置
b = a.transpose()
b = a.T

# 维度操作
b = a.sum(axis=0, keepdims=True)

from core.nn.tensor_nn import Linear, ReLU, Sigmoid, BatchNorm1d, Dropout
from core.nn.modules.conv import Conv2d
from core.nn.modules.rnn import RNN, LSTM

# 线性层
linear = Linear(in_features=10, out_features=5)

# 激活函数
relu = ReLU()
sigmoid = Sigmoid()

# 批归一化
bn = BatchNorm1d(num_features=5)

# Dropout
dropout = Dropout(p=0.5)

# 卷积层
conv = Conv2d(in_channels=3, out_channels=64, kernel_size=3)

# 循环神经网络
rnn = RNN(input_size=128, hidden_size=256, num_layers=2)
lstm = LSTM(input_size=128, hidden_size=256, num_layers=2)

from core.nn.tensor_nn import Sequential

model = Sequential(
    Linear(784, 128),
    ReLU(),
    BatchNorm1d(128),
    Dropout(0.2),
    Linear(128, 64),
    ReLU(),
    Linear(64, 10)
)

from core.nn.tensor_nn import MSELoss, CrossEntropyLoss, SGD, Adam
from core.nn.loss import BCEWithLogitsLoss

# 损失函数
mse_loss = MSELoss()
ce_loss = CrossEntropyLoss()
bce_loss = BCEWithLogitsLoss()

# 优化器
sgd = SGD(model.parameters(), lr=0.01, momentum=0.9)
adam = Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999))

from core.utils.memory_utils import get_memory_monitor, memory_summary

monitor = get_memory_monitor()
usage = monitor.get_memory_usage()
memory_summary()

from core.utils.memory_utils import get_memory_pool

pool = get_memory_pool('cpu')
allocated_memory = pool.allocate(1000000, np.float32)

from core.utils.memory_utils import memory_context

with memory_context(monitor=True, clear_on_exit=True):
    # 在此上下文中的内存使用会被监控
    # 退出时自动清理
    pass