Did You See Us On National Television?
AiNetStudio
AI is accelerating discovery everywhere—from reading ancient scrolls with imaging + machine learning to optimizing complex physical systems. In every case, fine-tuning to achieve resonance is critical—and that’s where AI shines.
Speculative Concepts
Our Focus
I thought I would demonstrate how you can apply ML.NET to explore parameter spaces in safely simulated or instrumented setups—adjusting voltages, frequencies, phases, and rotations to lock onto stable resonant regimes. Unlike Python toolchains that often require stitching together many external libraries, ML.NET is natively integrated into the .NET ecosystem, giving us type safety, performance, and seamless deployment in our C# applications. Backed by Microsoft, it allows our research code to move directly into production Windows apps without rewrites, ensuring both speed and stability in experimentation.
AI Type #1 – Physical Feedback
AI measures changes in lift or weight on a precision scale and dynamically adjusts voltages, frequencies, and rotations in a real-time feedback loop to tune resonance and maximize anti-gravity effects.
AI Type #2 – Virtual Simulation
In this approach, the anti-gravity engine exists only in code. Components are modeled with physics-based formulas, and AI explores the parameter space virtually to discover resonant behaviors before any physical build is attempted.
AiNetStudio – ML.NET Graviflyer Demo
1) Data Model
// Models/GraviflyerReading.cs
using Microsoft.ML.Data;
public sealed class GraviflyerReading
{
public float VoltageKV { get; set; }
public float FrequencyKHz { get; set; }
public float PhaseDeg { get; set; }
public float RotationRPM { get; set; }
public float UltrasoundKHz { get; set; }
public float CurrentmA { get; set; }
public float TempC { get; set; }
public float Humidity { get; set; }
public float Vibration { get; set; }
[ColumnName("Label")] public float LiftGrams { get; set; }
}
public sealed class GraviflyerPrediction
{
public float Score { get; set; } // predicted LiftGrams
}
2) Train with ML.NET (LightGBM)
// Services/ModelTrainer.cs
using System.Collections.Generic;
using Microsoft.ML;
using Microsoft.ML.Trainers.LightGbm;
public static class ModelTrainer
{
public static (ITransformer model, DataViewSchema schema, RegressionMetrics metrics)
Train(IReadOnlyList<GraviflyerReading> rows)
{
var ml = new MLContext(seed: 42);
var data = ml.Data.LoadFromEnumerable(rows);
var features = new[]
{
nameof(GraviflyerReading.VoltageKV),
nameof(GraviflyerReading.FrequencyKHz),
nameof(GraviflyerReading.PhaseDeg),
nameof(GraviflyerReading.RotationRPM),
nameof(GraviflyerReading.UltrasoundKHz),
nameof(GraviflyerReading.CurrentmA),
nameof(GraviflyerReading.TempC),
nameof(GraviflyerReading.Humidity),
nameof(GraviflyerReading.Vibration),
};
var pipeline =
ml.Transforms.Concatenate("Features", features)
.Append(ml.Transforms.NormalizeMinMax("Features"))
.Append(ml.Regression.Trainers.LightGbm(new LightGbmRegressionTrainer.Options
{
LabelColumnName = "Label",
FeatureColumnName = "Features",
NumberOfLeaves = 31,
MinimumExampleCountPerLeaf = 10,
LearningRate = 0.05f,
NumberOfIterations = 300
}));
var model = pipeline.Fit(data);
var preds = model.Transform(data);
var metrics = ml.Regression.Evaluate(preds, "Label", "Score");
return (model, data.Schema, metrics);
}
}
3) Propose Next Settings (Model-Guided Search)
// Services/CandidateSelector.cs
using System.Collections.Generic;
using System.Linq;
using Microsoft.ML;
public sealed record Candidate(float VoltageKV, float FrequencyKHz, float PhaseDeg, float RotationRPM, float UltrasoundKHz);
public static class CandidateSelector
{
public static IReadOnlyList<Candidate> ProposeTopN(
MLContext ml, ITransformer model, int topN = 5,
(float min, float max, float step) v = (5, 40, 5),
(float min, float max, float step) f = (5, 200, 5),
(float min, float max, float step) p = (0, 360, 15),
(float min, float max, float step) r = (0, 4000, 200),
(float min, float max, float step) u = (0, 40, 5))
{
var engine = ml.Model.CreatePredictionEngine<GraviflyerReading, GraviflyerPrediction>(model);
var list = new List<(Candidate c, float predicted)>();
for (var vv = v.min; vv <= v.max; vv += v.step)
for (var ff = f.min; ff <= f.max; ff += f.step)
for (var pp = p.min; pp <= p.max; pp += p.step)
for (var rr = r.min; rr <= r.max; rr += r.step)
for (var uu = u.min; uu <= u.max; uu += u.step)
{
var c = new Candidate(vv, ff, pp, rr, uu);
var pred = engine.Predict(new GraviflyerReading {
VoltageKV = vv, FrequencyKHz = ff, PhaseDeg = pp,
RotationRPM = rr, UltrasoundKHz = uu
}).Score;
list.Add((c, pred));
}
return list.OrderByDescending(x => x.predicted).Take(topN).Select(x => x.c).ToList();
}
}
4) Closed-Loop Runner (Apply → Measure → Learn)
// Services/ExperimentRunner.cs
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.ML;
public interface IActuator
{
Task ApplyAsync(float voltageKV, float freqKHz, float phaseDeg, float rpm, float ultrasoundKHz, CancellationToken ct);
}
public interface ISensor
{
Task<float> ReadLiftGramsAsync(CancellationToken ct);
Task<(float tempC, float humidity, float currentmA, float vibration)> ReadTelemetryAsync(CancellationToken ct);
}
public sealed class ExperimentRunner
{
private readonly IActuator _actuator;
private readonly ISensor _sensor;
private readonly List<GraviflyerReading> _buffer = new();
public ExperimentRunner(IActuator actuator, ISensor sensor)
{
_actuator = actuator;
_sensor = sensor;
}
public async Task RunAsync(TimeSpan settleDelay, int cycles, CancellationToken ct)
{
var ml = new MLContext(seed: 42);
for (int i = 0; i < cycles; i++)
{
ct.ThrowIfCancellationRequested();
var (model, _, metrics) = ModelTrainer.Train(_buffer);
Console.WriteLine($"R^2={metrics.RSquared:F3}, MAE={metrics.MeanAbsoluteError:F3}");
var next = CandidateSelector.ProposeTopN(ml, model, topN: 3);
foreach (var c in next)
{
ct.ThrowIfCancellationRequested();
float V(float x) => Math.Clamp(x, 0, 40);
float F(float x) => Math.Clamp(x, 0, 200);
float P(float x) => Math.Clamp(x, 0, 360);
float R(float x) => Math.Clamp(x, 0, 4000);
float U(float x) => Math.Clamp(x, 0, 40);
await _actuator.ApplyAsync(V(c.VoltageKV), F(c.FrequencyKHz), P(c.PhaseDeg), R(c.RotationRPM), U(c.UltrasoundKHz), ct);
await Task.Delay(settleDelay, ct);
var lift = await _sensor.ReadLiftGramsAsync(ct);
var (tempC, humidity, currentmA, vibration) = await _sensor.ReadTelemetryAsync(ct);
var row = new GraviflyerReading
{
VoltageKV = V(c.VoltageKV),
FrequencyKHz = F(c.FrequencyKHz),
PhaseDeg = P(c.PhaseDeg),
RotationRPM = R(c.RotationRPM),
UltrasoundKHz = U(c.UltrasoundKHz),
CurrentmA = currentmA,
TempC = tempC,
Humidity = humidity,
Vibration = vibration,
LiftGrams = lift
};
_buffer.Add(row);
Console.WriteLine($"Measured Lift: {lift:F3} g @ V={row.VoltageKV}, f={row.FrequencyKHz}kHz, φ={row.PhaseDeg}°, rpm={row.RotationRPM}, us={row.UltrasoundKHz}kHz");
}
}
}
public IReadOnlyList<GraviflyerReading> GetAll() => _buffer;
}
5) Hardware Stubs (replace with your drivers)
// Hardware/ActuatorAndSensorStubs.cs
using System;
using System.Threading;
using System.Threading.Tasks;
public sealed class StubActuator : IActuator
{
public Task ApplyAsync(float voltageKV, float freqKHz, float phaseDeg, float rpm, float ultrasoundKHz, CancellationToken ct)
{
Console.WriteLine($"Apply: V={voltageKV}kV, f={freqKHz}kHz, φ={phaseDeg}°, rpm={rpm}, us={ultrasoundKHz}kHz");
return Task.CompletedTask;
}
}
public sealed class StubSensor : ISensor
{
private readonly Random _rng = new(123);
public Task<float> ReadLiftGramsAsync(CancellationToken ct) => Task.FromResult((float)(_rng.NextDouble() * 2.0 - 0.5));
public Task<(float tempC, float humidity, float currentmA, float vibration)> ReadTelemetryAsync(CancellationToken ct)
=> Task.FromResult((22.0f, 40.0f, 10.0f, 0.0f));
}
About Our Company
In 1991, we made HUNDREDS of MILLIONS of DOLLARS using an AI software program called StationBreak®. It used Machine Learning and Bayesian Optimization to analyze how to distribute advertising dollars across 28,000 broadcast television stations to maximize net profits from airing Over 100 of Famous Celebrity Infomercials.
Now, we decided to create an AI-Powered Business Application, AiNetStudio®, incorporating the use of those techniques — including AI, Neural Networks, and Bayesian Optimization — to modernize business tasks liek accounting and advertising to help small businesses understand how to grow their businesses.
