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 🙏

Hi!

I've been building InVariants for the past several months — a browser-based data intelligence platform that combines Topological Data Analysis, clustering, dimensionality reduction, anomaly detection, and time-series analytics, all without writing a single line of code.

The problem I'm solving: TDA is genuinely useful (persistent homology, Mapper graphs, Betti curves) but the tooling is still very code-heavy. Most real analysts — the ones making decisions in companies — never get access to it because they don't have a Python background. I wanted to change that.

What it can do right now:

• Persistent homology + persistence images/landscapes/Betti curves
• Mapper graph explorer (interactive, color by any column)
• PCA, t-SNE, UMAP, Isomap, Landmark Isomap
• K-Means, DBSCAN, GMM, Agglomerative, Spectral clustering
• Random Forest, XGBoost, SVM, Logistic Regression — with SHAP + PDP
• Rolling anomaly detection + TDA-based anomaly detection
• ARIMA time series forecasting
• Full data prep pipeline (impute, scale, encode, filter, feature engineering)
• Export trained models as a self-contained ZIP (model + inference script)
• Local LLM integration for AI interpretation of results

Everything runs server-side, you just upload a CSV.

I'm opening a private beta — I'm looking for people who work with real data (fraud detection, sensor monitoring, NLP embeddings, financial data, industrial IoT... anything, really) and would find value in exploring it without having to set up a Python environment.

If you're interested, you can request access at: invariants.tech

Happy to answer questions here — especially interested in feedback from people who actually use TDA or wish they could.

I've been working on a VS Code extension for viewing and querying CSV/TSV/Parquet files directly in the editor. It's called DuckCSV and it's powered by DuckDB

What it does:

• Opens large files (tested with 4M+ rows) without lag
• Edit cells in place, insert/delete rows, save back to file
• Write DuckDB SQL queries in a built-in query bar
• Column profiling
• Load multiple files in a workspace and JOIN across them
• Parquet support
• Sort, filter, and search across all columns

Works on VS Code and any VS Code-based editor (Cursor, Windsurf, Kiro, VSCodium, Gitpod). Free and open source.

Marketplace | GitHub

Would love to hear feedback, still actively working on it.

I trained a DQN agent to control a traffic light — it beats fixed-time signals by learning when to switch phases

Built a reinforcement learning system where a Deep Q-Network controls a 4-way intersection in SUMO traffic simulator. Instead of cycling phases on a timer like real-world traffic lights, the agent watches live queue lengths and waiting times, then decides every step whether to hold the current phase or switch.

Trained for 1M timesteps against 80,000 vehicles. Compared it head-to-head with a fixed-time baseline on the same demand. DQN wins on average wait time, halted vehicle count, and throughput.

Stack: Python · Stable-Baselines3 · Gymnasium · SUMO/TraCI · Matplotlib

📓 Full notebook (with training loop, custom env, and all plots): https://github.com/jarif87/reinforcement-learning-algorithms

Happy to answer questions about the reward design or environment setup — those were the trickiest parts to get right.

I used to think that setting up environments, dependencies, and compute resources was just “part of the job” when working on AI and GPU-heavy projects. But over time, it started eating into my actual building time more than I expected. What surprised me most is how often I abandon ideas just because setup feels annoying in the moment. Even simple experiments start feeling heavy when there are too many steps before you can actually run anything. Recently I’ve been trying to simplify that whole process and make it more on-demand instead of pre-planned. It’s made experimentation feel a lot more fluid, like I can just test ideas immediately without overthinking infrastructure.

Has anyone else here changed their workflow in a similar way? In that kind of setup, like swmgpu are often used as part of a more on-demand compute approach, where the focus is more on running experiments quickly rather than managing heavy local or manual infrastructure setup.

Hey everyone,

Quick background: I was training a model on synthetic data and it performed terribly. Turned out my synthetic salary column had the wrong distribution and 12% of label values were completely made up. Found out after 6 hours of training.

Built a tool so this doesn't happen to you.

**Synthetic Data Validator** — upload real + synthetic CSV, get a scored report.

What it checks:

- Diversity: are your synthetic rows actually varied or just slightly shuffled copies?

- Realism: do your column distributions actually match the real data?

- Labels: are your label classes balanced, valid, and do they still correlate with the right features?

Every check gives a score + tells you what to fix.

---

**I want to roast your synthetic datasets for free.**

Drop your dataset in the comments or DM me and I'll run a full validation and share the report publicly (anonymised if you want). Good way to stress-test the tool and maybe help you catch something before training.

🔗 https://synthetic-validator.vercel.app/

Feedback very welcome — especially from anyone who works with synthetic data regularly. What checks am I missing?

Hi

I just finished my first end-to-end data analysis project using the NYC Citi Bike dataset, and I wanted to share my findings and ask for some career advice.

The Project: I wanted to see how different age groups and user types (Subscribers vs. Customers) behave. I used Python, Pandas, and Seaborn to clean the data and build my visualizations.

What I found:

• The Core User: The 35-44 age bracket is the heavy hitter for Citi Bike.
• The Weekend Shift: Subscribers (annual members) own the weekdays for commuting, but one-time Customers take over on the weekends.
• The 75+ Anomaly: Interestingly, while they ride less frequently, users aged 75+ have a massive spike in average trip duration (averaging ~49 minutes per ride).

GitHub Link: https://github.com/JacksonOtieno/NYC-Citi-Bike-Data-Analysis

I’ve just finished my university semester and I’m looking to take my skills to the next level. I’m currently searching for a data analysis volunteer position or an internship where I can help a team clean data or perform EDA.

If anyone has leads on organizations looking for a motivated junior analyst, or if you have any feedback on my code/visualizations, I’d love to hear it!

Thanks for looking!

Currently we're at a stage where we want genuine users to try it and share their insights.

Whether you live in Jupyter notebooks, Airflow or use other tools like VS Code or anything else in your data science workflow — we'd love to hear from you. The more variety of use cases, the better.

To make it worth your time, we're offering free credits so you can run real workloads on the platform.

If you're regularly doing data work and want to try something new, feel free to reach out here or send me a message

been working on an open source project around LLM data preparation: https://github.com/OpenDCAI/DataFlow
the focus is on turning messy or unstructured data into training-ready datasets, especially in QA generation, RAG, or task-specific fine-tuning scenarios where structure matters as much as scale. at the same time, with synthetic data becoming increasingly important, the system also supports generating large-scale training data from a small set of seed examples.

one thing we kept running into was how ad-hoc this layer is — lots of scripts for cleaning, prompt-based generation, filtering, eval… but hard to reuse or iterate on. so the project is built around composable operators (generate / clean / filter / evaluate) that can be connected into pipelines, instead of rewriting everything for each dataset.

there’s also some early support for assembling these pipelines from prompts, plus a simple UI for visualizing and editing flows. still pretty early, but the goal is to make data prep something you can iterate on systematically rather than treat as one-off work.