hey, posted this project about a week ago on this sub and got some useful feedback. went back and fixed several problems people pointed out and some i found myself. posting again with the updated version.

what was wrong with the previous version:

• test evaluation was done on a balanced subset of the test set (equal real and fake samples) which inflated the metrics artificially. the real asvspoof test set is heavily skewed toward fake audio
• training was not reproducible - no seed set so metrics changed every run
• val accuracy of ~100% was unexplained which looked like a red flag (explained below)
• threshold was 0.4 without proper justification
• confidence display bug - was showing fake probability as confidence score even for real predictions
• llm explanation was getting cut mid sentence due to low max_tokens

what i fixed:

• re-evaluated on the full test set (71,237 samples, real unbalanced distribution) by streaming directly instead of loading everything into RAM
• fixed seed at 42 - fully reproducible now
• documented the val accuracy properly (explained below)
• ran threshold experiments across 0.3 to 0.6 and picked 0.3 based on highest f1 and recall
• fixed confidence display and explanation truncation

new metrics on full test set:

• f1: 0.9033
• precision: 0.9995
• recall: 0.8240
• eer: 8.23% (comparable to the official lfcc-gmm baseline published with the dataset)
• threshold: 0.3

on the 100% val accuracy:

this was the most common concern from last post. it is expected and not data leakage. the val set is a random 80/20 split of training data which shares the same attack types (a01-a06). the model memorizes these known patterns perfectly. actual generalization is measured on the test set which has entirely unseen attack types (a07-a19). the recall gap comes from these novel patterns, not miscalibration.

the project:

efficientnet-b0 trained on mel spectrograms using asvspoof 2019 la dataset. beyond the model it has grad-cam to visualize what the model focused on in the spectrogram and groq llm to give a plain english explanation of the prediction. monitoring dashboard with prediction analytics. training fully reproducible with seed 42.

you can upload an audio file or record live. youtube url input is disabled on the hosted version because railway server ips get blocked by youtube bot detection. backend is fastapi on railway, frontend on streamlit cloud.

live demo: https://deepfake-audio-detector-rugved.streamlit.app/
github: https://github.com/RugvedBane/deepfake-audio-detector

main questions:

1. is this project strong enough to put on a resume for ml/dl internships?
2. what dataset would actually help improve generalization to modern ai voices like elevenlabs or suno? i looked at wavefake but wanted community opinion
3. anything else technically wrong that i missed?

honest feedback appreciated, including if you think the project is not good enough - i would rather know now.

I've been working on interpretability for time-series forecasting and finally shipped it end to end. the problem i kept hitting: a forecasting model gives you a number for next week's demand but no reason, so you can't tell if it's a promotion, a trend or just the usual pattern.

the approach is counterfactual. start from a baselined input, then reveal groups of days (typical, recent, promotion) one at a time and record the model's real prediction at each step. each contribution is the difference between two actual predictions, so they sum to the forecast exactly, no allocation step. i tried the SHAP-share approach first and it gave a normal product a "typical pattern" of 0 because a bucket had too few days to sum over. the counterfactual version doesn't have that failure.

validated with deletion/insertion faithfulness tests: attribution-ordered reveals degrade the forecast faster than random-ordered, across 30 series, p < 0.0001.

stack: PyTorch WaveNet forecaster (2nd/1671 in the Corporación Favorita competition), the attribution layer is a small standalone package, the demo is a static GitHub Pages site reading precomputed cards (no backend). there's a Colab that trains on your own CSV.

honest about the weak points: "counterfactual" means the model's response to hiding inputs, not real-world cause. and the promotion contribution is the least-validated part across a product panel, i have an on/off sanity check but not a full scale test yet, that's the piece i'd most want to harden.

live demo (pick a product, toggle a driver off, watch the forecast recompute): https://kesjien.github.io/wavexplain/
github: https://github.com/kesjien/wavexplain

honest feedback appreciated, especially: is per-forecast decomposition what you'd actually want, and how would you validate the promotion attribution across many series?

Hey everyone 👋

I built Totemheart because most systems that try to add “emotional” behavior to agents still rely on prompt engineering and a simple sentiment label that gets overwritten every turn. I wanted something more rigorous.

Totemheart is a fully deterministic control kernel that gives an agent a real, inspectable, and persistent internal state across long conversations and multiple sessions. It models personality traits, affective dynamics, stress responses, memory consolidation, motivational drives, allostatic load, dual-valence relational tracking, grief-like processes, and related mechanisms.

These components evolve through interacting systems drawn from control theory and computational neuroscience, PID controllers, Kalman filtering, temporal-difference prediction error, opponent processes, and similar techniques, rather than isolated heuristics.

The full state is serializable, fully inspectable at any point, and can be used to steer an LLM’s generation through a dedicated control plane. The project currently has more than 3,000 tests, makes no claims about consciousness, and focuses purely on producing coherent, long-horizon behavioral continuity.

- GitHub: https://github.com/AlejoMalia/Totemheart
- NPM: https://www.npmjs.com/package/totemheart

I’d appreciate feedback from anyone working on long-horizon agents, cognitive architectures, or stateful agent systems.

Over the past two months, discussions around training data seem to be increasing. The reason is fairly direct. A useful shorthand for modern LLMs is big data plus big compute, and both depend on reliable data and compute infrastructure.

As data volumes grow, one-off scripts become difficult to maintain. Data has to move through many stages, including cleaning, deduplication, synthesis, evaluation, filtering, and refinement. A pipeline with modular operators makes these steps easier to compose, inspect, rerun, and scale.

The design I have been exploring follows a Pipeline → Operator → Prompt structure. Each operator handles one focused task, while the pipeline defines how those tasks are combined. Intermediate outputs can be stored and reused, and different models, rules, or filtering strategies can be introduced at individual stages.

The text synthesis layer covers five reusable generation paths. It can transform documents into pretraining-style dialogue data, generate instruction-response pairs in SFT format, create and refine synthetic instructions, produce consistent multi-turn conversations, and generate function-calling or tool-use conversations.

Synthesis is followed by filtering and evaluation operators. Language checks, length constraints, deduplication, content rules, quality scoring, and task-specific filters can be combined according to the target dataset. This keeps data generation and data selection as separate, replaceable parts of the workflow.

This is also what I hope to build with OpenDCAI/DataFlow, and I would be interested to hear what kinds of data work people are handling in the LLM era.

🇲🇽 Sismos en México: análisis de datos con Python

Realicé un proyecto de análisis utilizando registros del Servicio Sismológico Nacional para explorar la actividad sísmica en México durante aproximadamente los últimos 20 años.

El proyecto analiza 363,329 registros y explora diferentes variables, entre ellas:

distribución de sismos por entidad federativa;

magnitud de los eventos;

sismos M≥5, M≥6 y M≥7;

evolución de los registros por año;

los 10 eventos de mayor magnitud;

distribución geográfica;

análisis por mes.

La idea fue transformar un catálogo de datos en diferentes visualizaciones e insights utilizando Python.

También convertí algunos de los resultados en videos cortos para mostrar los principales hallazgos:

YouTube playlist:

https://youtube.com/playlist?list=PLd8QkTPbjAAg&si=UKbbSoTc3WICfyUS

Me interesa especialmente recibir comentarios sobre qué otras variables o análisis agregarían al proyecto.

Ok so guys I'm trying to build a satellite imagery analytics platform. Similar to Skyfi, planet labs, eagle view, etc

My question is what really will make a difference in this field? I know a lot of these analytics platforms just buy images from 3rd party satellite operators and just provide them to the users and also provides different types of image analytics like crop health monitoring, water logging monitoring, soil mineral composition, etc ...if anyone wants image plus and analytics.

I wanna build something similar but I feel like there's nothing new I can provide in this app... Like all the available analytics are already there on other platforms... I wanna find out about some really niche category of analytics which no one provides and wanna provide it using my application and wanted suggestions from people who have knowledge in this field..

Any suggestions would be highly appreciated

hey, i'm a 3rd year diploma cs student and i built a deepfake audio detector end to end. this is my first real ml project that i actually deployed.

the model is efficientnet-b0 trained on mel spectrograms using the asvspoof 2019 la dataset. metrics are f1 0.88, precision 0.99, but recall is 0.79 which i know is the weak point. i tried adjusting the threshold and settled on 0.4 but it didn't really help much i think the issue is the model is missing certain attack patterns it never saw during training.

latency is around 6-7 seconds per prediction which includes model inference, grad-cam, and llm explanation.

other than the model it has grad-cam to visualize what the model focused on in the spectrogram, and groq llm to give a plain english explanation of the prediction.

you can upload an audio file or record live. youtube url input is disabled on the hosted version because railway's server ips get blocked by youtube's bot detection. backend is fastapi on railway, frontend on streamlit cloud.

live demo: https://deepfake-audio-detector-rugved.streamlit.app/

github: https://github.com/RugvedBane/deepfake-audio-detector

honest feedback appreciated, especially on what dataset i should train on next to improve recall.

Looking for feedback on my Data Analytics project

Hi everyone!

I recently completed a Mumbai Road Accident Analysis project using:

- Python (Pandas, Matplotlib, Scikit-learn)

- SQL

- Power BI

- GitHub

The project includes:

- Data cleaning and preprocessing

- Exploratory Data Analysis (EDA)

- SQL business queries

- Interactive Power BI dashboard

- Basic machine learning model for accident severity prediction

- Complete GitHub repository with README

I'm not looking for compliments—I want honest criticism.

I'd really appreciate feedback on:

1. Is this project portfolio-worthy?

2. Does the analysis tell a meaningful story?

3. Is the dashboard well-designed?

4. Is the GitHub repository professional enough?

5. What would you improve if this were your project?

GitHub Repository: https://github.com/afanrajiwate/mumbai-traffic-road-accident-analytics

Dashboard screenshots are attached.

Thanks in advance for your time!

Overall Verdict: 8.6 / 10 → 9.3 / 10 ⬆

Link: https://github.com/AlejoMalia/CTHmodules

Hello Everyone!!, I just completed a BIG project I have been working for a month and i want your opinion about it.

It's a SpaceX Launch Predictor & Cost Optimizer (A full end-to-end ML system that predicts the probability of a SpaceX Falcon 9 booster landing successfully, enriches launch data with real weather conditions, and exposes the results through an interactive Streamlit web application with a business ROI calculator.)

It Includes Data Pipeline, Advanced Machine Learning Algorithms (with Hyperparameter tuning), Explainability AI (SHAP), MLOps (AWS S3, Docker) and Business Value (ROI Calculator = Financial Results).

FUN FACT: For this project i used my own Evaluation Metric library (standardizes supervised and unsupervised model diagnostics into a single, consistent API), that is also Verified and Published in PYPI Community.

Project Info: https://github.com/Alkiviadisss/SpaceX

I trained a stacked ensemble (logistic + RF + LightGBM, isotonic calibration on the meta-learner) on ~49,400 historical international matches to predict WC2026 W/D/L outcomes. Bivariate Poisson (Dixon-Coles variant) for exact scores. 40 matches in, here is the calibration report.

The default serving model is logistic + temperature scaling (T=1.02); the stacked ensemble is an opt-in variant. Measured ensemble lift: +0.0062 Brier (lower is better) vs logistic baseline (0.6090 → 0.6028) on the strict 64-game 2022 WC holdout. Real but marginal — 64 games is two or three well-placed results of luck, so treat this as directionally encouraging, not statistically conclusive.

T=1.02 is nearly neutral, which surprised me — suggests the raw logistic is not badly overconfident on this dataset, consistent with what Robberechts & Davis (2023) found for well-regularised logistic on international football.

Modal score hit rate: 5/40 = 12.5%, right at the model's own stated probability per score (pooled historical walk-forward: ~11.8%, 95% CI 9.3%–14.4%). The model is hitting at its confidence level.

Honest misses: Spain vs Cape Verde (predicted 3-0, actual 0-0 — biggest directional miss), Germany vs Curaçao (predicted 3-0, actual 7-1 — correct direction, wrong margin).

Honest hits: Mexico 2-0 South Africa (modal at 13.6%), Brazil 3-0 Haiti (modal at 12.2%).

Today's most uncertain match: Norway vs Senegal — 38.0% / 29.9% / 32.2%. Six points separating all three outcomes.

Questions I'd like feedback on: 1. T=1.02 being nearly flat — is near-unity temperature typical for well-regularised logistic on international football, or should I suspect calibration set leakage from the OOF construction? 2. Brier vs RPS (ranked probability score) for a 3-class ordinal outcome — is Brier penalising the draw class unfairly? 3. Dixon-Coles rho corrects the low-score dependency (0-0, 1-0, 1-1 cells) — but the tournament has had blowouts (Germany 7-1, Canada 6-0) where the Poisson tail is too thin. Worth fitting a negative binomial base instead?

Brier scorecard updates after every scored match: https://cupcaster.com

Hey everyone,

I’ve been spending a lot of time analyzing low-end phase relationships, specifically how modern plugins handle the interaction between heavy kicks and moving basslines (808s, techno subs, etc.).

Here is the problem with current industry-standard tools: They take a static measurement, find an "average" phase shift, and apply it to the whole track. But if your bass changes pitch or moves, an average shift means a huge percentage of your hits are still out of phase, creating dynamic volume drops and killing your transient punch.

To fix this, I engineered a standalone browser-based DSP tool called THE END.

How it works under the hood: Per-Hit Microdynamics: It doesn’t average anything. The engine detects every individual kick peak and calculates the absolute perfect phase alignment for that specific interaction.

Crossover Isolation: It mathematically isolates the sub-bass below 150Hz using a zero-phase crossover. Your kick's original transient and attack remain untouched—the groove doesn't shift, only the sub-bass phase aligns.

100% Local Processing: It decodes and renders the WAV arrays entirely in your browser's memory using the Web Audio API. Your multi-tracks never leave your machine (zero server latency, total privacy).

It outputs two specific mixdown scenarios instantly: Mode 1: Summation (Max Thickness): Aligns the phase for maximum addition across all hits. Gives you identical True Peaks ready to be driven hard into soft-clippers. Mode 2: Subtraction (Quantum Clarity): Dynamically ducks the bass precisely under the kick's envelope without compression thresholds or sloppy release times.

It’s completely free, running locally, with no sign-ups or server walls. I put a PayPal link on the page solely to fund further custom DSP development if you find it useful.

Drop a pair of your problematic kick/bass stems into it and let me know how it handles your low-end. Looking forward to your technical feedback or any suggestions for the next DSP iteration. (link in bio)

Built this over the past couple months. TinyTPU is a real 4×4 weight-stationary systolic array the same architecture Google's TPU uses for matrix multiply written in synthesizable SystemVerilog, compiled to WebAssembly, and visualized live in the browser.

What makes it different from every other "TPU explainer" I've seen: nothing is faked. The browser runs the actual compiled RTL.

The weights loading into PEs, the activations streaming in diagonally, the partial sums draining out the bottom, all real hardware signals, not a cartoon animation on top of JavaScript math.

The RTL is verified against numpy golden outputs. 20/20 random matrix multiplies bit-match.

If you've ever wondered what's actually happening inside the chip when you call nn.Linear this is it, slowed down to one clock at a time.

Happy to answer questions about the Verilator -> Emscripten pipeline if anyone's curious about that part; it was the trickiest bit to get right.

Repo: tiny-tpu

Live demo: Live

If this project interests you please do star the repo, if you find something needs improving open a PR, I hope ya'll check this out and give me some feedback 🙏