Coder Legion - Recent posts tagged machine

List Of Machine Learning (ML) Models

Fri, 16 Oct 2026 12:38:00 +0000

Found this list while training it into my new personal LLM, its a list of machine learning (ML) models, with descriptions and settings. They are fairly easy to use if you are comfortable on the command line, but it's technical enough that it won't sound familiar to most people, so its good reading. If you want the full info, copy below this line into your favorite AI and say "Take this list of ML models, research them and give me a description and use case for each." or tell it what you need to do and ask which one of these will do that. Learning just the 4 types and understanding that you chain multiple ones together with / without an LLM in the process. Warning too, frontier models will not write good training data for these just like all training data, will either flag you or just write generic bad data on purpose, so never ask it to make you training data unless its open source (deepseek, qwen etc).

Ok so main purpose first, 4 categories:

CLASSIFIERS - Take input, predict a category label (a string).
Example: input = "I want to cancel my account", output = "cancellation"

Requires labeled training data: each training row has input + a string label.

Specific Models: KNN (K-Nearest Neighbors), NAIVE BAYES (Gaussian Naive Bayes), DNN (Deep Neural Network / MultilayerPerceptron), RANDOM FOREST, TREE (Classification Tree), ADABOOST (Adaptive Boosting), LOGISTIC REGRESSION

REGRESSORS - Take input, predict a number (a float).
Example: input = [sqft, bedrooms, age], output = 350000.00

Requires labeled training data: each training row has input + a numeric label.

Specific Models: RIDGE (Ridge Regression), KNN REGRESSOR, SVR (Support Vector Regression), MLP REGRESSOR (Neural Network Regressor), GRADIENT BOOST

CLUSTERERS - Take input, assign it to a group (integer cluster ID).
Example: input = [age, income, spend], output = 2 (meaning cluster 2)

No labels needed. The algorithm discovers groups on its own.

Specific Models: KMEANS, DBSCAN, FUZZY C-MEANS

ANOMALY DETECTORS - Take input, flag it as normal (0) or anomaly (1).
Example: input = [transaction_amount, time, location], output = 1 (anomaly)

Train on normal/clean data only. Anything that looks different gets flagged.

Specific Models: ISOLATION FOREST, LOCAL OUTLIER FACTOR, ROBUST Z-SCORE

Machine Vs Machine - The Future of Defence

Thu, 05 Feb 2026 19:13:34 +0000

This Is No Longer a Human Battlefield

Critical infrastructure is no longer under threat from lone hackers, criminal groups, or even nation‑state teams operating at human speed. What we are witnessing now is something fundamentally different.

Adversarial AI is actively targeting the systems that power civilization itself—electric grids, factories, water treatment plants, pipelines, rail networks, and transportation control systems. These attacks are not slow, manual, or linear. They are automated, adaptive, and relentless.

The uncomfortable truth is this: humans are now the slowest component in the defense loop.

Speed Decides Everything in OT

In IT security, seconds or minutes may be acceptable. In Operational Technology (OT) and Industrial Control Systems (ICS), milliseconds decide whether a process stabilizes or catastrophically fails.

A voltage spike on a grid, a pressure anomaly in a pipeline, a timing deviation in a manufacturing line—these events evolve faster than any SOC analyst, incident commander, or on‑call engineer can meaningfully respond.

Adversarial AI understands this.

Modern attacks are increasingly designed to:

Exploit control‑loop timing
Manipulate sensor feedback
Induce oscillations rather than outright failures
Create cascading physical effects that appear “operational,” not cyber

By the time a human notices, the damage is already unfolding.

Why Human‑Centric Defense Is Failing

Most OT cybersecurity strategies still assume:

Alerts will be reviewed by humans
Analysts will correlate logs
Engineers will intervene manually

This model is collapsing.

Adversarial AI does not wait for change management windows. It does not respect shift rotations. It does not suffer fatigue, cognitive overload, or alert blindness.

Meanwhile, OT environments suffer from:

Sparse or delayed telemetry
Legacy PLCs with no native security logging
Safety systems that react too late to cyber‑induced anomalies
Operators trained for mechanical failure, not algorithmic deception

The result is a widening speed gap—and adversarial AI is winning it.

The Emergence of Machine vs. Machine Warfare

The future of OT and ICS cybersecurity is not human versus attacker.

It is machine versus machine.

Defense systems must operate at the same temporal scale as the attack. That means:

Autonomous detection of control‑logic manipulation
Real‑time behavioral baselining of physical processes
Automated response actions executed inside the control loop
Continuous adaptation without human approval delays

This is not about replacing engineers. It is about allowing humans to set intent and boundaries—while machines fight the battle at machine speed.

What Machine Intelligence Defense Looks Like

A true machine‑driven OT defense system does not rely on logs or static signatures. It understands physics, process, and intent.

Key characteristics include:

1. Process‑Aware Intelligence

The system understands what should be happening physically—not just what packets look like.

A command may be valid syntactically, yet dangerous contextually. Machine intelligence must detect when actions violate safe operational envelopes.

2. Continuous Learning Without Drift

Defensive AI must learn normal behavior without normalizing slow‑burn attacks or attacker‑induced degradation. This requires constrained learning tied to engineering truth, not pure statistics.

3. Autonomous Response Authority

When milliseconds matter, the system must be allowed to:

Block malicious commands
Isolate compromised controllers
Revert logic to known‑safe states
Throttle or pause processes before safety systems trip

Human approval comes after stabilization, not before.

4. Conflict Resolution Between Machines

As OT environments deploy optimization AI, safety AI, and security AI, defense systems must detect and resolve conflicts between autonomous agents before they escalate into physical risk.

Protecting the Infrastructure That Powers Civilization

Power grids are no longer just energy systems—they are computational ecosystems.
Factories are no longer mechanical—they are algorithmic.
Water systems are no longer passive—they are automated decision engines.

Every one of these systems is now a target.

And every one of them must be capable of defending itself.

The New Role of Humans

Humans are not obsolete—but their role must change.

Humans should:

Define safety boundaries and response policies
Train and validate machine defenders
Investigate incidents after containment
Govern autonomy and accountability

Humans should not be expected to out‑react adversarial AI in real time.

That era is over.

This Is How the Future Fights Back

The next phase of OT and ICS cybersecurity will not be won with more dashboards, more alerts, or more analysts.

It will be won by:

Machine intelligence defending machine‑driven infrastructure—at machine speed.

This is no longer a human battlefield.

This is how the future fights back.

State Management Made Easy with Fluxor in Blazor

Fri, 25 Apr 2025 12:59:35 +0000

Exploring Actions, Effects, and the Benefits of Fluxor

Modern web applications are becoming increasingly complex, and with complexity comes the need for structured state management. In the world of Blazor a popular .NET-based web UI framework .

Fluxor offers a powerful yet easy-to-understand state container that brings predictable state flow to your applications.

Fluxor is a zero-boilerplate Flux/Redux library for Microsoft .NET.

It brings the same clean architecture and unidirectional data flow popularized by Redux in the JavaScript ecosystem—adapted for C# developers building with Blazor.

We’ll break down the core concepts of Fluxor and show how you can use Actions, Reducers, and Effects to create a clean, maintainable architecture.

Explore the GitHub project

️ What is Fluxor?

Fluxor provides a structured and predictable way to manage state in your Blazor application. Inspired by Redux, it embraces:

Unidirectional data flow — State changes follow a clear path: Action ➝ Reducer ➝ State ➝ UI.

Single source of truth — All application state lives in a centralized, immutable store.

Middleware & Effects — Separate side-effects like API calls from your UI and business logic.

Unlike some Redux implementations, Fluxor handles a lot of the boilerplate for you with C#-friendly conventions and strong typing.

Actions – Declaring Intent

In both Redux and Fluxor, Actions are plain messages that describe what happened. They're just
signals , they don’t contain logic.

Example:

public record FetchItemsAction;
public record FetchItemsSuccessAction(List<Item> Items);
public record FetchItemsFailedAction(string ErrorMessage);

⚙️ Effects – Handling Side Effects

Since Reducers must be pure, Effects in Fluxor allow you to perform async operations like API calls without cluttering your UI.

Example:

public class ItemEffects
{
    [EffectMethod]
    public async Task HandleFetchItems(FetchItemsAction action, IDispatcher dispatcher)
    {
        try
        {
            var items = await itemService.GetItemsAsync();
            dispatcher.Dispatch(new FetchItemsSuccessAction(items));
        }
        catch (Exception ex)
        {
            dispatcher.Dispatch(new FetchItemsFailedAction(ex.Message));
        }
    }
}

This Effect reacts to FetchItemsAction and handles fetching data from an external service.

State and Reducers – Updating the Store

Reducers are responsible for updating state in response to actions. They are pure functions and return a new state based on the action received.

public static class ItemReducers
{
    [ReducerMethod]
    public static ItemState OnFetchSuccess(ItemState state, FetchItemsSuccessAction action) =>
        state with { Items = action.Items, IsLoading = false };

    [ReducerMethod]
    public static ItemState OnFetchFailed(ItemState state, FetchItemsFailedAction action) =>
        state with { ErrorMessage = action.ErrorMessage, IsLoading = false };
}

Reducers never mutate state—they return a new state object.

Try It Yourself

Check out the working example project to see all these concepts in action:
https://github.com/stevsharp/BlazorAndFluxorStateMachine

It demonstrates:

Dispatching Actions from UI
Handling async logic with Effects
Clean Reducer logic
Blazor component integration

✅ Why Use Fluxor?

No boilerplate overload – clean C# syntax
Clear, testable state transitions
Great for scaling large Blazor apps
Familiar to those who’ve used Redux in React or Angular
Keeps business logic and UI concerns separate

References

Fluxor GitHub Repository

Redux Official Site

Angular Redux

Blazor Documentation – Microsoft

BlazorAndFluxorStateMachine – GitHub Sample

List item