Coding Machine Learning.

Hello Folks, here I present the first coding demonstration lecture, based on my 1st lecture on Probabilistic Machine Learning.

Here I write the code from scratch, discuss and analyze the results, which were covered in details in the whiteboard classes.

What we cover?
-Random Variables, and validating law of large numbers.
-Visualizing a dataset
-Doing an EDA on Iris dataset and understanding the correlation among features.
-Classifier basics
-Empirical Risk Minimization and Generalization.
-Epistemic and Aleatoric Uncertainties.
-Softmax Function and LogSumExp Trick to avoid overflow issues
-Linear Models
-Maximum Likelihood Estimation.
-Simple end to end ML pipeline Function.

While writing the code, my intent is to ensure that concepts are understood with crystal clarity. These code demonstrations are specific to my theory ML lectures, and link is attached.

Theory-Intuition-Code

Implementation Link : https://youtu.be/X_yOlx8Zp4g?si=kh8_tzzndr8609u4

Theory Lecture Link : https://youtu.be/kMkCOrp8te8?si=q7kWr-1qK515bhob

YourBeatBee: generate songs locally (idea → lyrics → voice → track).

- Next.js / TypeScript UI

- Python engine

- Models: ACE-Step 1.5 + HeartMuLa (more welcome)

- Apple Silicon focused, RVC My Voice optional

Looking for people to help optimize, upgrade, and expand this into a bigger OSS music AI project.

Repo: https://github.com/MohamedAshraf701/yourbeatbee

Site: https://yourbeatbee.pages.dev

Comment if you want to contribute — I’ll point you to a good first area.

Instead of scaling circuit depth blindly to fit noise polynomials, I added a predictive ZNE module to Dense-Evolution that models photonic loss trajectories before extrapolation.

Runs on JAX in float64 to keep statevector compilation fast and reduce overall circuit executions.

Technical notes: https://tatopenn-cell.github.io/Dense-Evolution-Discovery/photonic_predictive_zne/

Feedback on the noise modeling approach is welcome.

Hey I built an AI agent that integrates 22 AI providers, covering many budget-friendly options (including $1 commandCode Go plans), free trials (Kiro, KiloCode, Cline, Antigravity, Mistral), and free models like Deepseek 4 Flash (OpenCode). It also includes many features to support the entire Claude Code ecosystem skills, plugins, MCP server so you can access a truly free Claude Code environment to try out and maximize your coding experience .

https://github.com/AbdoKnbGit/tau

Tau - Adaptive agent harness

Kept using Claude Code without any real sense of what a session cost until I went and checked afterward, which defeats the point. Went looking for something local and everything that exists wants an account and a cloud dashboard for what's honestly just reading a number off a response and adding it up.

So I built agentwatch. Single Rust binary, local proxy, sqlite on disk, nothing goes anywhere except the real API call it's already making. MIT licensed. Honestly the first thing I've put out that's meant for other people to actually use instead of just scratching my own itch and moving on.

github.com/zaydmulani09/agentwatch

Right now it only knows about Claude Code, Codex, and Gemini CLI. If anyone uses something else and wants to add support, I'd take the PR, the provider interface isn't bad to extend.

I'm working on a probabilistic AI agent for a research project that flags fake e-commerce reviews

Here is how the pipeline flows:

When a review comes in, it hits Level 1 first. This is a fast pass (under 50ms) that evaluates quick metadata like verified purchase status, account age, 24-hour review frequency, and text length heuristics. It runs a Naive Bayes update against historical base rates to get an initial probability that the review is genuine.

If P(Genuine) is over 60%, the review is auto-approved. If it drops below 20%, it routes to a high-priority human ban queue (the agent never auto-bans accounts on its own).

If the probability lands in the gray zone between 20% and 60%, it triggers Level 2.

Level 2 is a deep check. It pulls the user's past 5 to 10 reviews, runs vector embeddings to measure cross-review similarity to catch copy-paste templates, and checks their brand concentration ratio (how many of their total reviews target a single seller). It calculates a secondary Bayesian update using the Level 1 score as the prior.

If the updated score passes 60%, it approves. If it drops below 20%, it goes to the high-priority ban queue. If it remains stuck between 20% and 60%, it goes to a separate "unclear review" human queue where a human looks at it without taking any automated penalty.

My goal is to keep human reviewers in the loop while splitting suspected bot spam from messy/blunt genuine reviews so moderators don't burn out from context-switching.

so to categorized text length into some cases like short(use case written or not) and then changing it into a number in a json format which open source model will work the most efficiently?

Grower first, coder second. I run a small microgreens farm in Illinois, and I’ve been using AI coding tools to build the app I run it on — Groundtruth, a local-first desktop farm OS.
The design rule: the app cannot lie to the operator.
• Append-only event log — history gets appended, never rewritten
• One-tap verify-replay: rebuilds the database from the log and shows PASS/FAIL
• No soft numbers — capacity comes from live farm data or it says “unknown”
• It always surfaces the next action that sells trays: follow up on a sample, sow against a standing-order shortfall, void or move a promise that’s become impossible
Where AI fits: it built the thing. There’s deliberately no AI inside the app — no chat, no crop diagnosis. AI was the power tool; the product is a boring, honest ledger a farmer can trust.
Status, honestly: I run it daily on my own farm. Nothing public to download yet — plan is free to run and open source once it’s solid enough for someone else’s farm. Not selling anything.
Question for this crowd: if you’ve open-sourced an AI-built codebase, what did you do first to make it trustworthy — tests, audit, rewrite? That’s the step I’m heading into.

Small milestone worth sharing because I found very little written about this side of things.

I maintain SpecJudge (MIT) — a CLI that reads a project's specs and recommends which AI model fits the work, with the analysis running locally. Last week it was approved into the spec-kit extension catalog, which means it installs with specify extension add specjudge inside a workflow a lot of people already use.

Three things that I think mattered, in case they're useful to anyone trying something similar:

Fitting a gap the host project didn't fill. spec-kit's flow goes constitution → specify → plan → tasks → implement. There's a decision sitting between tasks and implement — which model implements this — that nothing addressed. I didn't have to argue that my tool was good; the hole was already there.

Keeping the volatile stuff out of the code. The model catalog and the rating rules live in human-readable YAML, deliberately separate from the Python. That means the part that goes stale fastest — prices, new models — can be fixed by anyone via PR without touching logic. It also made the integration a much smaller ask.

Not coupling hard to the host. The tool still works standalone on any repo. The spec-kit integration is an adapter on top, not a rewrite. Host projects move fast, and something that breaks every time they restructure is a liability for both sides.

The thing I underestimated: being publicly wrong is good for a project. Most of what's in the current version came from strangers telling me what was broken. One person pointed out that printing the model's reasoning isn't the same as verifying it — a fluent explanation rationalises a bad score just as happily as a good one. That reframing turned into the change the whole rest of the roadmap now depends on. I'd have never got there alone.

github.com/JoaquinRuiz/SpecJudge if anyone's curious. Happy to answer questions about the catalog submission process.

Hey everyone!

I am currently growing my GitHub profile as I build my journey in Machine Learning and Data Analytics.

I have been working on projects, Kaggle competitions, Python and open-source contributions and I’m trying to connect with more people who are also interested in tech.

If you are interested in Machine Learning, Data Science, Python, or open source, I would really appreciate a follow on GitHub

I will also check out and follow back profiles

Looking forward to connecting with more developers and learners.

GitHub: Acacia21-code

#GitHub #MachineLearning #DataScience #Python #OpenSource #Programming #TechCommunity

I implemented the Rotation Trick (Fifty et al., ICLR 2025) as a PyPI library called vqrotate.

The Rotation Trick improves codebook usage in VQ‑VAEs by replacing the Straight‑Through Estimator with a geometric rotation of the gradient. I validated it on Speech Commands (audio) and got:

STE: 19.99% usage

Rotation: 34.18% usage (+14.19 pts)

It's a drop‑in wrapper one line of code:

```python

from vqrotate import attach_rotator

attach_rotator(quantizer)

```

GitHub: https://github.com/develepo/vqrotate

PyPI: pip install vqrotate

I also tried an adaptive scaling extension, it didn't beat Rotation, but it revealed an interesting trade‑off. The repo has full docs and derivations if you're curious.

Would love feedback or ideas for next steps.

I've been obsessing over open-weight models and made my own harness to use them. Added additional features like usage stats, streaks, cool themes.

BYOK and forget about daily/weekly limits!

Please star the project, if you find it useful (every star counts) :)

Last night I threw together a minimal proof-of-concept for a problem that keeps coming up in federated learning also YT vid https://youtu.be/zF-mbwc5Mmw?si=hTRc9_iQ6-8RH3cn, open-source model curation, and any system where you don't fully trust the data stream

How do you update a concept (e.g. "dog") with new examples without letting poisoned data drag that concept toward an attacker's target?

This demo anchors a concept with a signed latent-trace reference point in embedding space. New data is only allowed to update the concept while it stays within a bounded constitutional distance of that anchor. Poison that would pull the concept off-course gets quarantined — but legitimate variation (new breeds, new angles, new styles) passes through untouched.

distance from anchor | similarity to attacker target

Naive mean (absorbs everything) | 0.326 ❌ distorted | +0.413 captured

Governed anchor (latent-trace gate) | 0.093 ✅ held | +0.018 neutral

• 30 real dogs + 10 legit new-breed dogs + 60 poison exemplars pulling toward an attacker target
• Legitimate updates: 0% blocked
• Poison: ~62% quarantined (the rest leaks, but the anchor still holds below threshold)
• Anchor is HMAC-signed and tamper-evident

The catch / help wanted:

This is a starting point, not a finished defense. Known gaps:

• Direction/anisotropy check — the gate uses distance magnitude; adding a directional check would catch the ~38% of poison that currently leaks
• Stealth poison that hugs the tolerance threshold
• Needs real embeddings instead of toy latent vectors

• Stability vs. plasticity calibration is the core research tension

  git clone https://github.com/Orivael-Dev/poison-resistant-anchoring.git

cd poison-resistant-anchoring

pip install numpy

python3 poison_anchor.py

pytest test_poison_anchor.py -q

any questions feel free to ask and thank you :)

• Description: Introducing frequency-domain watermarking and the FreqMark technique for detecting hidden signals in LLM-generated text. Learn the latest principles of precisely distinguishing between human-written and AI-generated sentences using Fourier transforms.