Software Discussions

Axiom CODAR - My AI Coding Agent

2026-03-19T09:51:19.8930000

My Friends,

I am going to share my recent effort: AI Coding Agent that is fully Automated end to end.

I have tested my Agent, and it runs really well! Here is an example of my recent project, a World Class Machine Learning Library based on PyTorch built in .NET:

Axiom CODAR built this whole project from the start! Its not yet finished. Based entirely on XAI's Grok LLM, it uses C# as a super smart Agent that can do pretty much anything in the directory the Agent is given. The Agent is restricted to this directory only, for security reasons.

IMPORTANT: Do not share your API Keys with anyone! Ever!

The first time you open Axiom CODAR, a Directory needs to be set, this is your working directory. The second time, it opens the base directory if no Api Key is present. You will see a file: "grokconfig.json" - You need to open this file in your favorite text editor, and add your XAPI Key, get it from here: https://docs.x.ai/developers/quickstart#step-2-generate-an-api-key

Save your file and click it, and the app should open. At this point, you're off to the races, and your computer will work on any project you give it, and do the best it can to complete all tasks to a very high perfection!

This is very early in development, so it may have a few bugs that need to be ironed out, and I am certain Improvements can be made.

Below is the first version of: AxiomCODAR.v1 - Enjoy and be amazed by this amazing tool! Its in zip file format.

EDIT: Here is my github account where updates will be added for this and other projects: https://github.com/OzzieAI-AU

Disclaimer:

This Agent will use Credit that you need to pay for. It is efficient, but it still can use lots of Credit. It is your responsibility to keep track of your own credit and usage; no responsibility is accepted by me or my platform!

Best Wishes,

Chris

Google Chrome Video Extractor

2025-01-26T00:34:35.5300000

My Friends,

I want to open source a small project I use from time to time: Video Extractor

This is a Google Chrome Extension, so its simple and easy to install, if you use Google Chrome. Its early days, there is a lot that can be done to extend this tool, and make it better! It does not work with video blobs yet. One day soon maybe I will include Blob Videos.

Inside a file: Google Chrome Video Extractor, create the file structure:

In the File: background.js

chrome.runtime.onInstalled.addListener(() => {
  console.log('Extension installed');
});

In the File: content.js

function extractAllVideos() {
  const videos = document.querySelectorAll('video');
  const videoList = Array.from(videos).map((video, index) => {
    const sourceUrl = video.src || (video.querySelector('source') ? video.querySelector('source').src : '');
    const poster = video.poster || '';
    const width = video.width || video.videoWidth;
    const height = video.height || video.videoHeight;
    const videoName = video.getAttribute('title') || `Video ${index + 1}`;
    const videoTag = videuterHTML;
    return { videoTag: videoTag, videoName: videoName, sourceUrl: sourceUrl, poster: poster, width: width, height: height };
  }).filter(video => video.sourceUrl !== ''); // Filter out videos without source URLs
  return videoList;
}

chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  if (request.action === 'extractVideos') {
    const videoInfo = extractAllVideos();
    sendResponse(videoInfo);
  }
});

In the File: manifest.json

{
  "manifest_version": 3,
  "name": "Video Extractor",
  "version": "1.0",
  "description": "Extracts video tags and their source URLs, then opens videos in a new tab",
  "permissions": [
    "activeTab",
    "scripting"
  ],
  "background": {
    "service_worker": "background.js"
  },
  "action": {
    "default_popup": "popup.html"
  },
  "content_scripts": [
    {
      "matches": ["<all_urls>"],
      "js": ["content.js"]
    }
  ]
}

In the File: popup.html

<!DOCTYPE html>
<html>

<head>
  <title>Video Extractor</title>
  <link href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" rel="stylesheet">
  <style>
    body {
      font-family: Arial, sans-serif;
      padding: 20px;
      border-radius: 3px;
      width: 473px;
      background-color: #343a40;
      color: white;
    }

    .T {
      margin-top: 3x;
      padding-left: 20px;
      padding-right: 20px;
      border: #454d55 1px solid;
      border-radius: 7px;
    }

    table {
      border: none;
    }

    thead {
    display: table-header-group;
    vertical-align: middle;
    unicode-bidi: isolate;
    border-color: none;
    }

    .video-list {
      max-height: 400px;
      overflow-y: auto;
    }

    .thumbnail {
      width: 124px;
      height: 70px;
      object-fit: cover;
      border-radius: 3px;
    }

    .scrollbar-dark::-webkit-scrollbar {
      width: 8px;
      background-color: #343a40;
    }

    .scrollbar-dark::-webkit-scrollbar-thumb {
      background-color: #6c757d;
      border-radius: 10px;
    }
  </style>
</head>

<body>
  <h3 class="text-center">Video Extractor</h3>
  <div class="T">
    <table class="table table-dark table-striped">
      <thead>
        <tr>
          <th scope="col">Thumbnail</th>
          <th scope="col">Details</th>
        </tr>
      </thead>
      <tbody id="videoList" class="video-list scrollbar-dark"></tbody>
    </table>
  </div>
  <script src="popup.js"></script>
</body>

</html>

In the File: popup.js

chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
  const activeTab = tabs[0];
  chrome.scripting.executeScript({
    target: { tabId: activeTab.id },
    function: extractAllVideosInTab
  }, (results) => {
    if (results && results[0] && results[0].result) {
      const videoList = results[0].result;
      displayVideos(videoList);
    } else {
      alert('No videos found on this page.');
    }
  });
});

function extractAllVideosInTab() {
  const videos = document.querySelectorAll('video');
  const videoList = Array.from(videos).map((video, index) => {
    const sourceUrl = video.src || (video.querySelector('source') ? video.querySelector('source').src : '');
    const poster = video.poster || '';
    const width = video.width || video.videoWidth;
    const height = video.height || video.videoHeight;
    const videoName = video.getAttribute('title') || `Video ${index + 1}`;
    const videoTag = videuterHTML;
    return { videoTag: videoTag, videoName: videoName, sourceUrl: sourceUrl, poster: poster, width: width, height: height };
  }).filter(video => video.sourceUrl !== ''); // Filter out videos without source URLs
  return videoList;
}

function displayVideos(videoList) {
  const videoListElement = document.getElementById('videoList');
  videoListElement.innerHTML = '';
  videoList.forEach(video => {
    const row = document.createElement('tr');

    const thumbnailCell = document.createElement('td');
    const thumbnail = document.createElement('img');
    thumbnail.src = video.poster || 'https://via.placeholder.com/124x70?text=No+Thumbnail';
    thumbnail.className = 'thumbnail';
    thumbnailCell.appendChild(thumbnail);

    const detailsCell = document.createElement('td');
    detailsCell.innerHTML = `
      <strong>${video.videoName}</strong><br>
      <small>Width: ${video.width}px, Height: ${video.height}px</small><br>
      <a href="${video.sourceUrl}" target="_blank" style="color: #17a2b8;">Source URL</a>
    `;

    row.appendChild(thumbnailCell);
    row.appendChild(detailsCell);
    videoListElement.appendChild(row);
  });
}

Easy, then once you have this done, all you need to do is add the extension:

Adding a Google Chrome extension is pretty straightforward! Here's a step-by-step guide:

Open Chrome: Make sure you're using the Google Chrome browser.

Go to the Chrome Web Store: You can access it by clicking on this [link](https://support.google.com/chrome_webstore/answer/2664769?hl=en).

Find an Extension: Use the search bar or browse through categories to find the extension you want.

Click "Add to Chrome": Once you've found an extension you like, click the "Add to Chrome" button.

Confirm Installation: A pop-up will appear asking for confirmation. Click "Add Extension" to install it.

Access the Extension: After installation, you'll see the extension's icon next to the address bar. Click on it to start using the extension.

And that's it! You're all set to enjoy your new extension. 😊

Once done, you will be able to access Video Extractor like so:

Enjoy!

Best Wishes,

Chris

Crypto Currency Software Monitor

2025-03-06T21:00:13.6730000

My Friends,

I want to share some of my work on Crypto, and Software tracking changes in the Market. I am using AI as Prediction Engines, Data Engines, to download data and so on.

Disclaimer:

I am not a Financial Expert, what I share with you is just an experiment, so please take from it what you will! Crypto is risky, you can very easily loose your money! Any of my comments must not be accepted as advice, it is not, and no responsibility will be accepted. You must accept the risks and your own activities are your own responsibility.

Datasets

There are very few Datasets available for Crypto! Its a real shame, because with the right Dataset, one could do a lot more to make accurate predictions! I have put together a Dataset: Here

Size: 270Mb
Resolutions: 5, 15, 30, 60, 120, 240, D, 3D, W
Cutoff Date: Thursday 6th March 2025
Download: Here

// Get the Data and read in as a Json String:
string jsonString = File.ReadAllText("Path to your data");

// Deserialize the latest price data:
List<LatestPrice> dataset = JsonSerializer.Deserialize<List<LatestPrice>>(jsonString);

    /// <summary>
    /// Represents a cryptocurrency price update with status and candlestick data.
    /// </summary>
    public class LatestPrice
    {
        /// <summary>
        /// The status of the price update (e.g., "ok" indicates successful data).
        /// </summary>
        [JsonPropertyName("s")]
        public string Status { get; set; }

        /// <summary>
        /// The current or closing price of the cryptocurrency.
        /// </summary>
        [JsonPropertyName("price")]
        public double Price { get; set; }

        /// <summary>
        /// The opening price of the cryptocurrency for the period.
        /// </summary>
        [JsonPropertyName("open")]
        public double OpenPrice { get; set; }

        /// <summary>
        /// The lowest price of the cryptocurrency during the period.
        /// </summary>
        [JsonPropertyName("low")]
        public double LowPrice { get; set; }

        /// <summary>
        /// The highest price of the cryptocurrency during the period.
        /// </summary>
        [JsonPropertyName("high")]
        public double HighPrice { get; set; }

        /// <summary>
        /// The highest price of the cryptocurrency during the period.
        /// </summary>
        public int Timestamp { get; internal set; }
    }

Typically, one data record would look like:

  {
    "s": "ok",
    "price": 145567.4031468,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741254545
  }

I think most would agree, the OHLCV Data, Open, High, Low, Close and Volume Data, is the best data to look at. However, this data does not include the most important data, the Tick Data or the 10 Second Data!

The One Tick Data

The Tick Data or some refer to the 10 Second Data is the data we see in the Charts, every update, where the line on the chart moves with every Update, each Candle displayed is made up of X number of Ticks, which are Market updates for the timeframe given:

Above, the the Chart, we are on the One Hour time frame, which is the 60 minutes shown. If one watches the Chart, we have a Candle for every One Hour shown. However, the Red Line, shown at: 4.068133, is on a different Time Frame, typically, it is 10 Seconds, and moves up or Down according to market value, every 10 Seconds. So, you ask: "Why is this important?"

This data is important, if one wants to make predictions on Market movement, one can evaluate this 10 second data to see big shifts in the market very early on in the game!

For Example:

Each Candle shown is for One Hour, and this is how a Candle works:

Where:

Bullish Candle = Increase in Market Value.
Bearish Candle = Decrease in Market Value.

This means, each Candle might be made up of:

[
  {
    "s": "ok",
    "price": 145567.4031468,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741254545
  },
  {
    "s": "ok",
    "price": 145520.46327524,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741254614
  },
  {
    "s": "ok",
    "price": 145564.42804449,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741254654
  },
  {
    "s": "ok",
    "price": 145617.9267137,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741254690
  },
  {
    "s": "ok",
    "price": 145578.68046191,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741254727
  },
  {
    "s": "ok",
    "price": 145637.58190353,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741254761
  },
  {
    "s": "ok",
    "price": 145618.64815215,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741254797
  },
  {
    "s": "ok",
    "price": 145580.54016992,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741254830
  },
  {
    "s": "ok",
    "price": 145531.77093057,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741254865
  },
  {
    "s": "ok",
    "price": 145509.7590418,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741254900
  },
  {
    "s": "ok",
    "price": 145317.62793503,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741254937
  },
  {
    "s": "ok",
    "price": 145433.38322856,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741254975
  },
  {
    "s": "ok",
    "price": 145439.97079788,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741255008
  },
  {
    "s": "ok",
    "price": 145439.44186895,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741255052
  },
  {
    "s": "ok",
    "price": 145460.67916664,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741255089
  },
  {
    "s": "ok",
    "price": 145436.23623911,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741255121
  },
  {
    "s": "ok",
    "price": 145420.62482179,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741255155
  },
  {
    "s": "ok",
    "price": 145458.88401393,
    "open": 145123.87091991,
    "low": 140956.87897272,
    "high": 148669.89984942,
    "Timestamp": 1741255186
  }
]

Of course, at Ten Seconds, in Sixty Minutes, we would have:

Convert 60 minutes to seconds:
- 60 minutes × 60 seconds/minute = 3,600 seconds
Divide total seconds by 10-second intervals:
- 3,600 seconds ÷ 10 seconds/interval = 360 intervals

So, there are 360 ten-second intervals in 60 minutes, thus making up one Candle on the One Hour interval.

The Input Schema Class: AIBreakoutInputSchema.cs

namespace AdvancedCryptoTrader.AI
{



    #region Using Statements:



    using Microsoft.ML.Data;



    #endregion



    /// <summary>
    /// Represents the input schema for breakout prediction, including both historical and short-term features.
    /// </summary>
    public class AIBreakoutInputSchema
    {
        /// <summary>
        /// The label for the breakout prediction (optional for training, "Bullish", "Bearish", or "NoBreakout").
        /// </summary>
        [ColumnName("Label")]
        public string Label { get; set; }

        /// <summary>
        /// Historical timestamp in Unix seconds for the candlestick.
        /// </summary>
        [ColumnName("Timestamp")]
        public long Timestamp { get; set; }

        /// <summary>
        /// Closing price of the historical candlestick.
        /// </summary>
        [ColumnName("ClosePrice")]
        public float ClosePrice { get; set; }

        /// <summary>
        /// Opening price of the historical candlestick.
        /// </summary>
        [ColumnName("OpenPrice")]
        public float OpenPrice { get; set; }

        /// <summary>
        /// Highest price during the historical candlestick period.
        /// </summary>
        [ColumnName("HighPrice")]
        public float HighPrice { get; set; }

        /// <summary>
        /// Lowest price during the historical candlestick period.
        /// </summary>
        [ColumnName("LowPrice")]
        public float LowPrice { get; set; }

        /// <summary>
        /// Trading volume during the historical candlestick period.
        /// </summary>
        [ColumnName("Volume")]
        public float Volume { get; set; }

        /// <summary>
        /// Price change percentage for the historical candlestick ((Close - Open) / Open * 100).
        /// </summary>
        [ColumnName("PriceChangePct")]
        public float PriceChangePct { get; set; }

        /// <summary>
        /// Price range for the historical candlestick (High - Low).
        /// </summary>
        [ColumnName("PriceRange")]
        public float PriceRange { get; set; }

        /// <summary>
        /// Simple Moving Average over a lookback period (e.g., 20 periods).
        /// </summary>
        [ColumnName("Sma")]
        public float Sma { get; set; }

        /// <summary>
        /// Relative Strength Index over a lookback period (e.g., 14 periods).
        /// </summary>
        [ColumnName("Rsi")]
        public float Rsi { get; set; }

        /// <summary>
        /// Average True Range over a lookback period (e.g., 14 periods) for historical volatility.
        /// </summary>
        [ColumnName("Atr")]
        public float Atr { get; set; }

        /// <summary>
        /// Short-term (10-second) price difference magnitude (absolute value of Close price change over 10 seconds).
        /// </summary>
        [ColumnName("ShortTermPriceDiffMagnitude")]
        public float ShortTermPriceDiffMagnitude { get; set; }

        /// <summary>
        /// Short-term (10-second) rolling average of price difference magnitude over a window (e.g., 50 updates, 500 seconds).
        /// </summary>
        [ColumnName("ShortTermPriceDiffRollingAvg")]
        public float ShortTermPriceDiffRollingAvg { get; set; }

        /// <summary>
        /// Short-term (10-second) volatility (standard deviation of price differences over a window).
        /// </summary>
        [ColumnName("ShortTermVolatility")]
        public float ShortTermVolatility { get; set; }

        /// <summary>
        /// Slope of short-term price movement over a window (e.g., last 20 updates, 200 seconds).
        /// </summary>
        [ColumnName("ShortTermPriceSlope")]
        public float ShortTermPriceSlope { get; set; }
    }
}

Here is the C# ML.NET Class: AIBreakoutPredictor.cs

namespace AdvancedCryptoTrader.AI
{



    #region Using Statements:



    using Microsoft.ML;
    using Microsoft.ML.Data;
    using Microsoft.ML.Transforms;

    using System;
    using System.Linq;
    using System.Collections.Generic;



    #endregion


    /// <summary>
    /// AIBreakoutPredictor class that uses a Transformer model to predict market breakout trends (bullish, bearish, or no breakout)
    /// based on historical and short-term (10-second) price data.
    /// </summary>
    public partial class AIBreakoutPredictor
    {



        #region Fields:



        /// <summary>
        /// The MLContext for the Machine Learning Pipeline.
        /// </summary>
        private readonly MLContext _mlContext;
        
        
        
        /// <summary>
        /// The Transformer Model.
        /// </summary>
        private ITransformer _model;
        
        
        
        /// <summary>
        /// Historical Loopback Period.
        /// </summary>
        private const int HistoricalLookbackPeriod = 50; // Number of historical candlesticks (e.g., 1H) for sequence
        
        
        
        /// <summary>
        /// Shortterm Loopback Period.
        /// </summary>
        private const int ShortTermLookbackPeriod = 50;  // Number of 10-second updates for short-term features
        
        
        
        /// <summary>
        /// Breakout threshold.
        /// </summary>
        private const float BreakoutThreshold = 0.05f;   // 5% price change threshold for defining breakouts



        #endregion



        #region Properties:



        #endregion



        /// <summary>
        /// Initializes a new instance of the AIBreakoutPredictor class.
        /// </summary>
        /// <param name="ailogger">Optional logging action for debugging and monitoring. Defaults to Console.WriteLine if null.</param>
        public AIBreakoutPredictor(Action<string> ailogger = null)
        {
            
            _mlContext = new MLContext(seed: 0);
            LoadModelFromDisk(ailogger ?? (s => Console.WriteLine(s))); // Load existing model or start fresh
        }



        /// <summary>
        /// Trains the Transformer model with historical and short-term price data to predict breakouts.
        /// </summary>
        /// <param name="prices">List of Price objects containing historical candlestick data (e.g., 1H timeframe).</param>
        /// <param name="shortTermPrices">List of Price objects containing short-term (10-second) price updates.</param>
        /// <param name="ailogger">Logging action for training progress and errors.</param>
        /// <summary>
        /// Trains the Transformer model with historical and short-term price data to predict breakouts.
        /// </summary>
        /// <param name="prices">List of Price objects containing historical candlestick data (e.g., 1H timeframe).</param>
        /// <param name="shortTermPrices">List of Price objects containing short-term (10-second) price updates.</param>
        /// <param name="ailogger">Logging action for training progress and errors.</param>
        public void Train(List<Price> prices, List<Price> shortTermPrices, Action<string> ailogger)
        {
            
            if (prices == null || prices.Count == 0 || shortTermPrices == null || shortTermPrices.Count == 0)
            {
                ailogger("Train: Error - No price data provided for training.");
                throw new ArgumentException("Price data cannot be null or empty.");
            }

            ailogger($"Train: Processing {prices.Count} historical candlesticks and {shortTermPrices.Count} short-term updates.");

            // Calculate features from historical and short-term data
            var historicalFeatures = CalculateHistoricalFeatures(prices).ToList();
            var shortTermFeatures = CalculateShortTermFeatures(shortTermPrices).ToList();

            // Align historical and short-term data by timestamp
            var trainingData = AlignData(historicalFeatures, shortTermFeatures, ailogger).ToList();

            if (trainingData.Count == 0)
            {
                ailogger("Train: Error - No aligned training data generated.");
                throw new InvalidOperationException("No training data available after alignment.");
            }

            ailogger($"Train: Generated {trainingData.Count} training records. Sample - Timestamp={trainingData.First().Timestamp}, ClosePrice={trainingData.First().ClosePrice:F2}, ShortTermPriceDiffMagnitude={trainingData.First().ShortTermPriceDiffMagnitude:F2}");

            // Create ML.NET data view
            var dataView = _mlContext.Data.LoadFromEnumerable(trainingData);
            ailogger("Train: DataView created for Transformer training.");

            // Define the pipeline for non-sequence multiclass classification (no Sequence transform for older ML.NET)
            var pipeline = _mlContext.Transforms
                .Conversion.MapValueToKey("Label", "Label") // Convert string labels to keys for multiclass
                .Append(_mlContext.Transforms.Concatenate("Features", // Concatenate all numeric features
                    "ClosePrice", "OpenPrice", "HighPrice", "LowPrice", "Volume", "PriceChangePct", "PriceRange",
                    "Sma", "Rsi", "Atr", "ShortTermPriceDiffMagnitude", "ShortTermPriceDiffRollingAvg",
                    "ShortTermVolatility", "ShortTermPriceSlope"))
                .Append(_mlContext.Transforms.NormalizeMinMax("Features")) // Normalize features for better training
                .Append(_mlContext.MulticlassClassification.Trainers
                    .LbfgsMaximumEntropy(
                        labelColumnName: "Label",
                        featureColumnName: "Features",
                        l1Regularization: 1f,
                        l2Regularization: 1f,
                        optimizationTolerance: 1E-07f,
                        historySize: 20,
                        enforceNonNegativity: false)) // Use L-BFGS for multiclass without advancedSettings
                .Append(_mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabel", "PredictedLabel")); // Convert keys back to labels

            ailogger("Train: Pipeline defined for L-BFGS multiclass model.");
            _model = pipeline.Fit(dataView);
            ailogger("Train: Model training completed successfully.");

            SaveModelToDisk(ailogger); // Save the trained model
        }



        /// <summary>
        /// Predicts the next breakout trend (Bullish, Bearish, or NoBreakout) for a sequence of prices.
        /// </summary>
        /// <param name="prices">List of historical Price objects (e.g., 1H candlesticks).</param>
        /// <param name="shortTermPrices">List of short-term (10-second) Price updates.</param>
        /// <param name="ailogger">Logging action for prediction details.</param>
        /// <returns>Predicted breakout trend with probability scores and confidence.</returns>
        public AIBreakoutOutputSchema Predict(List<Price> prices, List<Price> shortTermPrices, Action<string> ailogger)
        {
            
            if (_model == null)
                throw new InvalidOperationException("Model must be trained before predicting.");

            if (prices == null || prices.Count == 0 || shortTermPrices == null || shortTermPrices.Count == 0)
            {
                ailogger("Predict: Error - No price data provided for prediction.");
                throw new ArgumentException("Price data cannot be null or empty.");
            }

            ailogger($"Predict: Processing {prices.Count} historical candlesticks and {shortTermPrices.Count} short-term updates.");

            // Calculate features from historical and short-term data
            var historicalFeatures = CalculateHistoricalFeatures(prices).ToList();
            var shortTermFeatures = CalculateShortTermFeatures(shortTermPrices).ToList();

            // Align data for prediction
            var predictionInput = AlignData(historicalFeatures, shortTermFeatures, ailogger).Last();

            // Create prediction engine for single-row prediction
            var predEngine = _mlContext.Model.CreatePredictionEngine<AIBreakoutInputSchema, AIBreakoutOutputSchema>(_model);
            var prediction = predEngine.Predict(predictionInput);

            // Calculate confidence as the highest probability
            prediction.Confidence = prediction.Probabilities.Max();

            ailogger($"Predict: Output - PredictedLabel={prediction.PredictedLabel}, Probabilities=[{string.Join(", ", prediction.Probabilities.Select(p => p.ToString("F2")))}], Confidence={prediction.Confidence:F2}");
            return prediction;
        }



        /// <summary>
        /// Calculates technical and derived features from historical price data (e.g., 1H candlesticks).
        /// </summary>
        /// <param name="prices">List of Price objects for historical data.</param>
        /// <returns>Enumerable of InputBreakoutSchema with calculated features.</returns>
        private IEnumerable<AIBreakoutInputSchema> CalculateHistoricalFeatures(List<Price> prices)
        {
            
            var priceList = prices.ToList();
            var features = new List<AIBreakoutInputSchema>();

            for (int i = 0; i < priceList.Count; i++)
            {
                var price = priceList[i];
                var feature = new AIBreakoutInputSchema
                {
                    Timestamp = price.Timestamp,
                    ClosePrice = (float)price.ClosePrice,
                    OpenPrice = (float)price.OpenPrice,
                    HighPrice = (float)price.HighPrice,
                    LowPrice = (float)price.LowPrice,
                    Volume = (float)price.Volume,
                    PriceChangePct = (float)((price.ClosePrice - price.OpenPrice) / price.OpenPrice * 100),
                    PriceRange = (float)(price.HighPrice - price.LowPrice)
                };

                // Calculate SMA (Simple Moving Average) over HistoricalLookbackPeriod
                if (i >= HistoricalLookbackPeriod)
                {
                    var periodPrices = priceList.Skip(i - HistoricalLookbackPeriod).Take(HistoricalLookbackPeriod);
                    feature.Sma = (float)periodPrices.Average(p => p.ClosePrice);
                }

                // Calculate RSI (Relative Strength Index) over HistoricalLookbackPeriod
                if (i >= HistoricalLookbackPeriod)
                {
                    var periodPrices = priceList.Skip(i - HistoricalLookbackPeriod).Take(HistoricalLookbackPeriod);
                    feature.Rsi = (float)CalculateRSI(periodPrices.Select(p => p.ClosePrice));
                }

                // Calculate ATR (Average True Range) over HistoricalLookbackPeriod
                if (i >= HistoricalLookbackPeriod)
                {
                    var periodPrices = priceList.Skip(i - HistoricalLookbackPeriod).Take(HistoricalLookbackPeriod);
                    feature.Atr = (float)CalculateATR(periodPrices);
                }

                features.Add(feature);
            }

            return features;
        }



        /// <summary>
        /// Calculates short-term features from 10-second price updates.
        /// </summary>
        /// <param name="prices">List of Price objects for 10-second updates.</param>
        /// <returns>Enumerable of short-term feature aggregates for alignment with historical data.</returns>
        private IEnumerable<AIBreakoutInputSchema> CalculateShortTermFeatures(List<Price> prices)
        {
            
            var priceList = prices.ToList();
            var features = new List<AIBreakoutInputSchema>();

            for (int i = 0; i < priceList.Count; i++)
            {
                var price = priceList[i];
                var feature = new AIBreakoutInputSchema
                {
                    Timestamp = price.Timestamp,
                    ClosePrice = (float)price.ClosePrice
                };

                // Calculate 10-second price difference (magnitude)
                if (i > 0)
                {
                    var prevPrice = priceList[i - 1];
                    float priceDiff = (float)(price.ClosePrice - prevPrice.ClosePrice);
                    feature.ShortTermPriceDiffMagnitude = Math.Abs(priceDiff);
                }

                // Calculate rolling average of price difference magnitude over ShortTermLookbackPeriod
                if (i >= ShortTermLookbackPeriod)
                {
                    var periodDiffs = priceList.Skip(i - ShortTermLookbackPeriod).Take(ShortTermLookbackPeriod)
                        .Zip(priceList.Skip(i - ShortTermLookbackPeriod + 1).Take(ShortTermLookbackPeriod),
                            (prev, curr) => Math.Abs((float)(curr.ClosePrice - prev.ClosePrice)));
                    feature.ShortTermPriceDiffRollingAvg = periodDiffs.Average();
                }

                // Calculate short-term volatility (standard deviation of price differences)
                if (i >= ShortTermLookbackPeriod)
                {
                    var periodDiffs = priceList.Skip(i - ShortTermLookbackPeriod).Take(ShortTermLookbackPeriod)
                        .Zip(priceList.Skip(i - ShortTermLookbackPeriod + 1).Take(ShortTermLookbackPeriod),
                            (prev, curr) => (float)(curr.ClosePrice - prev.ClosePrice));
                    feature.ShortTermVolatility = (float)periodDiffs.StandardDeviation();
                }

                // Calculate slope of price movement over ShortTermLookbackPeriod
                if (i >= ShortTermLookbackPeriod)
                {
                    var periodTimestamps = priceList.Skip(i - ShortTermLookbackPeriod).Take(ShortTermLookbackPeriod)
                        .Select(p => (double)p.Timestamp);
                    var periodPrices = priceList.Skip(i - ShortTermLookbackPeriod).Take(ShortTermLookbackPeriod)
                        .Select(p => (float)p.ClosePrice);
                    feature.ShortTermPriceSlope = (float)CalculateSlope(periodTimestamps, periodPrices);
                }

                features.Add(feature);
            }

            return features;
        }



        /// <summary>
        /// Aligns historical and short-term features by timestamp for training or prediction.
        /// </summary>
        /// <param name="historicalFeatures">Historical features from 1H candlesticks.</param>
        /// <param name="shortTermFeatures">Short-term features from 10-second updates.</param>
        /// <param name="ailogger">Logging action for alignment details.</param>
        /// <returns>Enumerable of aligned InputBreakoutSchema records.</returns>
        private IEnumerable<AIBreakoutInputSchema> AlignData(IEnumerable<AIBreakoutInputSchema> historicalFeatures, IEnumerable<AIBreakoutInputSchema> shortTermFeatures, Action<string> ailogger)
        {
           
            var historicalList = historicalFeatures.ToList();
            var shortTermList = shortTermFeatures.ToList();
            var alignedData = new List<AIBreakoutInputSchema>();

            // Assume short-term data is continuous and recent; align with the most recent historical data
            for (int i = 0; i < historicalList.Count; i++)
            {
                var historical = historicalList[i];
                var shortTermWindow = shortTermList
                    .Where(st => st.Timestamp >= historical.Timestamp && st.Timestamp < (i + 1 < historicalList.Count ? historicalList[i + 1].Timestamp : long.MaxValue))
                    .ToList();

                if (shortTermWindow.Any())
                {
                    var aligned = new AIBreakoutInputSchema
                    {
                        Timestamp = historical.Timestamp,
                        ClosePrice = historical.ClosePrice,
                        OpenPrice = historical.OpenPrice,
                        HighPrice = historical.HighPrice,
                        LowPrice = historical.LowPrice,
                        Volume = historical.Volume,
                        PriceChangePct = historical.PriceChangePct,
                        PriceRange = historical.PriceRange,
                        Sma = historical.Sma,
                        Rsi = historical.Rsi,
                        Atr = historical.Atr,
                        ShortTermPriceDiffMagnitude = shortTermWindow.Last().ShortTermPriceDiffMagnitude,
                        ShortTermPriceDiffRollingAvg = shortTermWindow.Last().ShortTermPriceDiffRollingAvg,
                        ShortTermVolatility = shortTermWindow.Last().ShortTermVolatility,
                        ShortTermPriceSlope = shortTermWindow.Last().ShortTermPriceSlope
                    };

                    // Set label based on historical breakout (look ahead)
                    if (i + 1 < historicalList.Count)
                    {
                        float nextPriceChange = (historicalList[i + 1].ClosePrice - historical.ClosePrice) / historical.ClosePrice;
                        aligned.Label = Math.Abs(nextPriceChange) >= BreakoutThreshold
                            ? (nextPriceChange > 0 ? "Bullish" : "Bearish")
                            : "NoBreakout";
                    }

                    alignedData.Add(aligned);
                }
            }

            ailogger($"AlignData: Aligned {alignedData.Count} records from {historicalList.Count} historical and {shortTermList.Count} short-term features.");
            return alignedData;
        }



        /// <summary>
        /// Calculates the Relative Strength Index (RSI) for a sequence of closing prices.
        /// </summary>
        /// <param name="prices">Sequence of closing prices.</param>
        /// <returns>RSI value (0-100).</returns>
        private double CalculateRSI(IEnumerable<double> prices)
        {
            
            var priceChanges = prices.Zip(prices.Skip(1), (prev, curr) => curr - prev).ToList();
            var gains = priceChanges.Where(x => x > 0).DefaultIfEmpty(0).Average();
            var losses = Math.Abs(priceChanges.Where(x => x < 0).DefaultIfEmpty(0).Average());

            if (losses == 0) return 100;
            var rs = gains / losses;
            return 100 - (100 / (1 + rs));
        }



        /// <summary>
        /// Calculates the Average True Range (ATR) for a sequence of prices.
        /// </summary>
        /// <param name="prices">Sequence of Price objects.</param>
        /// <returns>ATR value.</returns>
        private double CalculateATR(IEnumerable<Price> prices)
        {
            
            var trueRanges = prices.Zip(prices.Skip(1), (prev, curr) =>
            {
                double highLow = curr.HighPrice - curr.LowPrice;
                double highClose = Math.Abs(curr.HighPrice - prev.ClosePrice);
                double lowClose = Math.Abs(curr.LowPrice - prev.ClosePrice);
                return Math.Max(highLow, Math.Max(highClose, lowClose));
            }).ToList();

            return trueRanges.DefaultIfEmpty(0).Average();
        }



        /// <summary>
        /// Calculates the slope of a linear regression for timestamps and prices.
        /// </summary>
        /// <param name="timestamps">Sequence of timestamps (as doubles).</param>
        /// <param name="prices">Sequence of prices (as floats).</param>
        /// <returns>Slope of the linear regression line.</returns>
        private double CalculateSlope(IEnumerable<double> timestamps, IEnumerable<float> prices)
        {
            
            var ts = timestamps.ToList();
            var ps = prices.ToList();
            if (ts.Count != ps.Count || ts.Count < 2) return 0;

            double sumX = ts.Sum();
            double sumY = ps.Sum();
            double sumXY = ts.Zip(ps, (x, y) => x * y).Sum();
            double sumXX = ts.Sum(x => x * x);
            double n = ts.Count;

            double slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
            return slope;
        }



        /// <summary>
        /// Loads a pre-trained model from disk if it exists, otherwise initializes a new model.
        /// </summary>
        /// <param name="ailogger">Logging action for model loading status.</param>
        private void LoadModelFromDisk(Action<string> ailogger)
        {
            
            string modelPath = "Models/BreakoutPredictorModel.zip";

            if (System.IO.File.Exists(modelPath))
            {
                try
                {
                    _model = _mlContext.Model.Load(modelPath, out var schema);
                    ailogger($"Loaded BreakoutPredictor model from {modelPath}");
                }
                catch (Exception ex)
                {
                    ailogger($"Model load failed: {ex.Message}. Starting fresh!");
                    _model = null; // Reset to force retraining
                }
            }
            else
            {
                ailogger("No model found at Models/BreakoutPredictorModel.zip—starting with a new one!");
                _model = null; // Fresh start
            }
        }



        /// <summary>
        /// Saves the trained model to disk atomically to prevent corruption.
        /// </summary>
        /// <param name="ailogger">Logging action for model saving status.</param>
        private void SaveModelToDisk(Action<string> ailogger)
        {
           
            string modelPath = "Models/BreakoutPredictorModel.zip";
            string tempModelPath = modelPath + ".tmp";

            try
            {
                if (_model != null)
                {
                    _mlContext.Model.Save(_model, null, tempModelPath);
                    System.IO.File.Move(tempModelPath, modelPath, overwrite: true);
                    ailogger($"BreakoutPredictor model saved to {modelPath}");
                }
                else
                {
                    ailogger("No model to save—train it first!");
                }
                System.Threading.Thread.Sleep(1000); // Brief pause to ensure file operations settle
            }
            catch (Exception ex)
            {
                ailogger($"Save failed: {ex.Message}. Keeping the model in memory!");
                if (System.IO.File.Exists(tempModelPath))
                    System.IO.File.Delete(tempModelPath); // Clean up temp file on failure
            }
        }
    }



    /// <summary>
    /// BreakoutPredictor class that uses a Transformer model to predict market breakout trends (bullish, bearish, or no breakout)
    /// based on historical and short-term (10-second) price data.
    /// </summary>
    public partial class AIBreakoutPredictor
    {


        
        /// <summary>
        /// Tests the BreakoutPredictor by training it on historical and short-term price data, then predicting
        /// breakout trends for the current market, evaluating performance metrics like accuracy, win rate, and confidence.
        /// </summary>
        /// <param name="historicalPrices">List of historical Price objects (e.g., 1-hour candlesticks) for training and testing.</param>
        /// <param name="shortTermPrices">List of short-term Price objects (e.g., 10-second updates) for real-time analysis.</param>
        /// <param name="ailogger">Logging action for test progress, results, and errors. Defaults to Console.WriteLine if null.</param>
        /// <param name="windowSize">Number of historical candlesticks to use for each prediction (default: 50, matching HistoricalLookbackPeriod).</param>
        /// <param name="testEpisodes">Number of prediction episodes to simulate (default: 100).</param>
        /// <param name="trainingRatio">Ratio of data to use for training (0-1, default: 0.7 or 70%).</param>
        /// <returns>Tuple containing overall accuracy, win rate, and average confidence for predictions.</returns>
        public (float Accuracy, float WinRate, float AverageConfidence) TestBreakoutPrediction(List<Price> historicalPrices,
                                                                                               List<Price> shortTermPrices,
                                                                                               Action<string> ailogger = null,
                                                                                               int windowSize = 50,
                                                                                               int testEpisodes = 100,
                                                                                               float trainingRatio = 0.7f)
        {
            
            // Default logger to Console.WriteLine if none provided
            ailogger = ailogger ?? (s => Console.WriteLine(s));

            // Validate input data
            if (historicalPrices == null || historicalPrices.Count < windowSize + 1)
            {
                ailogger($"TestBreakoutPrediction: Error - Insufficient historical price data: {historicalPrices?.Count ?? 0} prices, need at least {windowSize + 1}");
                return (0f, 0f, 0f);
            }

            if (shortTermPrices == null || shortTermPrices.Count == 0)
            {
                ailogger("TestBreakoutPrediction: Error - No short-term price data provided.");
                return (0f, 0f, 0f);
            }

            // Calculate the number of data points for training and testing
            int trainingCount = (int)(historicalPrices.Count * trainingRatio);
            if (trainingCount < windowSize || trainingCount >= historicalPrices.Count)
            {
                ailogger($"TestBreakoutPrediction: Error - Invalid training split: need between {windowSize} and {historicalPrices.Count - 1} prices for training");
                return (0f, 0f, 0f);
            }

            // Split data into training and testing sets
            var trainingHistoricalPrices = historicalPrices.Take(trainingCount).ToList();
            var testingHistoricalPrices = historicalPrices.Skip(trainingCount).ToList();
            int maxEpisodes = Math.Min(testEpisodes, testingHistoricalPrices.Count - windowSize);

            if (maxEpisodes <= 0)
            {
                ailogger("TestBreakoutPrediction: Error - Not enough testing data for specified episodes and window size.");
                return (0f, 0f, 0f);
            }

            ailogger($"TestBreakoutPrediction: Starting test with {maxEpisodes} episodes, {trainingRatio * 100:F1}% training data, window size={windowSize}");

            // Train the model with training data
            try
            {
                Train(trainingHistoricalPrices, shortTermPrices.Take(trainingCount * 6).ToList(), ailogger); // Assuming 10s updates, 360 per hour, 6 per 1H candle
                ailogger("TestBreakoutPrediction: Model trained successfully.");
            }
            catch (Exception ex)
            {
                ailogger($"TestBreakoutPrediction: Training failed - {ex.Message}");
                return (0f, 0f, 0f);
            }

            // Initialize metrics
            int correctPredictions = 0;
            int totalPredictions = 0;
            int bullishWins = 0, bearishWins = 0, totalBullish = 0, totalBearish = 0;
            float totalConfidence = 0f;
            const float confidenceThreshold = 0.65f; // Minimum confidence for a prediction to be considered valid

            // Simulate predictions for testing episodes
            for (int i = 0; i < maxEpisodes; i++)
            {
                // Get a window of historical data for prediction
                var predictionWindow = testingHistoricalPrices.Skip(i).Take(windowSize).ToList();
                var currentShortTermWindow = shortTermPrices
                    .Skip(i * (windowSize * 6)) // Assuming 6 short-term updates per 1H candle (10s * 6 = 60s)
                    .Take(windowSize * 6) // Match the number of short-term updates to historical window
                    .ToList();

                // Predict the next breakout trend
                AIBreakoutOutputSchema prediction;
                try
                {
                    prediction = Predict(predictionWindow, currentShortTermWindow, ailogger);
                }
                catch (Exception ex)
                {
                    ailogger($"TestBreakoutPrediction: Prediction failed for episode {i + 1} - {ex.Message}");
                    continue;
                }

                // Determine the actual outcome (look ahead one step in historical data)
                string actualLabel = "NoBreakout";
                if (i + windowSize < testingHistoricalPrices.Count)
                {
                    float nextPriceChange = (float)((testingHistoricalPrices[i + windowSize].ClosePrice - testingHistoricalPrices[i + windowSize - 1].ClosePrice) /
                                           (testingHistoricalPrices[i + windowSize - 1].ClosePrice));
                    actualLabel = Math.Abs(nextPriceChange) >= BreakoutThreshold
                        ? (nextPriceChange > 0 ? "Bullish" : "Bearish")
                        : "NoBreakout";
                }

                // Calculate confidence (highest probability among classes)
                float confidence = prediction.Probabilities.Max();
                totalConfidence += confidence;

                // Log prediction details
                ailogger($"TestBreakoutPrediction Episode {i + 1}: Predicted={prediction.PredictedLabel}, Actual={actualLabel}, " +
                         $"Confidence={confidence:F2}, Probabilities=[{string.Join(", ", prediction.Probabilities.Select(p => p.ToString("F2")))}]");

                // Evaluate if prediction is valid (above confidence threshold) and correct
                if (confidence >= confidenceThreshold)
                {
                    totalPredictions++;
                    if (prediction.PredictedLabel == actualLabel)
                    {
                        correctPredictions++;
                        if (prediction.PredictedLabel == "Bullish") bullishWins++;
                        if (prediction.PredictedLabel == "Bearish") bearishWins++;
                    }

                    // Track totals for win rate calculation
                    if (prediction.PredictedLabel == "Bullish") totalBullish++;
                    if (prediction.PredictedLabel == "Bearish") totalBearish++;
                }
            }

            // Calculate performance metrics
            float accuracy = totalPredictions > 0 ? (float)correctPredictions / totalPredictions * 100 : 0f;
            float winRate = (totalBullish + totalBearish) > 0
                ? ((float)(bullishWins + bearishWins) / (totalBullish + totalBearish)) * 100
                : 0f;
            float averageConfidence = totalPredictions > 0 ? totalConfidence / totalPredictions : 0f;

            // Log final results
            ailogger($"TestBreakoutPrediction Complete: Accuracy={accuracy:F2}%, Win Rate={winRate:F2}%, " +
                     $"Average Confidence={averageConfidence:F2}, Total Predictions={totalPredictions}, Correct={correctPredictions}");
            ailogger($"Breakdown: Bullish Predictions={totalBullish}, Bullish Wins={bullishWins}, " +
                     $"Bearish Predictions={totalBearish}, Bearish Wins={bearishWins}");

            return (accuracy, winRate, averageConfidence);
        }
    }
}

The Output Schema: AIBreakoutOutputSchema.cs

namespace AdvancedCryptoTrader.AI
{



    #region Using Statements:



    using Microsoft.ML.Data;



    #endregion



    /// <summary>
    /// Represents the output schema for breakout prediction, including the predicted label and confidence scores.
    /// </summary>
    public class AIBreakoutOutputSchema
    {
        /// <summary>
        /// The predicted breakout label ("Bullish", "Bearish", or "NoBreakout").
        /// </summary>
        [ColumnName("PredictedLabel")]
        public string PredictedLabel { get; set; }

        /// <summary>
        /// Probability scores for each possible breakout class (Bullish, Bearish, NoBreakout).
        /// </summary>
        [ColumnName("Score")]
        public float[] Probabilities { get; set; }

        /// <summary>
        /// Confidence score for the predicted label (highest probability among classes).
        /// </summary>
        public float Confidence { get; internal set; }
    }
}

More coming soon...

Best Wishes,

Chris

Femm 4.2

2024-01-23T23:46:26.2930000

How to learn Femm 4.2 as a newbe download manual also any other files to learn.

Start a new file by pressing the white block or new from file menu

any line or circle must begin and end with the square dot. reading the manual helps a lot!

the Basics: page 16

Right click the mouse used to select item sq dots, lines, cicle or radius, or labels

Spacebar: to edit item

Tab: to enter location for dots or use grid and press snap-to to ON

a few days and it will be easy! I'm still by no means a good user yet.

How to Download BLOB or m3u8 Embedded Video

2023-11-30T02:41:25.9330000

My Friends,

I have partially covered some of this before, downloading Blog or Embedded Video or media Content, within webpages.

How to Download blob files

Its very easy, just follow these steps:

Download 'ffmpeg.exe' from here: https://ffmpeg.org/download.html
Save and extract the bin/ to a Folder on the desktop, see below Image.
Create a Batch File and save the Code below into your batch file and run it.

Folder Structure

Your Folder Structure should look like this:

To create the batch file: Goto Start, Run, type in notepad.exe and paste the following code in:

CD \

CD "C:\Users\<User Folder>\Desktop\Blob Downloader\"

SET M8Path="https://...."

SET OutputPath="C:\Users\<User Folder>\Desktop\Blob Downloader\Downloaded Video.mp4"

ffmpeg.exe -i %M8Path% -bsf:a aac_adtstoasc -vcodec copy -c copy -crf 50 %OutputPath%

pause

Replace "<User Folder>" and "https://...." with your specific data.

How to get the Uri

On your keyboard, press the F12 key and open the Dev Tools dialog. Your browser will likely look different, I am using Chrome ATM, you will get a window similar to this:

At the top, select "network" as is shown.

Type in the filter text box: m3u8.

NOTE: m3u8, or m3u files are different and this media format can change, and have different names so be aware of this.

Ensure the record button is on! Its Red when on! Then and refresh the page! Sometimes you may need to play the video?

Be ready to click the Record button, because you don't want hundreds of items to sort through, by clicking the Record Button again, it will turn grey and stop recording I have highlighted in a red box:

Now, sort through the items found, copy the Uri and Paste it into the Batch File where it says M8Path:

Sometimes the correct Uri is not the first file, it may be second or third, but normally close to the top! Repeat this step until you find the item that you get the one with Video and Audio Data, by testing the video file that you get by running the bat file:

Above you can see, I am copying the Uri of the third item down, I select the "Request URL" and Copy it. That's what goes into the "M8Path" field.

After you have entered the details required, save the Batch File making sure you have selected "All Files" with extension .bat:

To run the Batch File, just double click on the Run Me, that will run the Code above you pasted in and saved:

Then, when you're done, you will have a Video, with Audio and Video called: "Downloaded Video.mp4" like this:

Enjoy My Friends, this is a real conundrum for a lot of people, and may thought their videos were safe online, safe from us and we could not download them, but here you can see how easy it is to download these videos!

Best Wishes,

Chris

Open AI's Whisper - Speech to Text AI

2022-10-19T21:34:08.5430000

My Friends,

This is just amazing! OpenAI has released software that makes Googles, subscription, Speech to Text Service, obsolete!

Whisper is a Python based AI, Transformer Model, that can take any source, Audio Text, Singing, almost anything, and it converts it to Text:

https://youtu.be/HbY51mVKrcE

https://www.youtube.com/watch?v=Ph6K_0ttsSc

https://www.youtube.com/watch?v=AwJf8aQfChE

This is the best, most powerful software I have ever seen! The old fashioned Mouse and Keyboard may become obsolete sooner rather than later!

If one wants to use C# to run this, there are some options:

From Python:

import whisper

model = whisper.load_model("base")
result = model.transcribe("audio.mp3")
print(result["text"])

In C#:

Run("Path/To/Python.3.9.9.exe", "PythonScript.py");




        /// <summary>
        /// Run an Executable.
        /// </summary>
        /// <param name="filename"></param>
        /// <param name="arguments"></param>
        /// <returns></returns>
        public static string Run(string filename, string arguments = null)
        {

            // The stdError Output:
            string stdError = null;

            // Th stdOutput:
            var stdOutput = new StringBuilder();

            // Check Args:
            if (arguments == null)
            {
                arguments = "";
            }

            // Init a new Process:
            Process process = new Process
            {
                StartInfo =
                {
                    FileName = filename,
                    Arguments = arguments,
                    CreateNoWindow = true,
                    WindowStyle = ProcessWindowStyle.Hidden,
                    UseShellExecute = false,
                    RedirectStandardError = true,
                    RedirectStandardOutput = true
                }
            };

            // OutputDataReceived:
            process.OutputDataReceived += (sender, args) => stdOutput.AppendLine(args.Data);

            // ErrorDataReceived:
            process.ErrorDataReceived += (sender, args) => { stdError += args.Data; };

            try
            {
                // Start the Process:
                process.Start();

                // Asynchronous Reading of the Output Data:
                process.BeginOutputReadLine();
                process.BeginErrorReadLine();

                // Wait for the Process to Exit:
                process.WaitForExit();
            }
            catch (Exception e)
            {

                throw new Exception("Error: " + e.Message, e);
            }

            // Check Exit Code:
            if (process.ExitCode == 0)
            {
                // Return Output Data:
                return stdOutput.ToString().Replace("\r\n", "").Trim();
            }
            else
            {

                throw new Exception("Perhaps a corrupt Input File?\r\n\r\n" + filename + ". Exit code = " + process.ExitCode + ": " + stdError.Replace("\r\n", "").Trim());
            }
        }

Or if you want to, you can use IronPython.

Best Wishes

Chris