NeuralProfile.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Misc/Guid.h"
#include "NeuralProfile.generated.h"
 
#define MAX_NEURAL_PROFILE_COUNT 64
 
 
UENUM(BlueprintType)
enum class ENeuralProfileFormat : uint8
{
    Type32 UMETA(DisplayName = "32bit"),
    Type16 UMETA(DisplayName = "16bit"),
};
 
UENUM(BlueprintType)
enum class ENeuralModelTileType : uint8
{
    OneByOne        UMETA(DisplayName = "1x1"),
 
    TwoByTwo        UMETA(DisplayName = "2x2"),
    
    FourByFour      UMETA(DisplayName = "4x4"),
    
    EightByEight    UMETA(DisplayName = "8x8"),
 
    Auto            UMETA(DisplayName = "Auto")
};
 
UENUM(BlueprintType)
enum class ETileOverlapResolveType : uint8
{
    Ignore          UMETA(DisplayName = "Ignore"),
 
    Feathering      UMETA(DisplayName = "Feathering")
};
 
 
UENUM(BlueprintType)
enum class ENeuralProfileRuntimeType : uint8
{
    NNERuntimeORTDml UMETA(DisplayName = "NNERuntimeORTDml"),
 
    NNERuntimeRDGHlsl UMETA(DisplayName = "NNERuntimeRDGHlsl"),
 
    MAX              UMETA(Hidden)
};
 
// struct with all the settings we want in UNeuralProfile, separate to make it easer to pass this data around in the engine.
USTRUCT(BlueprintType)
struct FNeuralProfileStruct
{
    GENERATED_USTRUCT_BODY()
    
    
    UPROPERTY(Category = "Common", EditAnywhere, BlueprintReadOnly, meta=(DisplayName="Input Format", editcondition = "false", EditConditionHides))
    ENeuralProfileFormat InputFormat;
 
    UPROPERTY(Category = "Common", EditAnywhere, BlueprintReadOnly, meta = (DisplayName = "Output Format", editcondition = "false", EditConditionHides))
    ENeuralProfileFormat OutputFormat;
 
    //runtime type (support "NNERuntimeORTDml" only at this moment)
    UPROPERTY(Category = "Model", EditAnywhere, BlueprintReadOnly)
    ENeuralProfileRuntimeType RuntimeType;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Model, meta = (DisplayName = "NNE Model Data"))
    TObjectPtr<UObject> NNEModelData;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Model, meta = (DisplayName = "Input Dimension", editcondition = "false"))
    FIntVector4 InputDimension;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Model, meta = (DisplayName = "Output Dimension", editcondition = "false"))
    FIntVector4 OutputDimension;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Override", meta = (DisplayName = "Batch Size"))
    int32 BatchSizeOverride;
 
    UPROPERTY(EditAnywhere, Category = "Tile")
    ENeuralModelTileType TileSize;
 
    UPROPERTY(EditAnywhere, Category = "Tile", meta = (DisplayName = "Border Overlaps"))
    FIntPoint TileOverlap;
 
    UPROPERTY(EditAnywhere, Category = "Tile", meta = (DisplayName = "Overlap Resolve Type"))
    ETileOverlapResolveType TileOverlapResolveType;
 
    FNeuralProfileStruct()
    {
        InputFormat = ENeuralProfileFormat::Type32;
        OutputFormat = ENeuralProfileFormat::Type32;
        RuntimeType = ENeuralProfileRuntimeType::NNERuntimeORTDml;
        NNEModelData = nullptr;
        InputDimension = FIntVector4(0);
        OutputDimension = FIntVector4(0);
        TileSize = ENeuralModelTileType::OneByOne;
        BatchSizeOverride = 1;
        TileOverlap = FIntPoint(0, 0);
        TileOverlapResolveType = ETileOverlapResolveType::Ignore;
    }
 
    void Invalidate()
    {
        *this = FNeuralProfileStruct();
    }
};
 
UCLASS(autoexpandcategories = NeuralProfile, MinimalAPI)
class UNeuralProfile : public UObject
{
    GENERATED_UCLASS_BODY()
 
public:
 
    UPROPERTY(Category = UNeuralProfile, EditAnywhere, meta = (ShowOnlyInnerProperties))
    struct FNeuralProfileStruct Settings;
 
    UPROPERTY()
    FGuid Guid;
 
    void BeginDestroy();
    virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent);
};
 
namespace NeuralProfile
{
    // Profile - Initializes or updates the contents of the neural profile.
    ENGINE_API int32 AddOrUpdateProfile(const UNeuralProfile* InProfile, const FGuid& InGuid, const FNeuralProfileStruct InSettings);
 
    ENGINE_API FNeuralProfileStruct GetProfileSetting(int32 AllocationId);
 
    // Profile - Returns the profile ID for a given neural profile object
    ENGINE_API int32 GetNeuralProfileId(const UNeuralProfile* In);
 
    // Experimental APIs to manage neural profiles.
    class INeuralProfileManager
    {
    public:
        virtual ~INeuralProfileManager() {}
 
        virtual void UpdateModel(int32 AllocationId, UObject* NNEModelData, FString RuntimeName) = 0;
        virtual void RemoveModel(int32 AllocationId) = 0;
 
        virtual void UpdateTileType(int32 AllocationId, ENeuralModelTileType ModelTileSize) = 0;
        virtual bool UpdateBatchSize(int32 AllocationId, int32 BatchSize) = 0;
        virtual void UpdateTileOverlap(int32 AllocationId, FIntPoint TileOverlap) = 0;
        virtual void UpdateTileOverlapResolveType(int32 AllocationId, ETileOverlapResolveType TileOverlapResolveType) = 0;
 
        virtual FIntVector4 GetInputDimension(UObject* NNEModelData, FString RuntimeName) = 0;
        virtual FIntVector4 GetOutputDimension(UObject* NNEModelData, FString RuntimeName) = 0;     
    };
}
 
extern ENGINE_API TUniquePtr<NeuralProfile::INeuralProfileManager> GNeuralProfileManager;