讲解Only tensors or tuples of tensors can be output from traced functions

野性酷女 2024-02-05 20:04 53阅读 0赞

引发错误的原因

解决方法

1. 检查函数的返回值类型

2. 将非张量类型的对象转换为张量

3. 使用张量元组返回多个对象

总结

--------------------

## 讲解Only tensors or tuples of tensors can be output from traced functions ##

在PyTorch中，当我们使用**torch.jit.trace**函数对模型进行跟踪时，可能会遇到一个错误消息：**Only tensors or tuples of tensors can be output from traced functions**（只有张量或张量元组可以从跟踪函数中输出）。本文将详细讲解这个错误消息的含义以及如何解决它。

### 引发错误的原因 ###

这个错误消息的出现是因为在跟踪函数中尝试返回非张量类型的对象。跟踪过程会将模型的计算图转换为JIT表达，从而提高模型的性能。然而，由于JIT引擎的限制，只有张量或张量元组才能从跟踪函数中返回。

### 解决方法 ###

解决这个问题的方法很简单，我们需要确保跟踪函数只返回张量或张量元组。以下是几种解决方案：

#### 1. 检查函数的返回值类型 ####

首先，我们需要检查跟踪函数的返回值是否为正确的类型。确保只返回张量或张量元组，而不是其他非张量类型的对象。

pythonCopy code
    import torch
    @torch.jit.script
    def my_traced_function(input):
        # 模型计算逻辑，最后返回张量或张量元组
        return output_tensor

#### 2. 将非张量类型的对象转换为张量 ####

如果在计算图中需要返回一个非张量类型的对象，我们可以通过将其转换为张量来解决这个问题。

pythonCopy code
    import torch
    @torch.jit.script
    def my_traced_function(input):
        # 需要返回一个非张量类型的对象
        non_tensor_output = compute_something()
        
        # 将非张量类型的对象转换为张量
        tensor_output = torch.tensor(non_tensor_output)
        
        # 返回张量或张量元组
        return tensor_output

#### 3. 使用张量元组返回多个对象 ####

如果需要返回多个对象，其中一个是非张量类型的对象，可以使用张量元组来返回。

pythonCopy code
    import torch
    @torch.jit.script
    def my_traced_function(input):
        # 计算相关操作
        tensor_output = compute_tensor_output()
        non_tensor_output = compute_non_tensor_output()
        
        # 使用张量元组返回多个对象
        return tensor_output, torch.tensor(non_tensor_output)

下面是一个示例代码，展示了如何在实际应用场景中解决**Only tensors or tuples of tensors can be output from traced functions**的错误。

pythonCopy code
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    class CNNModel(nn.Module):
        def __init__(self):
            super(CNNModel, self).__init__()
            self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1)
            self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)
            self.fc = nn.Linear(32*8*8, 10)
        def forward(self, x):
            x = F.relu(self.conv1(x))
            x = F.max_pool2d(x, 2)
            x = F.relu(self.conv2(x))
            x = F.max_pool2d(x, 2)
            x = x.view(-1, 32*8*8)
            x = self.fc(x)
            
            # 返回非张量类型的对象
            return {'output': x, 'metadata': {'label_names': ['cat', 'dog', 'bird', 'horse', 'ship', 'car', 'truck', 'plane', 'flower', 'tree']}}
    # 创建模型实例
    model = CNNModel()
    # 构造示例输入
    input_tensor = torch.randn(1, 3, 32, 32)
    # 跟踪函数
    traced_model = torch.jit.trace(model, input_tensor)
    # 测试跟踪模型
    output = traced_model(input_tensor)
    # 仅返回张量或张量元组
    tensor_output = output['output']
    metadata_output = output['metadata']
    print("Tensor output:", tensor_output)
    print("Metadata output:", metadata_output)

在这个示例代码中，我们构建了一个简单的卷积神经网络模型，并定义了其正向传播函数。在这个模型中，我们希望将分类标签的名称作为输出的一部分返回，以便在推理阶段使用。 由于**torch.jit.trace**只接受张量或张量元组的输出，我们无法直接将带有自定义键的字典对象作为输出。为了解决这个问题，我们可以将**metadata**部分转换为张量，并将其包含在返回的张量元组中。

**torch.jit.trace**函数是PyTorch提供的一个用于模型跟踪（model tracing）的工具函数。它可以用来将一个模型的正向传播函数转换为脚本模式（script mode），以便在后续的推理阶段中进行更高效的执行。 具体来说，**torch.jit.trace**函数的作用是通过执行模型的正向传播函数，自动对模型进行跟踪并生成一个脚本版本。该脚本版本可以以图形方式表示模型的结构，并具有更高的执行性能。 要使用**torch.jit.trace**函数，首先需要定义一个模型（继承自**torch.nn.Module**），并实现模型的正向传播函数。然后，通过将模型的实例和一个示例输入传递给**torch.jit.trace**函数，可以生成一个跟踪模型。这个跟踪模型可以像普通的函数一样调用，但其内部会执行跟踪过的模型的计算图。 跟踪过的模型具有以下特点：

1.  **高效执行：** 跟踪模型以图形方式表示，可以在执行阶段进行更高效的计算，提高模型的执行性能。
2.  **独立于Python：** 跟踪模型可以通过PyTorch的C++前端执行，独立于Python环境，这使得跟踪模型可以在推理阶段以不同的方式部署（如移植到C++应用程序或运行在嵌入式设备上）。
3.  **不受Python的限制：** 跟踪模型可以使用更多的优化技术，而不受Python的限制（如操作融合、多线程执行等）。 使用**torch.jit.trace**函数的示例代码如下：

pythonCopy code
    import torch
    import torch.nn as nn
    # 定义模型类
    class MyModel(nn.Module):
        def __init__(self):
            super(MyModel, self).__init__()
            self.fc = nn.Linear(10, 5)
        
        def forward(self, x):
            return self.fc(x)
    # 创建模型实例
    model = MyModel()
    # 构造示例输入
    input_tensor = torch.randn(1, 10)
    # 跟踪模型
    traced_model = torch.jit.trace(model, input_tensor)
    # 使用跟踪模型进行推理
    output = traced_model(input_tensor)

在上述示例代码中，我们首先定义了一个简单的模型类**MyModel**，并实现了其正向传播函数**forward**。然后，我们创建了一个模型实例**model**，并构造了一个示例输入**input\_tensor**。接下来，我们使用**torch.jit.trace**函数对模型进行跟踪，并将跟踪模型保存到**traced\_model**中。最后，我们使用跟踪模型进行推理，将示例输入传递给跟踪模型并获取输出结果。

### 总结 ###

在使用PyTorch进行模型跟踪时，出现错误消息**Only tensors or tuples of tensors can be output from traced functions**时，意味着跟踪函数返回了非张量类型的对象。我们可以通过确保跟踪函数只返回张量或张量元组来解决这个问题。如果需要返回非张量类型的对象，可以将其转换为张量或使用张量元组返回多个对象。这样就可以顺利进行模型跟踪，并提高模型的性能。