lovely-tensors

1.4k 22 非常简单 2 次阅读 3天前MIT开发框架

AI 解读由 AI 自动生成，仅供参考

lovely-tensors 是一个让 PyTorch 张量更“人类友好”的开源工具。在调试深度学习代码时，原始张量输出往往是一大堆难以解读的数字，既看不出形状、统计信息，也难以发现 NaN 或无穷值等问题。lovely-tensors 通过简洁的摘要格式自动展示张量的关键信息，比如维度、元素数量、数值范围、均值、标准差，并高亮异常值（如 inf、nan），甚至能一键可视化图像或绘制分布图。它还支持按需切换回原始输出或详细模式，兼顾效率与灵活性。该工具特别适合使用 PyTorch 的开发者和研究人员，尤其在模型调试、数据检查等场景下能显著提升可读性和工作效率。只需一行 monkey_patch()，即可全局优化张量显示体验。

使用场景

计算机视觉研究员小李正在调试一个图像超分辨率模型，频繁检查中间层输出的张量以判断是否出现异常值或维度错误。

没有 lovely-tensors 时

打印张量时只能看到密密麻麻的浮点数，难以快速判断形状（如是否为 [B, C, H, W]）和数据规模。
无法一眼识别是否存在 nan、inf 等异常值，需额外调用 .isnan().any() 等函数排查。
对于接近全零或常量的张量（如梯度消失），原始输出看不出规律，容易误判为正常。
调试图像特征图时，无法直观预览其作为 RGB 图像的可视化效果，需手动写 matplotlib 代码。
小张量（如长度为5的向量）也被截断显示，反而丢失关键细节。

使用 lovely-tensors 后

张量自动显示形状、元素总数和内存占用，如 tensor[3, 196, 196]，一目了然。
异常值直接标注 +Inf! -Inf! NaN!，无需额外检查即可定位数值不稳定问题。
全零张量显示为 all_zeros，常量或稀疏模式也能通过统计摘要（均值、标准差、分布直方图）快速识别。
通过 .rgb 属性一键可视化三通道特征图为图像，加速对生成结果的直观判断。
小张量保留原始数值显示，同时附带统计信息，兼顾细节与概览。

lovely-tensors 让张量“会说话”，将枯燥的数字转化为人类可读的洞察，大幅提升调试效率。

运行环境要求

操作系统

Linux
macOS
Windows

GPU

未说明

内存

未说明

依赖

notes该工具主要用于美化 PyTorch 张量的显示，需配合 PyTorch 使用；可通过 pip、conda 或 mamba 安装；支持对张量进行统计摘要、可视化（如 .rgb、.plt、.chans 等属性）及梯度信息展示；使用 named tensors 属于实验性功能。

python未说明

torch

快速开始

❤️ Lovely Tensors（可爱的张量）

阅读完整文档

安装

pip install lovely-tensors

或

mamba install lovely-tensors

或

conda install -c conda-forge lovely-tensors

使用方法

你调试 PyTorch 代码的频率有多高？你把一个张量（tensor）输出到单元格，然后看到这样的内容：

numbers

tensor([[[-0.3541, -0.3369, -0.4054,  ..., -0.5596, -0.4739,  2.2489],
         [-0.4054, -0.4226, -0.4911,  ..., -0.9192, -0.8507,  2.1633],
         [-0.4739, -0.4739, -0.5424,  ..., -1.0390, -1.0390,  2.1975],
         ...,
         [-0.9020, -0.8335, -0.9363,  ..., -1.4672, -1.2959,  2.2318],
         [-0.8507, -0.7822, -0.9363,  ..., -1.6042, -1.5014,  2.1804],
         [-0.8335, -0.8164, -0.9705,  ..., -1.6555, -1.5528,  2.1119]],

        [[-0.1975, -0.1975, -0.3025,  ..., -0.4776, -0.3725,  2.4111],
         [-0.2500, -0.2325, -0.3375,  ..., -0.7052, -0.6702,  2.3585],
         [-0.3025, -0.2850, -0.3901,  ..., -0.7402, -0.8102,  2.3761],
         ...,
         [-0.4251, -0.2325, -0.3725,  ..., -1.0903, -1.0203,  2.4286],
         [-0.3901, -0.2325, -0.4251,  ..., -1.2304, -1.2304,  2.4111],
         [-0.4076, -0.2850, -0.4776,  ..., -1.2829, -1.2829,  2.3410]],

        [[-0.6715, -0.9853, -0.8807,  ..., -0.9678, -0.6890,  2.3960],
         [-0.7238, -1.0724, -0.9678,  ..., -1.2467, -1.0201,  2.3263],
         [-0.8284, -1.1247, -1.0201,  ..., -1.2641, -1.1596,  2.3786],
         ...,
         [-1.2293, -1.4733, -1.3861,  ..., -1.5081, -1.2641,  2.5180],
         [-1.1944, -1.4559, -1.4210,  ..., -1.6476, -1.4733,  2.4308],
         [-1.2293, -1.5256, -1.5081,  ..., -1.6824, -1.5256,  2.3611]]])

作为人类，看到这么多数字真的对你有帮助吗？

它的形状（shape）是什么？大小（size）是多少？
统计信息如何？
有没有 nan 或 inf 值？
它是不是一张男人拿着丁鲷（tench）的图像？

import lovely_tensors as lt

lt.monkey_patch()

摘要

numbers # torch.Tensor

tensor[3, 196, 196] n=115248 (0.4Mb) x∈[-2.118 |▂▅█▇▂▁▁▂▂▁| 2.640] μ=-0.388 σ=1.073

numbers.rgb

numbers.plt

好多了，对吧？

numbers[1,:6,1] # 如果元素不多，仍然会显示具体数值。

tensor[6] x∈[-0.443, -0.197] μ=-0.311 σ=0.091 [-0.197, -0.232, -0.285, -0.373, -0.443, -0.338]

spicy = numbers[0,:12,0].clone()

spicy[0] *= 10000
spicy[1] /= 10000
spicy[2] = float('inf')
spicy[3] = float('-inf')
spicy[4] = float('nan')

spicy = spicy.reshape((2,6))
spicy # 辛辣内容

tensor[2, 6] n=12 x∈[-3.541e+03, -4.054e-05] μ=-393.842 σ=1.180e+03 +Inf! -Inf! NaN!

torch.zeros(10, 10) # 全零张量 —— 明确显示

tensor[10, 10] n=100 all_zeros

spicy.v # 详细模式（Verbose）

tensor[2, 6] n=12 x∈[-3.541e+03, -4.054e-05] μ=-393.842 σ=1.180e+03 +Inf! -Inf! NaN!
tensor([[-3.5405e+03, -4.0543e-05,         inf,        -inf,         nan, -6.1093e-01],
        [-6.1093e-01, -5.9380e-01, -5.9380e-01, -5.4243e-01, -5.4243e-01, -5.4243e-01]])

spicy.p # 原始方式（Plain old way）

tensor([[-3.5405e+03, -4.0543e-05,         inf,        -inf,         nan, -6.1093e-01],
        [-6.1093e-01, -5.9380e-01, -5.9380e-01, -5.4243e-01, -5.4243e-01, -5.4243e-01]])

梯度（Gradient）

torch.manual_seed(1)


# with config(color=False):
grad = torch.randn((10, 10), requires_grad=True, dtype=torch.float64)
grad_plus_one = grad+1

print(f"Before .backward:\n{grad}\n")

# 对于非叶子节点，除非...
print(f"Before .backward, non-leaf node:\n{grad_plus_one}\n")

grad_plus_one.prod().backward()

grad.grad[0,0] = float("-inf")

print(f"After .backward():\n{grad}\n")

grad.grad.zero_()

print(f"After .zero_() on .grad:\n{grad}")

Before .backward:
tensor[10, 10] f64 n=100 x∈[-3.705 |▁ ▂▂▇█▇█▃▂| 2.537] μ=0.105 σ=1.066 grad=None

Before .backward, non-leaf node:
tensor[10, 10] f64 n=100 x∈[-2.705 |▁ ▂▂▇█▇█▃▂| 3.537] μ=1.105 σ=1.066 grad (non-leaf) AddBackward0

After .backward():
tensor[10, 10] f64 n=100 x∈[-3.705 |▁ ▂▂▇█▇█▃▂| 2.537] μ=0.105 σ=1.066 grad={ x∈[-1.351e-05 |▁▁▁▁  ▁█▁▁| 4.236e-06] μ=-1.145e-07 σ=2.284e-06 -Inf! }

After .zero_() on .grad:
tensor[10, 10] f64 n=100 x∈[-3.705 |▁ ▂▂▇█▇█▃▂| 2.537] μ=0.105 σ=1.066 grad={ all_zeros }

命名维度（Named dimensions）

named_numbers = numbers.rename("C", "H","W")
named_numbers

/home/xl0/miniforge3/envs/torch/lib/python3.13/site-packages/torch/_tensor.py:1630: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at /pytorch/c10/core/TensorImpl.h:1971.)
  return super().rename(names)

tensor[C=3, H=196, W=196] n=115248 (0.4Mb) x∈[-2.118 |▂▅█▇▂▁▁▂▂▁| 2.640] μ=-0.388 σ=1.073

更深入（Going `.deeper`）

numbers.deeper

tensor[3, 196, 196] n=115248 (0.4Mb) x∈[-2.118 |▂▅█▇▂▁▁▂▂▁| 2.640] μ=-0.388 σ=1.073
  tensor[196, 196] n=38416 x∈[-2.118 |▂▃▅█▂▁▁▂▃▂| 2.249] μ=-0.324 σ=1.036
  tensor[196, 196] n=38416 x∈[-1.966 |▂▃▅█▁▁▁▁▂▁| 2.429] μ=-0.274 σ=0.973
  tensor[196, 196] n=38416 x∈[-1.804 |▃█▂▁▁▁▁▁▂▁| 2.640] μ=-0.567 σ=1.178

# 如果需要，你可以继续深入

并且我们可以将 `.deeper` 与命名维度（named dimensions）一起使用。

named_numbers.deeper(2)

tensor[C=3, H=196, W=196] n=115248 (0.4Mb) x∈[-2.118 |▂▅█▇▂▁▁▂▂▁| 2.640] μ=-0.388 σ=1.073
  tensor[H=196, W=196] n=38416 x∈[-2.118 |▂▃▅█▂▁▁▂▃▂| 2.249] μ=-0.324 σ=1.036
    tensor[W=196] x∈[-1.912 |▃▁▂█▃    ▁| 2.249] μ=-0.673 σ=0.522
    tensor[W=196] x∈[-1.861 |▂▂██▁    ▁| 2.163] μ=-0.738 σ=0.418
    tensor[W=196] x∈[-1.758 |▂▂█▂▁    ▁| 2.198] μ=-0.806 σ=0.397
    tensor[W=196] x∈[-1.656 |▂▆█▁▁    ▁| 2.249] μ=-0.849 σ=0.369
    tensor[W=196] x∈[-1.673 |▁▆█▁▁▁   ▁| 2.198] μ=-0.857 σ=0.357
    tensor[W=196] x∈[-1.656 |▂██▂▁▁   ▁| 2.146] μ=-0.848 σ=0.372
    tensor[W=196] x∈[-1.433 |▃█▅▁▁▁▁  ▁| 2.215] μ=-0.784 σ=0.397
    tensor[W=196] x∈[-1.279 |▆█▄▁▁▁▁▁ ▁| 2.249] μ=-0.695 σ=0.486
    tensor[W=196] x∈[-1.364 |▆██▂▁▁▁▁▁▁| 2.249] μ=-0.637 σ=0.539
    ...
  tensor[H=196, W=196] n=38416 x∈[-1.966 |▂▃▅█▁▁▁▁▂▁| 2.429] μ=-0.274 σ=0.973
    tensor[W=196] x∈[-1.861 |▂▁▁█▁    ▁| 2.411] μ=-0.529 σ=0.556
    tensor[W=196] x∈[-1.826 |▁▁▁█     ▁| 2.359] μ=-0.562 σ=0.473
    tensor[W=196] x∈[-1.756 |▂▁▃█▁    ▁| 2.376] μ=-0.622 σ=0.458
    tensor[W=196] x∈[-1.633 |▂▂█▄     ▁| 2.429] μ=-0.664 σ=0.430
    tensor[W=196] x∈[-1.651 |▂▂█▄     ▁| 2.376] μ=-0.669 σ=0.399
    tensor[W=196] x∈[-1.633 |▂▃█▃▁    ▁| 2.376] μ=-0.701 σ=0.391
    tensor[W=196] x∈[-1.563 |▂▃█▂▁    ▁| 2.429] μ=-0.670 σ=0.380
    tensor[W=196] x∈[-1.475 |▂▄█▁▁    ▁| 2.429] μ=-0.616 σ=0.386
    tensor[W=196] x∈[-1.511 |▁▄█▁▁▁   ▁| 2.429] μ=-0.593 σ=0.399
    ...
  tensor[H=196, W=196] n=38416 x∈[-1.804 |▃█▂▁▁▁▁▁▂▁| 2.640] μ=-0.567 σ=1.178
    tensor[W=196] x∈[-1.717 |▃█▆      ▁| 2.396] μ=-0.982 σ=0.350
    tensor[W=196] x∈[-1.752 |▂█▄      ▁| 2.326] μ=-1.034 σ=0.314
    tensor[W=196] x∈[-1.648 |▂█▁▁     ▁| 2.379] μ=-1.086 σ=0.314
    tensor[W=196] x∈[-1.630 |▃█▁      ▁| 2.466] μ=-1.121 σ=0.305
    tensor[W=196] x∈[-1.717 |▂█▁      ▁| 2.448] μ=-1.120 σ=0.302
    tensor[W=196] x∈[-1.717 |▃█▁▁     ▁| 2.431] μ=-1.166 σ=0.314
    tensor[W=196] x∈[-1.560 |█▆▁▁     ▁| 2.448] μ=-1.124 σ=0.326
    tensor[W=196] x∈[-1.421 |█▂▁▁ ▁   ▁| 2.431] μ=-1.064 σ=0.383
    tensor[W=196] x∈[-1.526 |██▁▁▁ ▁  ▁| 2.396] μ=-1.047 σ=0.417
    ...

现在用 `.rgb` 颜色显示

关键问题来了——这是我们要找的人吗？

numbers.rgb

也许吧？ 看起来有人对他做了归一化处理。

in_stats = ( (0.485, 0.456, 0.406),     # 均值（mean）
             (0.229, 0.224, 0.225) )    # 标准差（std）

# numbers.rgb(in_stats, cl=True) # 用于通道在后的输入格式（channel-last）
numbers.rgb(in_stats)

# numbers.rgb(denorm="imagenet") # 同上
# numbers.rgb(denorm="symmetric") # 输入范围为 [-1 .. 1]
# numbers.rgb(denorm="minmax") # 使用每个通道的最小/最大值将输入缩放到 [0..1]

没错，他就是我们的英雄——Tenchman！

用 `.plt` 绘制统计信息

(numbers+3).plt(center="mean", max_s=1000)

(numbers).plt

(numbers+3).plt(center="range")

查看 `.chans`

# .chans 会将 [-1,1] 范围内的值映射为颜色。
# 将我们的值缩放到该范围内以避免裁剪（clipping）。
mean = torch.tensor(in_stats[0])[:,None,None]
std = torch.tensor(in_stats[1])[:,None,None]
numbers_01 = (numbers*std + mean)
numbers_01

tensor[3, 196, 196] n=115248 (0.4Mb) x∈[0. |▃▇▆█▂▁▁▂▃▂| 1.000] μ=0.361 σ=0.248

numbers_01.chans

让我们试试卷积神经网络（Convolutional Neural Network）

from torchvision.models import vgg11

features: torch.nn.Sequential = vgg11().features

# 我已将前5层保存在 "features.pt" 中
_ = features.load_state_dict(torch.load("../features.pt", weights_only=True), strict=False)

# VGG11 第二个最大池化层（max pool layer）的激活值
acts = (features[:6](numbers[None])[0]/2) # /2 以减少裁剪
acts

tensor[128, 49, 49] n=307328 (1.2Mb) x∈[0. |█▁▁▁▁▁▁▁▁ | 12.508] μ=0.367 σ=0.634 grad (non-leaf) DivBackward0

acts[:4].chans(cmap="coolwarm", scale=4)

分组（Grouping）

# 创建8张亮度逐渐增强的图像，并以 2x2x2 的方式堆叠。
eight_images = (torch.stack([numbers]*8)
                    .add(torch.linspace(-3, 3, 8)[:,None,None,None])
                    .mul(torch.tensor(in_stats[1])[:,None,None])
                    .add(torch.tensor(in_stats[0])[:,None,None])
                    .clamp(0,1)
                    .view(2,2,2,3,196,196)
)
eight_images

tensor[2, 2, 2, 3, 196, 196] n=921984 (3.5Mb) x∈[0. |█▂▂▂▂▂▂▂▂▄| 1.000] μ=0.411 σ=0.369

eight_images.rgb

# VGG11 第二个卷积层的权重
features[3].weight

Parameter[128, 64, 3, 3] n=73728 (0.3Mb) x∈[-0.783 |  ▁▁██▁▁▁▁| 0.776] μ=-0.004 σ=0.065 grad=None

我希望 ±2σ 落在 [-1..1] 范围内

weights = features[3].weight.data
weights = weights / (2*2*weights.std()) # *2 是因为我们要在两侧都保留 2σ，总共是 4σ
# weights += weights.std() * 2
weights.plt

# VGG11 第二个卷积层（64通道 → 128通道）的权重，
# 按输出通道分组显示。
weights.chans(frame_px=1, gutter_px=0)

有点难以看清。放大10倍，但只显示前4个滤波器。

weights[:4].chans(frame_px=1, gutter_px=0, scale=10)

选项 | 文档

from lovely_tensors import set_config, config, lovely, get_config

set_config(precision=1, sci_mode=True, color=False)
torch.tensor([1, 2, torch.nan])

tensor[3] μ=1.5e+00 σ=7.1e-01 NaN! [1.0e+00, 2.0e+00, nan]

set_config(precision=None, sci_mode=None, color=None) # None 表示重置为默认值

print(torch.tensor([1., 2]))
# 或者使用 config 上下文管理器。
with config(sci_mode=True, precision=5):
    print(torch.tensor([1., 2]))

print(torch.tensor([1., 2]))

tensor[2] μ=1.500 σ=0.707 [1.000, 2.000]
tensor[2] μ=1.50000e+00 σ=7.07107e-01 [1.00000e+00, 2.00000e+00]
tensor[2] μ=1.500 σ=0.707 [1.000, 2.000]

无需 `.monkey_patch`

lt.lovely(spicy)

tensor[2, 6] n=12 x∈[-3.541e+03, -4.054e-05] μ=-393.842 σ=1.180e+03 +Inf! -Inf! NaN!

lt.lovely(spicy, verbose=True)

tensor[2, 6] n=12 x∈[-3.541e+03, -4.054e-05] μ=-393.842 σ=1.180e+03 +Inf! -Inf! NaN!
tensor([[-3.5405e+03, -4.0543e-05,         inf,        -inf,         nan, -6.1093e-01],
        [-6.1093e-01, -5.9380e-01, -5.9380e-01, -5.4243e-01, -5.4243e-01, -5.4243e-01]])

lt.lovely(numbers, depth=1)

tensor[3, 196, 196] n=115248 (0.4Mb) x∈[-2.118 |▂▅█▇▂▁▁▂▂▁| 2.640] μ=-0.388 σ=1.073
  tensor[196, 196] n=38416 x∈[-2.118 |▂▃▅█▂▁▁▂▃▂| 2.249] μ=-0.324 σ=1.036
  tensor[196, 196] n=38416 x∈[-1.966 |▂▃▅█▁▁▁▁▂▁| 2.429] μ=-0.274 σ=0.973
  tensor[196, 196] n=38416 x∈[-1.804 |▃█▂▁▁▁▁▁▂▁| 2.640] μ=-0.567 σ=1.178

lt.rgb(numbers, in_stats)

lt.plot(numbers, center="mean")

lt.chans(numbers_01)

Matplotlib 集成 | 文档

numbers.rgb(in_stats).fig # matplotlib figure（图形对象）

(numbers*0.3+0.5).chans.fig # matplotlib figure（图形对象）

numbers.plt.fig.savefig('pretty.svg') # 保存图形

!file pretty.svg; rm pretty.svg

pretty.svg: SVG Scalable Vector Graphics image（SVG 可缩放矢量图形图像）

向现有 Axes（坐标轴）添加内容

fig = plt.figure(figsize=(8,3))
fig.set_constrained_layout(True)
gs = fig.add_gridspec(2,2)
ax1 = fig.add_subplot(gs[0, :])
ax2 = fig.add_subplot(gs[1, 0])
ax3 = fig.add_subplot(gs[1,1:])

ax2.set_axis_off()
ax3.set_axis_off()

numbers_01.plt(ax=ax1)
numbers_01.rgb(ax=ax2)
numbers_01.chans(ax=ax3);

torch.compile()

直接可用。

def func(x):
    return x*2

if torch.__version__ >= "2.0":
    func = torch.compile(func)

func(torch.tensor([1,2,3]))

tensor[3] i64 x∈[2, 6] μ=4.000 σ=2.000 [2, 4, 6]

导入钩子（Import hook）

Lovely tensors 安装了一个导入钩子。设置环境变量 LOVELY_TENSORS=1，它将自动加载，无需修改代码：

注意：现在可以全局设置该变量。安装的导入钩子仅在导入 torch 时触发。

import torch

x = torch.randn(4, 16)
print(x)

LOVELY_TENSORS=1 python test.py

x: tensor[4, 16] n=64 x∈[-1.652, 1.813] μ=-0.069 σ=0.844

这与 Better Exceptions 结合使用尤其有用：

import torch

x = torch.randn(4, 16)
print(f"x: {x}")

w = torch.randn(15, 8) 
y = torch.matmul(x, w) # 维度不匹配

BETTER_EXCEPTIONS=1  LOVELY_TENSORS=1 python test.py

x: tensor[4, 16] n=64 x∈[-1.834, 2.421] μ=0.103 σ=0.896
Traceback (most recent call last):
  File "/home/xl0/work/projects/lovely-tensors/test.py", line 7, in <module>
    y = torch.matmul(x, w)
        │            │  └ tensor[15, 8] n=120 x∈[-2.355, 2.165] μ=0.142 σ=0.989
        │            └ tensor[4, 16] n=64 x∈[-1.834, 2.421] μ=0.103 σ=0.896
        └ <module 'torch' from '/home/xl0/mambaforge/envs/torch25-py312/lib/python3.12/site-packages/torch/__init__.py'>
RuntimeError: mat1 and mat2 shapes cannot be multiplied (4x16 and 15x8)

lovely-tensors 快速上手指南

环境准备

操作系统：支持 Linux、macOS 和 Windows
Python 版本：建议 Python 3.8 或更高版本
依赖库：
- PyTorch（torch）
- 可选：matplotlib（用于 .plt 和 .rgb 可视化功能）
- 可选：numpy

💡 提示：若使用国内网络，建议配置 PyPI 或 conda 的国内镜像源以加速安装。

安装步骤

推荐使用以下任一方式安装：

pip install lovely-tensors

或使用 mamba（更快的 conda 替代）：

mamba install lovely-tensors

或通过 conda-forge 渠道：

conda install -c conda-forge lovely-tensors

🇨🇳 国内用户可添加清华源等镜像加速 conda 安装：
conda install -c https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/ lovely-tensors

基本使用

只需两行代码即可启用增强版张量显示：

import lovely_tensors as lt
lt.monkey_patch()

启用后，PyTorch 张量在 Jupyter Notebook 或 Python REPL 中会自动显示简洁摘要，例如：

import torch
x = torch.randn(3, 196, 196)
x  # 输出示例：tensor[3, 196, 196] n=115248 x∈[-2.1 |▂▅█▇▂▁▁▂▂▁| 2.6] μ=-0.39 σ=1.07

常用属性（启用后可用）：

x.rgb：将张量作为 RGB 图像可视化（适用于 [C,H,W] 格式）
x.plt：绘制张量值的分布直方图
x.chans：按通道可视化（适合特征图）
x.deeper：递归显示各维度子张量的统计信息
x.v：显示详细数值（verbose 模式）
x.p：恢复原始 PyTorch 默认输出格式

示例：

x.rgb  # 自动渲染图像
x.plt  # 显示分布图

版本历史

0.1.22

0.1.21

0.1.20

0.1.19

0.1.18

0.1.17

0.1.16

0.1.14

0.1.13

0.1.12

0.1.11

0.1.10

0.1.7

0.1.6

0.1.5

0.1.4

0.1.3

0.1.0

0.0.9

0.0.8

常见问题

如何在非 IPython 环境（如 PyCharm 或 VSCode 调试器）中使用 lovely-tensors 的图像显示功能？

在 VSCode 调试时启用 lovely-tensors 后，变量检查变得非常慢，如何解决？

能否让 lovely-tensors 在标准 Python 脚本或调试会话中通过 matplotlib 自动显示图像？

lovely-tensors 是否支持 NumPy 数组？

导入 lovely-tensors 很慢，因为它加载了 IPython 和 matplotlib，能否延迟加载？

如何在张量 repr 中显示其占用的内存大小（如 KB、MB）？

相似工具推荐

stable-diffusion-webui

stable-diffusion-webui 是一个基于 Gradio 构建的网页版操作界面，旨在让用户能够轻松地在本地运行和使用强大的 Stable Diffusion 图像生成模型。它解决了原始模型依赖命令行、操作门槛高且功能分散的痛点，将复杂的 AI 绘图流程整合进一个直观易用的图形化平台。无论是希望快速上手的普通创作者、需要精细控制画面细节的设计师，还是想要深入探索模型潜力的开发者与研究人员，都能从中获益。其核心亮点在于极高的功能丰富度：不仅支持文生图、图生图、局部重绘（Inpainting）和外绘（Outpainting）等基础模式，还独创了注意力机制调整、提示词矩阵、负向提示词以及“高清修复”等高级功能。此外，它内置了 GFPGAN 和 CodeFormer 等人脸修复工具，支持多种神经网络放大算法，并允许用户通过插件系统无限扩展能力。即使是显存有限的设备，stable-diffusion-webui 也提供了相应的优化选项，让高质量的 AI 艺术创作变得触手可及。

★ 162.1k|★★★☆☆|今天

开发框架图像Agent

everything-claude-code

everything-claude-code 是一套专为 AI 编程助手（如 Claude Code、Codex、Cursor 等）打造的高性能优化系统。它不仅仅是一组配置文件，而是一个经过长期实战打磨的完整框架，旨在解决 AI 代理在实际开发中面临的效率低下、记忆丢失、安全隐患及缺乏持续学习能力等核心痛点。通过引入技能模块化、直觉增强、记忆持久化机制以及内置的安全扫描功能，everything-claude-code 能显著提升 AI 在复杂任务中的表现，帮助开发者构建更稳定、更智能的生产级 AI 代理。其独特的“研究优先”开发理念和针对 Token 消耗的优化策略，使得模型响应更快、成本更低，同时有效防御潜在的攻击向量。这套工具特别适合软件开发者、AI 研究人员以及希望深度定制 AI 工作流的技术团队使用。无论您是在构建大型代码库，还是需要 AI 协助进行安全审计与自动化测试，everything-claude-code 都能提供强大的底层支持。作为一个曾荣获 Anthropic 黑客大奖的开源项目，它融合了多语言支持与丰富的实战钩子（hooks），让 AI 真正成长为懂上

★ 140.4k|★★☆☆☆|今天

开发框架Agent语言模型

ComfyUI

ComfyUI 是一款功能强大且高度模块化的视觉 AI 引擎，专为设计和执行复杂的 Stable Diffusion 图像生成流程而打造。它摒弃了传统的代码编写模式，采用直观的节点式流程图界面，让用户通过连接不同的功能模块即可构建个性化的生成管线。这一设计巧妙解决了高级 AI 绘图工作流配置复杂、灵活性不足的痛点。用户无需具备编程背景，也能自由组合模型、调整参数并实时预览效果，轻松实现从基础文生图到多步骤高清修复等各类复杂任务。ComfyUI 拥有极佳的兼容性，不仅支持 Windows、macOS 和 Linux 全平台，还广泛适配 NVIDIA、AMD、Intel 及苹果 Silicon 等多种硬件架构，并率先支持 SDXL、Flux、SD3 等前沿模型。无论是希望深入探索算法潜力的研究人员和开发者，还是追求极致创作自由度的设计师与资深 AI 绘画爱好者，ComfyUI 都能提供强大的支持。其独特的模块化架构允许社区不断扩展新功能，使其成为当前最灵活、生态最丰富的开源扩散模型工具之一，帮助用户将创意高效转化为现实。

★ 107.7k|★★☆☆☆|2天前

开发框架图像Agent

NextChat

NextChat 是一款轻量且极速的 AI 助手，旨在为用户提供流畅、跨平台的大模型交互体验。它完美解决了用户在多设备间切换时难以保持对话连续性，以及面对众多 AI 模型不知如何统一管理的痛点。无论是日常办公、学习辅助还是创意激发，NextChat 都能让用户随时随地通过网页、iOS、Android、Windows、MacOS 或 Linux 端无缝接入智能服务。这款工具非常适合普通用户、学生、职场人士以及需要私有化部署的企业团队使用。对于开发者而言，它也提供了便捷的自托管方案，支持一键部署到 Vercel 或 Zeabur 等平台。 NextChat 的核心亮点在于其广泛的模型兼容性，原生支持 Claude、DeepSeek、GPT-4 及 Gemini Pro 等主流大模型，让用户在一个界面即可自由切换不同 AI 能力。此外，它还率先支持 MCP（Model Context Protocol）协议，增强了上下文处理能力。针对企业用户，NextChat 提供专业版解决方案，具备品牌定制、细粒度权限控制、内部知识库整合及安全审计等功能，满足公司对数据隐私和个性化管理的高标准要求。

★ 87.6k|★★☆☆☆|昨天

开发框架语言模型

ML-For-Beginners

ML-For-Beginners 是由微软推出的一套系统化机器学习入门课程，旨在帮助零基础用户轻松掌握经典机器学习知识。这套课程将学习路径规划为 12 周，包含 26 节精炼课程和 52 道配套测验，内容涵盖从基础概念到实际应用的完整流程，有效解决了初学者面对庞大知识体系时无从下手、缺乏结构化指导的痛点。无论是希望转型的开发者、需要补充算法背景的研究人员，还是对人工智能充满好奇的普通爱好者，都能从中受益。课程不仅提供了清晰的理论讲解，还强调动手实践，让用户在循序渐进中建立扎实的技能基础。其独特的亮点在于强大的多语言支持，通过自动化机制提供了包括简体中文在内的 50 多种语言版本，极大地降低了全球不同背景用户的学习门槛。此外，项目采用开源协作模式，社区活跃且内容持续更新，确保学习者能获取前沿且准确的技术资讯。如果你正寻找一条清晰、友好且专业的机器学习入门之路，ML-For-Beginners 将是理想的起点。

★ 85k|★★☆☆☆|今天

图像数据工具视频

ragflow

RAGFlow 是一款领先的开源检索增强生成（RAG）引擎，旨在为大语言模型构建更精准、可靠的上下文层。它巧妙地将前沿的 RAG 技术与智能体（Agent）能力相结合，不仅支持从各类文档中高效提取知识，还能让模型基于这些知识进行逻辑推理和任务执行。在大模型应用中，幻觉问题和知识滞后是常见痛点。RAGFlow 通过深度解析复杂文档结构（如表格、图表及混合排版），显著提升了信息检索的准确度，从而有效减少模型“胡编乱造”的现象，确保回答既有据可依又具备时效性。其内置的智能体机制更进一步，使系统不仅能回答问题，还能自主规划步骤解决复杂问题。这款工具特别适合开发者、企业技术团队以及 AI 研究人员使用。无论是希望快速搭建私有知识库问答系统，还是致力于探索大模型在垂直领域落地的创新者，都能从中受益。RAGFlow 提供了可视化的工作流编排界面和灵活的 API 接口，既降低了非算法背景用户的上手门槛，也满足了专业开发者对系统深度定制的需求。作为基于 Apache 2.0 协议开源的项目，它正成为连接通用大模型与行业专有知识之间的重要桥梁。

★ 77.1k|★★★☆☆|2天前

Agent图像开发框架