Add support for torch.export ExportedProgram models (#1498)

Implements functionality to load and execute PyTorch models exported via
torch.export (.pt2 files), enabling .NET applications to run ExportedProgram
models as the PyTorch ecosystem transitions from ONNX to torch.export.

## Implementation

### Native Layer
- Add THSExport.h and THSExport.cpp C++ wrappers for torch.export API
- Expose helper functions (toIValue, ReturnHelper) in THSJIT.h
- Add ExportedProgramModule typedef in Utils.h
- Update CMakeLists.txt to include THSExport sources

### Managed Layer
- Add LibTorchSharp.THSExport.cs with PInvoke declarations
- Implement ExportedProgram, ExportedProgram<TResult>, and
  ExportedProgram<T, TResult> classes in new Export namespace
- Provide torch.export.load() API following PyTorch conventions

### Features
- Load .pt2 ExportedProgram files
- Execute forward pass with type-safe generics
- Device management (CPU, CUDA, MPS)
- Dtype conversion support
- Parameters and buffers access
- Training/eval mode compatibility

### Testing
- Add TestExport.cs with 10 comprehensive unit tests
- Include 6 test .pt2 models covering various scenarios:
  - Simple linear model
  - Linear + ReLU
  - Multiple inputs
  - Tuple and list outputs
  - Sequential models
- Update TorchSharpTest.csproj to copy .pt2 files to output

## Technical Details

The implementation leverages ~80% of existing ScriptModule infrastructure,
including TensorOrScalar marshalling and return value processing. The .pt2
format is compatible with torch::jit::load() in LibTorch C++ API.

Fixes #1498

Author: tolleybot

src/Native/LibTorchSharp/CMakeLists.txt

@@ -11,6 +11,7 @@ set(SOURCES
 	crc32c.h
     THSAutograd.h
     THSData.h
+    THSExport.h
     THSJIT.h
     THSNN.h
 	THSStorage.h
@@ -23,6 +24,7 @@ set(SOURCES
 	THSActivation.cpp
     THSAutograd.cpp
 	THSData.cpp
+	THSExport.cpp
 	THSFFT.cpp
     THSJIT.cpp
 	THSLinearAlgebra.cpp

src/Native/LibTorchSharp/THSExport.cpp

@@ -0,0 +1,140 @@
+// Copyright (c) .NET Foundation and Contributors.  All Rights Reserved.  See LICENSE in the project root for license information.
+#include "THSExport.h"
+
+// NOTE: In LibTorch C++ API, ExportedProgram models (.pt2 files) are loaded using torch::jit::load()
+// The .pt2 format is compatible with the TorchScript loading infrastructure
+
+ExportedProgramModule THSExport_load(const char* filename, int64_t device, int64_t index)
+{
+    c10::DeviceType dev = c10::kCPU;
+    if (device == 1)
+        dev = c10::kCUDA;
+    if (device == 13)
+        dev = c10::kMPS;
+
+    CATCH(
+        // Load .pt2 file using torch::jit::load
+        // This works because ExportedProgram models are serialized in a JIT-compatible format
+        auto res = torch::jit::load(filename, torch::Device(dev, index));
+        auto copy = new torch::jit::Module(res);
+        return new std::shared_ptr<torch::jit::Module>(copy);
+    );
+
+    return nullptr;
+}
+
+void THSExport_Module_dispose(const ExportedProgramModule module)
+{
+    delete module;
+}
+
+void THSExport_Module_forward(
+    const ExportedProgramModule module,
+    const TensorOrScalar* tensorPtrs,
+    const int length,
+    TensorOrScalar* (*allocator)(int32_t idx, size_t length),
+    int8_t* typeCode,
+    int32_t idx)
+{
+    *typeCode = 0;
+
+    CATCH(
+        // Execute the forward method
+        auto result = (*module)->forward(toIValue(tensorPtrs, length));
+        ReturnHelper(result, allocator, typeCode, &idx);
+    )
+}
+
+int THSExport_Module_is_training(ExportedProgramModule module)
+{
+    // ExportedPrograms are always in eval mode, but we check the underlying module
+    return (*module)->is_training();
+}
+
+void THSExport_Module_train(ExportedProgramModule module, bool on)
+{
+    // ExportedPrograms should remain in eval mode, but we allow this for compatibility
+    (*module)->train(on);
+}
+
+void THSExport_Module_eval(ExportedProgramModule module)
+{
+    (*module)->eval();
+}
+
+void THSExport_Module_to_device_dtype(ExportedProgramModule module, int8_t dtype, int64_t device, int64_t index)
+{
+    c10::DeviceType dev = c10::kCPU;
+    if (device == 1)
+        dev = c10::kCUDA;
+    if (device == 13)
+        dev = c10::kMPS;
+
+    CATCH(
+        (*module)->to(torch::Device(dev, index), (at::ScalarType)dtype);
+    );
+}
+
+void THSExport_Module_to_device(ExportedProgramModule module, int64_t device, int64_t index)
+{
+    c10::DeviceType dev = c10::kCPU;
+    if (device == 1)
+        dev = c10::kCUDA;
+    if (device == 13)
+        dev = c10::kMPS;
+
+    CATCH(
+        (*module)->to(torch::Device(dev, index));
+    );
+}
+
+void THSExport_Module_to_dtype(ExportedProgramModule module, int8_t dtype)
+{
+    CATCH(
+        (*module)->to((at::ScalarType)dtype);
+    );
+}
+
+void THSExport_Module_parameters(const ExportedProgramModule module, Tensor* (*allocator)(size_t length))
+{
+    auto parameters = (*module)->parameters();
+    Tensor* result = allocator(parameters.size());
+
+    int i = 0;
+    for (auto parameter : parameters)
+        result[i++] = new torch::Tensor(parameter);
+}
+
+void THSExport_Module_named_parameters(
+    const ExportedProgramModule module,
+    Tensor* (*allocator)(size_t length),
+    const char** (*allocator2)(size_t length))
+{
+    auto parameters = (*module)->named_parameters();
+    Tensor* result = allocator(parameters.size());
+    const char** names = allocator2(parameters.size());
+
+    int i = 0;
+    for (const auto& parameter : parameters) {
+        result[i] = new torch::Tensor(parameter.value);
+        names[i] = make_sharable_string(parameter.name);
+        i++;
+    }
+}
+
+void THSExport_Module_named_buffers(
+    const ExportedProgramModule module,
+    Tensor* (*allocator)(size_t length),
+    const char** (*allocator2)(size_t length))
+{
+    auto buffers = (*module)->named_buffers();
+    Tensor* result = allocator(buffers.size());
+    const char** names = allocator2(buffers.size());
+
+    int i = 0;
+    for (const auto& buffer : buffers) {
+        result[i] = new torch::Tensor(buffer.value);
+        names[i] = make_sharable_string(buffer.name);
+        i++;
+    }
+}

src/Native/LibTorchSharp/THSExport.h

@@ -0,0 +1,48 @@
+// Copyright (c) .NET Foundation and Contributors.  All Rights Reserved.  See LICENSE in the project root for license information.
+#pragma once
+
+#include "../Stdafx.h"
+
+#include "torch/csrc/jit/api/module.h"
+
+#include "Utils.h"
+#include "THSJIT.h"  // For TensorOrScalar struct
+
+// API for torch.export ExportedProgram
+
+// Load ExportedProgram from .pt2 file
+EXPORT_API(ExportedProgramModule) THSExport_load(const char* filename, int64_t device, int64_t index);
+
+// Dispose ExportedProgram module
+EXPORT_API(void) THSExport_Module_dispose(const ExportedProgramModule module);
+
+// Execute forward pass on ExportedProgram
+EXPORT_API(void) THSExport_Module_forward(
+    const ExportedProgramModule module,
+    const TensorOrScalar* tensorPtrs,
+    const int length,
+    TensorOrScalar* (*allocator)(int32_t idx, size_t length),
+    int8_t* typeCode,
+    int32_t idx);
+
+// Device and dtype management
+EXPORT_API(void) THSExport_Module_to_device_dtype(ExportedProgramModule module, int8_t dtype, int64_t device, int64_t index);
+EXPORT_API(void) THSExport_Module_to_device(ExportedProgramModule module, int64_t device, int64_t index);
+EXPORT_API(void) THSExport_Module_to_dtype(ExportedProgramModule module, int8_t dtype);
+
+// Training mode (ExportedPrograms are always in eval mode, but we provide these for compatibility)
+EXPORT_API(int) THSExport_Module_is_training(ExportedProgramModule module);
+EXPORT_API(void) THSExport_Module_train(ExportedProgramModule module, bool on);
+EXPORT_API(void) THSExport_Module_eval(ExportedProgramModule module);
+
+// Parameters and buffers access
+EXPORT_API(void) THSExport_Module_parameters(const ExportedProgramModule module, Tensor* (*allocator)(size_t length));
+EXPORT_API(void) THSExport_Module_named_parameters(
+    const ExportedProgramModule module,
+    Tensor* (*allocator)(size_t length),
+    const char** (*allocator2)(size_t length));
+
+EXPORT_API(void) THSExport_Module_named_buffers(
+    const ExportedProgramModule module,
+    Tensor* (*allocator)(size_t length),
+    const char** (*allocator2)(size_t length));

src/Native/LibTorchSharp/THSJIT.h

@@ -98,3 +98,7 @@ EXPORT_API(TensorOrScalar*) THSJIT_AllocateTensorOrScalarArray(int32_t size);
 EXPORT_API(void) THSJIT_FreeTensorOrScalarArray(TensorOrScalar* ptr);
 EXPORT_API(void) THSJIT_SetTensorOrScalar(TensorOrScalar* array, int32_t index, int64_t type_code, int64_t array_index, ptrdiff_t handle);
 EXPORT_API(TensorOrScalar*) THSJIT_GetTensorOrScalar(TensorOrScalar* array, int32_t index);
+
+// Helper functions (shared with THSExport)
+std::vector<c10::IValue> toIValue(const TensorOrScalar* tensorPtrs, const int length);
+TensorOrScalar* ReturnHelper(c10::IValue result, TensorOrScalar* (*allocator)(int32_t idx, size_t length), int8_t* typeCode, int32_t* idx);

src/Native/LibTorchSharp/Utils.h

@@ -24,6 +24,10 @@ typedef std::shared_ptr<torch::jit::Function> * JITFunction;
 typedef std::shared_ptr<c10::Type> * JITType;
 typedef std::shared_ptr<c10::TensorType>* JITTensorType;
 
+// torch.export ExportedProgram module
+// Note: In LibTorch C++ API, ExportedProgram is also represented as torch::jit::Module
+typedef std::shared_ptr<torch::jit::Module>* ExportedProgramModule;
+
 struct TensorArray {
     Tensor *array;
     int64_t size;