Tidy up some rounding issues

saddam213 · saddam213 · commit 98fc358c1a48 · 2023-11-19T15:17:44.000+13:00
diff --git a/OnnxStack.StableDiffusion/Extensions.cs b/OnnxStack.StableDiffusion/Extensions.cs
@@ -1,8 +1,12 @@
 ﻿using Microsoft.ML.OnnxRuntime;
+using NumSharp;
 using OnnxStack.StableDiffusion.Config;
 using OnnxStack.StableDiffusion.Enums;
+
 using System;
 using System.Linq;
+using System.Numerics;
+using System.Threading.Tasks;
 
 namespace OnnxStack.StableDiffusion
 {
@@ -114,5 +118,6 @@ public static SchedulerType[] GetSchedulerTypes(this DiffuserPipelineType pipeli
                 _ => default
             };
         }
+
     }
 }
diff --git a/OnnxStack.StableDiffusion/Helpers/ArrayHelpers.cs b/OnnxStack.StableDiffusion/Helpers/ArrayHelpers.cs
@@ -0,0 +1,18 @@
+﻿using System;
+using System.Linq;
+
+namespace OnnxStack.StableDiffusion.Helpers
+{
+    internal class ArrayHelpers
+    {
+        public static float[] Linspace(float start, float end, int partitions, bool round = false)
+        {
+            var result = Enumerable.Range(0, partitions)
+                .Select(idx => idx != partitions ? start + (end - start) / (partitions - 1) * idx : end);
+            return !round
+                ? result.ToArray()
+                : result.Select(x => MathF.Round(x)).ToArray();
+        }
+
+    }
+}
diff --git a/OnnxStack.StableDiffusion/Schedulers/SchedulerBase.cs b/OnnxStack.StableDiffusion/Schedulers/SchedulerBase.cs
@@ -1,5 +1,5 @@
 ﻿using Microsoft.ML.OnnxRuntime.Tensors;
-using NumSharp;
+using OnnxStack.Core;
 using OnnxStack.StableDiffusion.Common;
 using OnnxStack.StableDiffusion.Config;
 using OnnxStack.StableDiffusion.Enums;
@@ -119,15 +119,13 @@ protected virtual float[] GetBetaSchedule()
             }
             else if (Options.BetaSchedule == BetaScheduleType.Linear)
             {
-                betas = np.linspace(Options.BetaStart, Options.BetaEnd, Options.TrainTimesteps).ToArray<float>();
+                betas = ArrayHelpers.Linspace(Options.BetaStart, Options.BetaEnd, Options.TrainTimesteps);
             }
             else if (Options.BetaSchedule == BetaScheduleType.ScaledLinear)
             {
-                var start = (float)Math.Sqrt(Options.BetaStart);
-                var end = (float)Math.Sqrt(Options.BetaEnd);
-                betas = np.linspace(start, end, Options.TrainTimesteps)
-                    .ToArray<float>()
-                    .Select(x => x * x);
+                var start = MathF.Sqrt(Options.BetaStart);
+                var end = MathF.Sqrt(Options.BetaEnd);
+                betas = ArrayHelpers.Linspace(start, end, Options.TrainTimesteps).Select(x => x * x);
             }
             else if (Options.BetaSchedule == BetaScheduleType.SquaredCosCapV2)
             {
@@ -136,9 +134,9 @@ protected virtual float[] GetBetaSchedule()
             else if (Options.BetaSchedule == BetaScheduleType.Sigmoid)
             {
                 var mul = Options.BetaEnd - Options.BetaStart;
-                var betaSig = np.linspace(-6f, 6f, Options.TrainTimesteps).ToArray<float>();
+                var betaSig = ArrayHelpers.Linspace(-6f, 6f, Options.TrainTimesteps);
                 var sigmoidBetas = betaSig
-                    .Select(beta => 1.0f / (1.0f + (float)Math.Exp(-beta)))
+                    .Select(beta => 1.0f / (1.0f + MathF.Exp(-beta)))
                     .ToArray();
                 betas = sigmoidBetas
                     .Select(x => (x * mul) + Options.BetaStart)
@@ -158,7 +156,7 @@ protected virtual float GetInitNoiseSigma(float[] sigmas)
             var maxSigma = sigmas.Max();
             return Options.TimestepSpacing == TimestepSpacingType.Linspace
                 || Options.TimestepSpacing == TimestepSpacingType.Trailing
-                ? maxSigma : (float)Math.Sqrt(maxSigma * maxSigma + 1);
+                ? maxSigma : MathF.Sqrt(maxSigma * maxSigma + 1);
         }
 
 
@@ -168,28 +166,27 @@ protected virtual float GetInitNoiseSigma(float[] sigmas)
         /// <returns></returns>
         protected virtual float[] GetTimesteps()
         {
-            NDArray timestepsArray = null;
             if (Options.TimestepSpacing == TimestepSpacingType.Linspace)
             {
-                timestepsArray = np.linspace(0, Options.TrainTimesteps - 1, Options.InferenceSteps);
-                timestepsArray = np.around(timestepsArray)["::1"];
+                return ArrayHelpers.Linspace(0, Options.TrainTimesteps - 1, Options.InferenceSteps, true);
             }
             else if (Options.TimestepSpacing == TimestepSpacingType.Leading)
             {
                 var stepRatio = Options.TrainTimesteps / Options.InferenceSteps;
-                timestepsArray = np.arange(0, (float)Options.InferenceSteps) * stepRatio;
-                timestepsArray = np.around(timestepsArray)["::1"];
-                timestepsArray += Options.StepsOffset;
+                return Enumerable.Range(0, Options.InferenceSteps)
+                    .Select(x => MathF.Round((float)x * stepRatio) + Options.StepsOffset)
+                    .ToArray();
             }
             else if (Options.TimestepSpacing == TimestepSpacingType.Trailing)
             {
                 var stepRatio = Options.TrainTimesteps / (Options.InferenceSteps - 1);
-                timestepsArray = np.arange((float)Options.TrainTimesteps, 0, -stepRatio)["::-1"];
-                timestepsArray = np.around(timestepsArray);
-                timestepsArray -= 1;
+                return Enumerable.Range(0, Options.TrainTimesteps)
+                    .Where((number, index) => index % stepRatio == 0)
+                    .Select(x => (float)x)
+                    .ToArray();
             }
 
-            return timestepsArray.ToArray<float>();
+            throw new NotImplementedException();
         }
 
 
@@ -209,7 +206,7 @@ protected virtual DenseTensor<float> GetPredictedSample(DenseTensor<float> model
             }
             else if (Options.PredictionType == PredictionType.VariablePrediction)
             {
-                var sigmaSqrt = (float)Math.Sqrt(sigma * sigma + 1);
+                var sigmaSqrt = MathF.Sqrt(sigma * sigma + 1);
                 predOriginalSample = sample.DivideTensorByFloat(sigmaSqrt)
                     .AddTensors(modelOutput.MultiplyTensorByFloat(-sigma / sigmaSqrt));
             }
@@ -253,11 +250,11 @@ protected float[] GetBetasForAlphaBar()
             Func<float, float> alphaBarFn = null;
             if (_options.AlphaTransformType == AlphaTransformType.Cosine)
             {
-                alphaBarFn = t => (float)Math.Pow(Math.Cos((t + 0.008f) / 1.008f * Math.PI / 2.0f), 2.0f);
+                alphaBarFn = t => MathF.Pow(MathF.Cos((t + 0.008f) / 1.008f * MathF.PI / 2.0f), 2.0f);
             }
             else if (_options.AlphaTransformType == AlphaTransformType.Exponential)
             {
-                alphaBarFn = t => (float)Math.Exp(t * -12.0f);
+                alphaBarFn = t => MathF.Exp(t * -12.0f);
             }
 
             return Enumerable
@@ -266,7 +263,7 @@ protected float[] GetBetasForAlphaBar()
                 {
                     var t1 = (float)i / _options.TrainTimesteps;
                     var t2 = (float)(i + 1) / _options.TrainTimesteps;
-                    return Math.Min(1f - alphaBarFn(t2) / alphaBarFn(t1), _options.MaximumBeta);
+                    return MathF.Min(1f - alphaBarFn(t2) / alphaBarFn(t1), _options.MaximumBeta);
                 }).ToArray();
         }
 
@@ -298,13 +295,13 @@ protected float[] Interpolate(float[] timesteps, float[] range, float[] sigmas)
                 // If timesteps[i] is less than the first element in range, use the first value in sigmas
                 else if (index == -1)
                 {
-                    result[i] = sigmas[sigmas.Length - 1];
+                    result[i] = sigmas[0];
                 }
 
                 // If timesteps[i] is greater than the last element in range, use the last value in sigmas
-                else if (index == -range.Length - 1)
+                else if (index > range.Length - 1)
                 {
-                    result[i] = sigmas[0];
+                    result[i] = sigmas[sigmas.Length - 1];
                 }
 
                 // Otherwise, interpolate linearly between two adjacent values in sigmas
@@ -340,14 +337,14 @@ protected float[] ConvertToKarras(float[] inSigmas)
                 .ToArray();
 
             // Calculate the inverse of sigmaMin and sigmaMax raised to the power of 1/rho
-            float minInvRho = (float)Math.Pow(sigmaMin, 1.0 / rho);
-            float maxInvRho = (float)Math.Pow(sigmaMax, 1.0 / rho);
+            float minInvRho = MathF.Pow(sigmaMin, 1.0f / rho);
+            float maxInvRho = MathF.Pow(sigmaMax, 1.0f / rho);
 
             // Calculate the Karras noise schedule using the formula from the paper
             float[] sigmas = new float[_options.InferenceSteps];
             for (int i = 0; i < _options.InferenceSteps; i++)
             {
-                sigmas[i] = (float)Math.Pow(maxInvRho + ramp[i] * (minInvRho - maxInvRho), rho);
+                sigmas[i] = MathF.Pow(maxInvRho + ramp[i] * (minInvRho - maxInvRho), rho);
             }
 
             // Return the resulting noise schedule
@@ -366,7 +363,7 @@ protected float[] SigmaToTimestep(float[] sigmas, float[] logSigmas)
             var timesteps = new float[sigmas.Length];
             for (int i = 0; i < sigmas.Length; i++)
             {
-                float logSigma = (float)Math.Log(sigmas[i]);
+                float logSigma = MathF.Log(sigmas[i]);
                 float[] dists = new float[logSigmas.Length];
 
                 for (int j = 0; j < logSigmas.Length; j++)
diff --git a/OnnxStack.StableDiffusion/Schedulers/StableDiffusion/LMSScheduler.cs b/OnnxStack.StableDiffusion/Schedulers/StableDiffusion/LMSScheduler.cs
@@ -3,7 +3,6 @@
 using NumSharp;
 using OnnxStack.Core;
 using OnnxStack.StableDiffusion.Config;
-using OnnxStack.StableDiffusion.Enums;
 using OnnxStack.StableDiffusion.Helpers;
 using System;
 using System.Collections.Generic;
@@ -43,7 +42,7 @@ protected override void Initialize()
             var cumulativeProduct = alphas.Select((alpha, i) => alphas.Take(i + 1).Aggregate((a, b) => a * b));
 
             _sigmas = cumulativeProduct
-                .Select(alpha_prod => (float)Math.Sqrt((1 - alpha_prod) / alpha_prod))
+                .Select(alpha_prod => MathF.Sqrt((1 - alpha_prod) / alpha_prod))
                 .ToArray();
 
             var initNoiseSigma = GetInitNoiseSigma(_sigmas);
@@ -57,12 +56,13 @@ protected override void Initialize()
         /// <returns></returns>
         protected override int[] SetTimesteps()
         {
-            var sigmas = _sigmas.ToArray();
             var timesteps = GetTimesteps();
-            var log_sigmas = np.log(sigmas).ToArray<float>();
-            var range = np.arange(0, (float)_sigmas.Length).ToArray<float>();
-            sigmas = Interpolate(timesteps, range, _sigmas);
+            var log_sigmas = _sigmas.Select(x => MathF.Log(x)).ToArray();
+            var range = Enumerable.Range(0, _sigmas.Length)
+                .Select(x => (float)x)
+                .ToArray();
 
+            var sigmas = Interpolate(timesteps, range, _sigmas);
             if (Options.UseKarrasSigmas)
             {
                 sigmas = ConvertToKarras(sigmas);
@@ -72,7 +72,6 @@ protected override int[] SetTimesteps()
             _sigmas = sigmas
                 .Append(0.000f)
                 .ToArray();
-
             return timesteps.Select(x => (int)x)
                  .OrderByDescending(x => x)
                  .ToArray();
@@ -92,7 +91,7 @@ public override DenseTensor<float> ScaleInput(DenseTensor<float> sample, int tim
 
             // Get sigma at stepIndex
             var sigma = _sigmas[stepIndex];
-            sigma = (float)Math.Sqrt(Math.Pow(sigma, 2) + 1);
+            sigma = MathF.Sqrt(MathF.Pow(sigma, 2f) + 1f);
 
             // Divide sample tensor shape {2,4,(H/8),(W/8)} by sigma
             return sample.DivideTensorByFloat(sigma);
@@ -144,7 +143,7 @@ public override SchedulerStepResult Step(DenseTensor<float> modelOutput, int tim
             {
                 // Multiply to coeff by each derivatives to create the new tensors
                 var (lmsCoeff, derivative) = lmsCoeffsAndDerivatives[i];
-                lmsDerProduct[i] = derivative.MultiplyTensorByFloat((float)lmsCoeff);
+                lmsDerProduct[i] = derivative.MultiplyTensorByFloat(lmsCoeff);
             }
 
             // Add the sumed tensor to the sample
@@ -180,7 +179,7 @@ public override DenseTensor<float> AddNoise(DenseTensor<float> originalSamples,
         /// <param name="t">The t.</param>
         /// <param name="currentOrder">The current order.</param>
         /// <returns></returns>
-        private double GetLmsCoefficient(int order, int t, int currentOrder)
+        private float GetLmsCoefficient(int order, int t, int currentOrder)
         {
             // python line 135 of scheduling_lms_discrete.py
             // Compute a linear multistep coefficient.
@@ -197,7 +196,7 @@ double LmsDerivative(double tau)
                 }
                 return prod;
             }
-            return Integrate.OnClosedInterval(LmsDerivative, _sigmas[t], _sigmas[t + 1], 1e-4);
+            return (float)Integrate.OnClosedInterval(LmsDerivative, _sigmas[t], _sigmas[t + 1], 1e-4);
         }
 
         protected override void Dispose(bool disposing)

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,12 @@`
`1`	`1`	`using Microsoft.ML.OnnxRuntime;`
	`2`	`+using NumSharp;`
`2`	`3`	`using OnnxStack.StableDiffusion.Config;`
`3`	`4`	`using OnnxStack.StableDiffusion.Enums;`
	`5`	`+`
`4`	`6`	`using System;`
`5`	`7`	`using System.Linq;`
	`8`	`+using System.Numerics;`
	`9`	`+using System.Threading.Tasks;`
`6`	`10`
`7`	`11`	`namespace OnnxStack.StableDiffusion`
`8`	`12`	`{`
`@@ -114,5 +118,6 @@ public static SchedulerType[] GetSchedulerTypes(this DiffuserPipelineType pipeli`
`114`	`118`	`_ => default`
`115`	`119`	`};`
`116`	`120`	`}`
	`121`	`+`
`117`	`122`	`}`
`118`	`123`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`using Microsoft.ML.OnnxRuntime.Tensors;`
`2`		`-using NumSharp;`
	`2`	`+using OnnxStack.Core;`
`3`	`3`	`using OnnxStack.StableDiffusion.Common;`
`4`	`4`	`using OnnxStack.StableDiffusion.Config;`
`5`	`5`	`using OnnxStack.StableDiffusion.Enums;`
`@@ -119,15 +119,13 @@ protected virtual float[] GetBetaSchedule()`
`119`	`119`	`}`
`120`	`120`	`else if (Options.BetaSchedule == BetaScheduleType.Linear)`
`121`	`121`	`{`
`122`		`- betas = np.linspace(Options.BetaStart, Options.BetaEnd, Options.TrainTimesteps).ToArray<float>();`
	`122`	`+ betas = ArrayHelpers.Linspace(Options.BetaStart, Options.BetaEnd, Options.TrainTimesteps);`
`123`	`123`	`}`
`124`	`124`	`else if (Options.BetaSchedule == BetaScheduleType.ScaledLinear)`
`125`	`125`	`{`
`126`		`- var start = (float)Math.Sqrt(Options.BetaStart);`
`127`		`- var end = (float)Math.Sqrt(Options.BetaEnd);`
`128`		`- betas = np.linspace(start, end, Options.TrainTimesteps)`
`129`		`- .ToArray<float>()`
`130`		`- .Select(x => x * x);`
	`126`	`+ var start = MathF.Sqrt(Options.BetaStart);`
	`127`	`+ var end = MathF.Sqrt(Options.BetaEnd);`
	`128`	`+ betas = ArrayHelpers.Linspace(start, end, Options.TrainTimesteps).Select(x => x * x);`
`131`	`129`	`}`
`132`	`130`	`else if (Options.BetaSchedule == BetaScheduleType.SquaredCosCapV2)`
`133`	`131`	`{`
`@@ -136,9 +134,9 @@ protected virtual float[] GetBetaSchedule()`
`136`	`134`	`else if (Options.BetaSchedule == BetaScheduleType.Sigmoid)`
`137`	`135`	`{`
`138`	`136`	`var mul = Options.BetaEnd - Options.BetaStart;`
`139`		`- var betaSig = np.linspace(-6f, 6f, Options.TrainTimesteps).ToArray<float>();`
	`137`	`+ var betaSig = ArrayHelpers.Linspace(-6f, 6f, Options.TrainTimesteps);`
`140`	`138`	`var sigmoidBetas = betaSig`
`141`		`- .Select(beta => 1.0f / (1.0f + (float)Math.Exp(-beta)))`
	`139`	`+ .Select(beta => 1.0f / (1.0f + MathF.Exp(-beta)))`
`142`	`140`	`.ToArray();`
`143`	`141`	`betas = sigmoidBetas`
`144`	`142`	`.Select(x => (x * mul) + Options.BetaStart)`
`@@ -158,7 +156,7 @@ protected virtual float GetInitNoiseSigma(float[] sigmas)`
`158`	`156`	`var maxSigma = sigmas.Max();`
`159`	`157`	`return Options.TimestepSpacing == TimestepSpacingType.Linspace`
`160`	`158`	`\|\| Options.TimestepSpacing == TimestepSpacingType.Trailing`
`161`		`- ? maxSigma : (float)Math.Sqrt(maxSigma * maxSigma + 1);`
	`159`	`+ ? maxSigma : MathF.Sqrt(maxSigma * maxSigma + 1);`
`162`	`160`	`}`
`163`	`161`
`164`	`162`
`@@ -168,28 +166,27 @@ protected virtual float GetInitNoiseSigma(float[] sigmas)`
`168`	`166`	`/// <returns></returns>`
`169`	`167`	`protected virtual float[] GetTimesteps()`
`170`	`168`	`{`
`171`		`- NDArray timestepsArray = null;`
`172`	`169`	`if (Options.TimestepSpacing == TimestepSpacingType.Linspace)`
`173`	`170`	`{`
`174`		`- timestepsArray = np.linspace(0, Options.TrainTimesteps - 1, Options.InferenceSteps);`
`175`		`- timestepsArray = np.around(timestepsArray)["::1"];`
	`171`	`+ return ArrayHelpers.Linspace(0, Options.TrainTimesteps - 1, Options.InferenceSteps, true);`
`176`	`172`	`}`
`177`	`173`	`else if (Options.TimestepSpacing == TimestepSpacingType.Leading)`
`178`	`174`	`{`
`179`	`175`	`var stepRatio = Options.TrainTimesteps / Options.InferenceSteps;`
`180`		`- timestepsArray = np.arange(0, (float)Options.InferenceSteps) * stepRatio;`
`181`		`- timestepsArray = np.around(timestepsArray)["::1"];`
`182`		`- timestepsArray += Options.StepsOffset;`
	`176`	`+ return Enumerable.Range(0, Options.InferenceSteps)`
	`177`	`+ .Select(x => MathF.Round((float)x * stepRatio) + Options.StepsOffset)`
	`178`	`+ .ToArray();`
`183`	`179`	`}`
`184`	`180`	`else if (Options.TimestepSpacing == TimestepSpacingType.Trailing)`
`185`	`181`	`{`
`186`	`182`	`var stepRatio = Options.TrainTimesteps / (Options.InferenceSteps - 1);`
`187`		`- timestepsArray = np.arange((float)Options.TrainTimesteps, 0, -stepRatio)["::-1"];`
`188`		`- timestepsArray = np.around(timestepsArray);`
`189`		`- timestepsArray -= 1;`
	`183`	`+ return Enumerable.Range(0, Options.TrainTimesteps)`
	`184`	`+ .Where((number, index) => index % stepRatio == 0)`
	`185`	`+ .Select(x => (float)x)`
	`186`	`+ .ToArray();`
`190`	`187`	`}`
`191`	`188`
`192`		`- return timestepsArray.ToArray<float>();`
	`189`	`+ throw new NotImplementedException();`
`193`	`190`	`}`
`194`	`191`
`195`	`192`
`@@ -209,7 +206,7 @@ protected virtual DenseTensor<float> GetPredictedSample(DenseTensor<float> model`
`209`	`206`	`}`
`210`	`207`	`else if (Options.PredictionType == PredictionType.VariablePrediction)`
`211`	`208`	`{`
`212`		`- var sigmaSqrt = (float)Math.Sqrt(sigma * sigma + 1);`
	`209`	`+ var sigmaSqrt = MathF.Sqrt(sigma * sigma + 1);`
`213`	`210`	`predOriginalSample = sample.DivideTensorByFloat(sigmaSqrt)`
`214`	`211`	`.AddTensors(modelOutput.MultiplyTensorByFloat(-sigma / sigmaSqrt));`
`215`	`212`	`}`
`@@ -253,11 +250,11 @@ protected float[] GetBetasForAlphaBar()`
`253`	`250`	`Func<float, float> alphaBarFn = null;`
`254`	`251`	`if (_options.AlphaTransformType == AlphaTransformType.Cosine)`
`255`	`252`	`{`
`256`		`- alphaBarFn = t => (float)Math.Pow(Math.Cos((t + 0.008f) / 1.008f * Math.PI / 2.0f), 2.0f);`
	`253`	`+ alphaBarFn = t => MathF.Pow(MathF.Cos((t + 0.008f) / 1.008f * MathF.PI / 2.0f), 2.0f);`
`257`	`254`	`}`
`258`	`255`	`else if (_options.AlphaTransformType == AlphaTransformType.Exponential)`
`259`	`256`	`{`
`260`		`- alphaBarFn = t => (float)Math.Exp(t * -12.0f);`
	`257`	`+ alphaBarFn = t => MathF.Exp(t * -12.0f);`
`261`	`258`	`}`
`262`	`259`
`263`	`260`	`return Enumerable`
`@@ -266,7 +263,7 @@ protected float[] GetBetasForAlphaBar()`
`266`	`263`	`{`
`267`	`264`	`var t1 = (float)i / _options.TrainTimesteps;`
`268`	`265`	`var t2 = (float)(i + 1) / _options.TrainTimesteps;`
`269`		`- return Math.Min(1f - alphaBarFn(t2) / alphaBarFn(t1), _options.MaximumBeta);`
	`266`	`+ return MathF.Min(1f - alphaBarFn(t2) / alphaBarFn(t1), _options.MaximumBeta);`
`270`	`267`	`}).ToArray();`
`271`	`268`	`}`
`272`	`269`
`@@ -298,13 +295,13 @@ protected float[] Interpolate(float[] timesteps, float[] range, float[] sigmas)`
`298`	`295`	`// If timesteps[i] is less than the first element in range, use the first value in sigmas`
`299`	`296`	`else if (index == -1)`
`300`	`297`	`{`
`301`		`- result[i] = sigmas[sigmas.Length - 1];`
	`298`	`+ result[i] = sigmas[0];`
`302`	`299`	`}`
`303`	`300`
`304`	`301`	`// If timesteps[i] is greater than the last element in range, use the last value in sigmas`
`305`		`- else if (index == -range.Length - 1)`
	`302`	`+ else if (index > range.Length - 1)`
`306`	`303`	`{`
`307`		`- result[i] = sigmas[0];`
	`304`	`+ result[i] = sigmas[sigmas.Length - 1];`
`308`	`305`	`}`
`309`	`306`
`310`	`307`	`// Otherwise, interpolate linearly between two adjacent values in sigmas`
`@@ -340,14 +337,14 @@ protected float[] ConvertToKarras(float[] inSigmas)`
`340`	`337`	`.ToArray();`
`341`	`338`
`342`	`339`	`// Calculate the inverse of sigmaMin and sigmaMax raised to the power of 1/rho`
`343`		`- float minInvRho = (float)Math.Pow(sigmaMin, 1.0 / rho);`
`344`		`- float maxInvRho = (float)Math.Pow(sigmaMax, 1.0 / rho);`
	`340`	`+ float minInvRho = MathF.Pow(sigmaMin, 1.0f / rho);`
	`341`	`+ float maxInvRho = MathF.Pow(sigmaMax, 1.0f / rho);`
`345`	`342`
`346`	`343`	`// Calculate the Karras noise schedule using the formula from the paper`
`347`	`344`	`float[] sigmas = new float[_options.InferenceSteps];`
`348`	`345`	`for (int i = 0; i < _options.InferenceSteps; i++)`
`349`	`346`	`{`
`350`		`- sigmas[i] = (float)Math.Pow(maxInvRho + ramp[i] * (minInvRho - maxInvRho), rho);`
	`347`	`+ sigmas[i] = MathF.Pow(maxInvRho + ramp[i] * (minInvRho - maxInvRho), rho);`
`351`	`348`	`}`
`352`	`349`
`353`	`350`	`// Return the resulting noise schedule`
`@@ -366,7 +363,7 @@ protected float[] SigmaToTimestep(float[] sigmas, float[] logSigmas)`
`366`	`363`	`var timesteps = new float[sigmas.Length];`
`367`	`364`	`for (int i = 0; i < sigmas.Length; i++)`
`368`	`365`	`{`
`369`		`- float logSigma = (float)Math.Log(sigmas[i]);`
	`366`	`+ float logSigma = MathF.Log(sigmas[i]);`
`370`	`367`	`float[] dists = new float[logSigmas.Length];`
`371`	`368`
`372`	`369`	`for (int j = 0; j < logSigmas.Length; j++)`