private static IOps CreateOps(WorkerFactory.Type type, ITensorAllocator allocator, bool verbose) { switch (type) { case WorkerFactory.Type.ComputePrecompiled: return(new PrecompiledComputeOps(ComputeShaderSingleton.Instance.kernels, ComputeShaderSingleton.Instance.referenceKernels, allocator, verbose)); case WorkerFactory.Type.Compute: return(new ComputeOps(ComputeShaderSingleton.Instance.kernels, ComputeShaderSingleton.Instance.referenceKernels, allocator, verbose)); case WorkerFactory.Type.ComputeRef: return(new ReferenceComputeOps(ComputeShaderSingleton.Instance.referenceKernels, allocator)); case WorkerFactory.Type.CSharpBurst: return(new BurstCPUOps(allocator)); case WorkerFactory.Type.CSharp: return(new UnsafeArrayCPUOps(allocator)); default: return(new ReferenceCPUOps(allocator)); } }
public static WorkerFactory.Type ResolveAutoType(WorkerFactory.Type type) { if (type != WorkerFactory.Type.Auto) { return(type); } return(GetBestTypeForDevice(WorkerFactory.Device.Auto)); }
internal static IWorker CreateWorker(WorkerFactory.Type type, Model model, string[] additionalOutputs, string[] trimOutputs, WorkerFactory.WorkerConfiguration workerConfiguration, IModelExecutionsReporter modelExecutionsReporter = null) { type = ResolveAutoType(type); var compareAgainstType = ResolveAutoType(workerConfiguration.compareAgainstType); Assert.AreNotEqual(type, WorkerFactory.Type.Auto); Assert.AreNotEqual(compareAgainstType, WorkerFactory.Type.Auto); bool compare = type != compareAgainstType; if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) && !SystemInfo.supportsComputeShaders && !Application.isEditor) { D.LogWarning("Compute shaders are not supported on current platform. Falling back to CSharpFast."); type = WorkerFactory.Type.CSharpBurst; } IVars vars; if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) || WorkerFactory.IsType(compareAgainstType, WorkerFactory.Device.GPU)) { vars = new ComputeVarsWithSharedModel(); } else { vars = new DefaultVars(); } ITensorAllocator allocator = vars.GetAllocator(); if (workerConfiguration.verbose) { D.Log($"Storage type: {vars.GetType()}. Allocator type: {allocator.GetType()}."); } IOps ops = CreateOps(type, allocator, workerConfiguration.verbose); if (compare) { ops = new CompareOps(ops, CreateOps(compareAgainstType, allocator, workerConfiguration.verbose), workerConfiguration.compareLogLevel, workerConfiguration.compareEpsilon); } if (workerConfiguration.verbose || modelExecutionsReporter != null) { ops = new VerboseOps(ops, workerConfiguration.verbose); } if (Application.isEditor || modelExecutionsReporter != null) { ops = new StatsOps(ops); } model = ValidateModel( PatchModel(model, additionalOutputs, trimOutputs)); ops.SetModelExecutionsReporter(modelExecutionsReporter); return(new GenericWorker(model, ops, vars, workerConfiguration.verbose)); }
public static IWorker CreateWorker(WorkerFactory.Type type, Model model, string[] additionalOutputs, string[] trimOutputs, bool verbose, WorkerFactory.Type compareAgainstType, bool differenceAsError) { type = ResolveAutoType(type); compareAgainstType = ResolveAutoType(compareAgainstType); Assert.AreNotEqual(type, WorkerFactory.Type.Auto); Assert.AreNotEqual(compareAgainstType, WorkerFactory.Type.Auto); bool compare = type != compareAgainstType; if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) && !SystemInfo.supportsComputeShaders && !Application.isEditor) { D.LogWarning("Compute shaders are not supported on current platform. Falling back to CSharpFast."); type = WorkerFactory.Type.CSharp; } IVars vars; if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) || WorkerFactory.IsType(compareAgainstType, WorkerFactory.Device.GPU)) { vars = new ComputeVarsWithSharedModel(); } else { vars = new DefaultVars(); } ITensorAllocator allocator = vars.GetAllocator(); if (verbose) { D.Log($"Storage type: {vars.GetType()}. Allocator type: {allocator.GetType()}."); } IOps ops = CreateOps(type, allocator, verbose); if (compare) { ops = new CompareOps(ops, CreateOps(compareAgainstType, allocator, verbose), differenceAsError); } if (verbose) { ops = new VerboseOps(ops); } if (Application.isEditor) { ops = new StatsOps(ops); } model = ValidateModel( PatchModel(model, additionalOutputs, trimOutputs)); return(new GenericWorker(model, ops, vars, verbose)); }
public BarracudaWorker(NNModel nnModel, WorkerFactory.Type type) { bool verbose = false; model = ModelLoader.Load(nnModel, verbose); worker = WorkerFactory.CreateWorker(type, model, verbose); var kernels = ComputeShaderSingleton.Instance.kernels; ops = new PrecompiledComputeOps(kernels, kernels[0]); }
internal static WorkerFactory.Type ValidateType(WorkerFactory.Type type) { type = ResolveAutoType(type); Assert.AreNotEqual(type, WorkerFactory.Type.Auto); if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) && !ComputeShaderSingleton.Instance.supported) { type = WorkerFactory.Type.PixelShader; } return(type); }
internal static WorkerFactory.Type ValidateType(WorkerFactory.Type type) { type = ResolveAutoType(type); Assert.AreNotEqual(type, WorkerFactory.Type.Auto); if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) && !ComputeShaderSingleton.Instance.supported) { D.LogWarning( $"SystemInfo.supportsComputeShaders: {SystemInfo.supportsComputeShaders}. Falling back to {WorkerFactory.Type.CSharp}"); type = WorkerFactory.Type.CSharp; } return(type); }
public static IOps CreateOps(WorkerFactory.Type type, bool verbose = false) { WorkerFactory.ValidateType(type); switch (type) { case WorkerFactory.Type.ComputePrecompiled: return new PrecompiledComputeOps(ComputeShaderSingleton.Instance.kernels, ComputeShaderSingleton.Instance.referenceKernels, verbose: verbose); case WorkerFactory.Type.Compute: return new ComputeOps(ComputeShaderSingleton.Instance.kernels, ComputeShaderSingleton.Instance.referenceKernels, verbose: verbose); case WorkerFactory.Type.ComputeRef: return new ReferenceComputeOps(ComputeShaderSingleton.Instance.referenceKernels); case WorkerFactory.Type.CSharp: return new UnsafeArrayCPUOps(); default: return new ReferenceCPUOps(); } }
/// <summary> /// Updates the output layer names based on the selected model architecture /// and initializes the Barracuda inference engine witht the selected model. /// </summary> private void InitializeBarracuda() { // The compiled model used for performing inference Model m_RunTimeModel; if (modelType == ModelType.MobileNet) { preProcessFunction = Utils.PreprocessMobileNet; // Compile the model asset into an object oriented representation m_RunTimeModel = ModelLoader.Load(mobileNetModelAsset); displacementFWDLayer = m_RunTimeModel.outputs[2]; displacementBWDLayer = m_RunTimeModel.outputs[3]; } else { preProcessFunction = Utils.PreprocessResNet; // Compile the model asset into an object oriented representation m_RunTimeModel = ModelLoader.Load(resnetModelAsset); displacementFWDLayer = m_RunTimeModel.outputs[3]; displacementBWDLayer = m_RunTimeModel.outputs[2]; } heatmapLayer = m_RunTimeModel.outputs[0]; offsetsLayer = m_RunTimeModel.outputs[1]; // Create a model builder to modify the m_RunTimeModel ModelBuilder modelBuilder = new ModelBuilder(m_RunTimeModel); // Add a new Sigmoid layer that takes the output of the heatmap layer modelBuilder.Sigmoid(predictionLayer, heatmapLayer); // Validate if backend is supported, otherwise use fallback type. workerType = WorkerFactory.ValidateType(workerType); // Create a worker that will execute the model with the selected backend engine = new Engine(workerType, modelBuilder.model, modelType); }
public static IWorker CreateWorker(WorkerFactory.Type type, Model model, string[] additionalOutputs = null, string[] trimOutputs = null, bool verbose = false) { return(CreateWorker(type, model, additionalOutputs, trimOutputs, verbose, compareAgainstType: type, differenceAsError: false)); }
public static IWorker CreateWorker(WorkerFactory.Type type, Model model, string[] additionalOutputs = null, string[] trimOutputs = null, bool verbose = false) { var workerConfiguration = new WorkerFactory.WorkerConfiguration(type, verbose); return(CreateWorker(type, model, additionalOutputs, trimOutputs, workerConfiguration)); }
public Engine(WorkerFactory.Type workerType, Model model, ModelType modelType) { this.workerType = workerType; worker = WorkerFactory.CreateWorker(workerType, model); this.modelType = modelType; }
internal static IWorker CreateWorker(WorkerFactory.Type type, Model model, string[] additionalOutputs, string[] trimOutputs, WorkerFactory.WorkerConfiguration workerConfiguration, IModelExecutionsReporter modelExecutionsReporter = null) { type = ResolveAutoType(type); var compareAgainstType = ResolveAutoType(workerConfiguration.compareAgainstType); Assert.AreNotEqual(type, WorkerFactory.Type.Auto); Assert.AreNotEqual(compareAgainstType, WorkerFactory.Type.Auto); bool compare = type != compareAgainstType; if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) && !SystemInfo.supportsComputeShaders && !Application.isEditor) { type = WorkerFactory.Type.PixelShader; } IVars vars; // PixelShader worker uses Blit/Textures, cannot re-use vars unless the dispatch mechanism allows rendering to sub part of the texture if ((type == WorkerFactory.Type.PixelShader) || (compareAgainstType == WorkerFactory.Type.PixelShader)) { vars = new GenericVarsWithReuse(); } else { if (WorkerFactory.IsType(type, WorkerFactory.Device.GPU) || WorkerFactory.IsType(compareAgainstType, WorkerFactory.Device.GPU)) { vars = new ComputeVarsWithSharedModel(); } else { vars = new DefaultVars(); } } ITensorAllocator allocator = vars.GetAllocator(); if ((type == WorkerFactory.Type.PixelShader) || (compareAgainstType == WorkerFactory.Type.PixelShader)) { allocator = new TensorCachingByShapeAllocator(); } if (workerConfiguration.verbose) { D.Log($"Storage type: {vars.GetType()}. Allocator type: {allocator.GetType()}."); } IOps ops = CreateOps(type, allocator, workerConfiguration.verbose); if (compare) { ops = new CompareOps(ops, CreateOps(compareAgainstType, allocator, workerConfiguration.verbose), workerConfiguration.compareLogLevel, workerConfiguration.compareEpsilon); } if (workerConfiguration.verbose || modelExecutionsReporter != null) { ops = new VerboseOps(ops, workerConfiguration.verbose); } if (Application.isEditor || modelExecutionsReporter != null) { ops = new StatsOps(ops); } model = ValidateModel( PatchModel(model, additionalOutputs, trimOutputs)); ops.SetModelExecutionsReporter(modelExecutionsReporter); return(new GenericWorker(model, ops, vars, workerConfiguration.verbose, workerConfiguration.takeoverWeights)); }