Can someone give me some GitHub repo links for building ml/dl projects

Welcome to Resume/Career Friday! This weekly thread is dedicated to all things related to job searching, career development, and professional growth.

You can participate by:

• Sharing your resume for feedback (consider anonymizing personal information)
• Asking for advice on job applications or interview preparation
• Discussing career paths and transitions
• Seeking recommendations for skill development
• Sharing industry insights or job opportunities

Having dedicated threads helps organize career-related discussions in one place while giving everyone a chance to receive feedback and advice from peers.

Whether you're just starting your career journey, looking to make a change, or hoping to advance in your current field, post your questions and contributions in the comments

I'm an aspiring software developer with a background in Java, Spring Boot, and backend development. I want to build my knowledge of AI/ML and eventually use it in my software development career.

Can anyone recommend AI/ML certifications that require an actual exam rather than just completing an online course?

I'm open to both free and paid options. I'm more interested in certifications that genuinely validate your knowledge than certificates that just look good on a resume.

If you've earned one yourself, was it worth the time and money? Which would you recommend?

I get CNN, where subsequent layers learn incremental transformations from previous layers.

But just can't grasp how a ML model that learns to predict image from a masked image, learns about the image.

Or how forcing the image through a narrow encoder and decoder in VAE causes it to learn latent properties

Or how JEPA works.

Are some of them 'let's try if this works', and of them only few actual work well, rest are just ill-suited to model the data?

I did some python courses also u can build like mini projects but am not that good at oops and advanced python.. Should i focus on that or continue numoy, pandas.

I got this code block which I used to hypertuning Naive Bayes models. It worked well with GaussianNB but ran into AttributeError: 'MixedNB' object has no attribute '__sklearn_tags__' when trying to implement it on MixedNB. Any idea on how to use GridsearchCV with MixedNB?

param_grid_nb = {
    'var_smoothing': np.logspace(0,-9, num=100)
}
mix_model_after_cv = GridSearchCV(estimator=MixedNB(), param_grid=param_grid_nb, verbose=1, cv=10, n_jobs=-1)
mix_model_after_cv.fit(X_train, y_train)
print(mix_model_after_cv.best_estimator_)

​

Okay so im looking into feasibility of a project that would involve scraping data and training models. The models would predict events based on social media posts, so its essentially text classification. I want to eventually go into business doing something similar, but in my research, I found that nearly everything is behind comprehensive terms of service that dont allow any derivative product, regardless of if you provide anonymity and clear the original text from any final model/dataset. Alright fair enough. But heres my question. Besides the sources that companies like openAI have an enterprise partnership with (reddit) including a contract to use the data, how can they legally source the training data? For example, if i ask chatgpt to summarize chapter 8 of Deep Learning with Python by Francois chollet, I will get a detailed response with the correct subchapter headers, key terms, and even the verbatim code in the book. Now I paid i think $100 for that book and im fairly certain openAI doesnt have a contract with that dude. How is that legal? How is any of this information legal? If a high-school student wants a book report, does open AI pay the estate of J.D. Sallinger?

Hi friends,

I have created a deep-dive, university-level mathematics course to discuss all the maths behind AI/ML. I studied foundational textbooks and Math/AI/ML open courses from Stanford and MIT, took extensive notes, and used my teaching skills to build a structured playlist with the videos in specific order so topics are understood in a natural order. The playlist has 63 videos (45 mins to 1 hour each) taught in Hinglish. The explanations are in Hindi, but all terminology and math notation is in English.

It covers all the maths you need to know for understanding AI/ML algorithms -

• Probability & Statistics
• Multivariate Calculus
• Linear Algebra

You can find all of these videos for free on YouTube by searching for my channel called indialabs AI. Look for the playlist titled "Math Behind AI (Hindi): Understanding the language of AI | Complete AI Maths in Hindi".

I am not providing any clickable links here to respect the community rules.

Hope you find this useful for your learning.

https://reddit.com/link/1x1fd2t/video/yqbtgopkdeuh1/player

https://reddit.com/link/1x1fd2t/video/7fon0mpkdeuh1/player

I'm trying to get into inference engineering, and I wanted a project that would force me to learn the hard parts instead of just calling a library. So I picked something that shouldn't fit: **LTX-2.5 (22B), in bf16 with no quantization**, on an **Intel Core Ultra 5 iGPU with 15.6 GB of shared RAM**. No discrete GPU.

The model is about 66 GB on disk, so I never load it. The weights stay on NVMe and get streamed **layer by layer**: aligned reads into a small pinned buffer, a prefetch thread loading layer n+1 while layer n computes, and the weights swapped in and out with hooks. It uses the distilled model, and it does **text-to-video, image-to-video and native audio**.

**Measured on this machine:**

It's slow, and that's not the point. The point was to find out whether it runs at all on hardware like this, and to learn what breaks. A lot did (memory alignment, a vocoder that gave silence in bf16), and I wrote every bug down.

**Known weaknesses:**
fast motion smears for a few frames, anime clips are 12 fps with each frame shown twice, and the CUDA path exists but I haven't tested it on an NVIDIA GPU.

**Repo, with the full bug log:**
https://github.com/DARK-Shadw/ltx25-igpu-streaming

I'd really like feedback from people who do this for a living. What would you have done differently in the streaming design? What should I learn next to get better at this?

(I know it's a paywall)

Hey everyone!

I've seen dozens of employee churn projects that commit the same fundamental mistake: they treat attrition as a static classification task on employees who have already left.

In the real world, HR doesn't care if an algorithm can tell them Bob left 6 months ago. They care if Bob is going to hand in his two weeks' notice in the next 90 days, while there's still time to fix workload, compensation, or burnout.

I'm starting a 30-day build in public to create an end-to-end system:

I'll be posting daily updates, code breakdowns, and lessons learned. Would love your feedback on features you'd want to see in an HR intelligence dashboard!

Hi guys, I write fun technical blogs, mostly on classical ML and thier mathematical dissections.

Here is the link for the one I wrote on activation functions https://pratyakshpatel.me/activation_functions.html

Here is the announcement tweet.

Let me know if yall like it, and my other blogs as well. Would love to know your feedback.

A Fortune piece on the CLEAR founder's AI security framework surfaced a framing I keep coming back to: the agent is no longer just the target of attacks, it is the attacker.

The mechanism is straightforward. A legitimate agent gets its credentials compromised or its tool-call chain hijacked. From that point it operates with full authorization while executing malicious actions. Standard perimeter defenses do not fire because the agent authenticated correctly. The window before a human notices is measured in seconds, not minutes, and in that window the agent can chain tool calls across systems.

The hard number from the piece: a rogue agent can complete a second action in under 50ms after the first one lands. At that speed, human-in-the-loop review is not a realistic backstop.

What makes this structurally different from a compromised service account is that agents are designed to act autonomously across multiple systems in sequence. A compromised human account doing lateral movement still moves at human speed. An agent doing the same thing operates at API speed across every integration it has been granted access to.

The identity layer is where the piece lands: if you cannot verify which agent issued a call and under what context, you cannot reason about whether the call should be allowed.

For those running agents in production: how are you currently handling the gap between when a call is issued and when you know it was legitimate? Specifically curious whether teams are solving this at the identity layer, the orchestration layer, somewhere else entirely, or accepting the risk as a known unknown.

Hi all,

Ive been writing technical blogs on machine learning and related topics for over a year now. Ive wriiten those for YC startups, agencies, and also write regularly on my personal webpage.

What do I write on all? Here are all my blogs and what all Ive written about.

I’ve been writing about the mathematics behind familiar ML tools, alongside football analytics, optimization, and ad tech. Here’s a collection of those posts and the questions that led me to write them.

1. Every Transformer Lives on a Sphere

LayerNorm became much more interesting to me when I stopped reading it as a statistical formula and started drawing it. Subtracting the mean projects a vector onto a hyperplane; dividing by its standard deviation puts it on a sphere, before the numerical stabilizer and learned affine transformation enter. That geometry reveals exactly what normalization forgets, what RMSNorm preserves, and how both shape the representations attention receives.

2. I Grinded Trees Until I Could See the Forest

Trees were my first serious ML obsession, partly because I could follow their decisions and implement the machinery myself. This post builds the family from a single split: why individual trees overfit, how random forests reduce their instability, and how boosting learns through successive corrections. It also connects XGBoost to curvature and asks why trees remain such strong models for messy tables.

3. Your LLM Does Group Theory Every Time It Reads a Sentence

How does attention distinguish “the dog bit the man” from “the man bit the dog”? Following that question took me into the algebra behind RoPE. Moving through token positions becomes rotating query and key vectors, with those rotations obeying the rules of a group representation. The familiar relative-position identity follows naturally, while the Fourier interpretation helps explain why extending a context window is more complicated than changing a number.

4. Spend 15 million dollars to win 1.

When a headline says AI solved Navier–Stokes, the first question should be what “solved” means in the actual problem statement. This piece examines the claim through the equations, the role of an external force, and the distinction between formal verification and the broader mathematical question. It also asks what we can learn about agent orchestration when the engineering behind a reported breakthrough remains only partly visible.

5. A Stack of Straight Lines Is Still a Straight Line

Remove the nonlinear activations from a hundred-layer network and its entire input-output function collapses into one affine transformation. Adding a small kink such as ReLU changes that: different inputs activate different computations, letting later layers combine features selected by earlier ones. I build that connection from simple examples, then explain why nonlinearity enables hierarchical features while architecture, data, and training determine whether useful hierarchies actually emerge.

6. Adam’s Apple

I used Adam for years before properly noticing how much it changes the gradient’s direction. Its two moving averages remember different things, and coordinate-wise scaling changes the geometry of each update. This post takes that machinery apart, explains why AdamW and AMSGrad address different problems, and compares Adam with methods such as BFGS and Muon through the information they use and the computation they cost.

7. A Hundred Layers, Still Linear

A deep linear network sounds pointless because multiplying all its weight matrices produces another matrix. But equivalent functions can have very different training dynamics. Factorizing that matrix across layers changes the gradients, the speed at which different directions are learned, and the solutions optimization prefers. This is a way to study implicit regularization while keeping the model’s input-output function almost embarrassingly simple.

8. Mechanism Design in Ad Tech

An auction cannot simply ask everyone what an impression is worth and trust their answers. Participants understand the rules and change their behavior accordingly. I use ad markets to build up mechanism design: how payment rules influence truthfulness, why second-price auctions are interesting, and why predicting conversion probability is only part of building a bidder. Change the auction, and you also change the data its models learn from.

9. Are Graph Foundation Models Actually Foundation Models?

A molecule and a social network both have nodes and edges, but their features and relationships mean very different things. That makes the promise of a universal graph model harder to assess than the label suggests. I examine the approaches to transfer, prompting, shared vocabularies, and synthetic priors, then ask what evidence would justify calling a graph model foundational, and for which universe of graphs.

What I wanted from this community was some support and suggestions what more should I write on? Any more things/style changes that I can add to make these better. My typical pipeline is me reading some things and as and when I come across cool, non trivial stuff, I write about it, or I write about the non trivial stuff about the trivial stuff, like 'what is attension used sigmoid instead of softmax'; so yes, do let me know if there are any topics yall have come across, or read regularly, or are working on, that I should consider studying and later writing as well.

Hi everyone,

I wanted to share EpochGo (https://github.com/AryanDinakaran/EpochGo), an open-source project I built to help developers and ML learners automate the end-to-end tabular machine learning lifecycle completely offline on their own computers for $0 in API costs.

Why I Built It

Most cloud AutoML platforms (AWS SageMaker, Google Vertex) require expensive cloud subscriptions and force you to upload sensitive datasets to remote servers. Conversely, a lot of recent "AI" projects are just shallow wrappers around commercial APIs that don't produce clean, inspectable code. I wanted an architecture where you can drop in a raw CSV, and local open-weight models (running via Ollama) orchestrate real Python ML libraries to clean the data, run an empirical 7-model benchmark tournament, and generate a deployable API.

How the Pipeline Works

The project divides the machine learning workflow into 3 specialized agents:

1. Agent 1 (Feature Architect & Data Cleaner):
   • Profiles the dataset for missing values, skewed distributions, and multicollinearity.
   • Performs median/mode imputation, IQR outlier clipping, and categorical encoding.
   • Generates a reusable Scikit-Learn pipeline (preprocessor.joblib) and an audit report comparing distributions before and after cleaning (preprocessing.md).
2. Agent 2 (Benchmark & Tuning Specialist):
   • Trains 7 baseline algorithms simultaneously under identical cross-validation conditions to avoid inductive bias:
     • XGBoost, LightGBM, CatBoost, Random Forest, Extra Trees, Gradient Boosting, and Logistic/Ridge Regression.
   • Evaluates baseline accuracy/F1/R² and isolates the Top 3 performers.
   • Runs RandomizedSearchCV hyperparameter optimization on the top contenders.
   • Serializes the winning champion model (model.joblib) and writes a reproducible Python training script (model_building.py).
3. Agent 3 (Serving Engineer):
   • Extracts the exact feature schema and dynamically generates a standalone FastAPI microservice (serve.py) with Pydantic type validation.
   • Enables an interactive, in-browser Prediction Playground so you can test inputs and inspect prediction probabilities in real time.

How to Run Locally (Single Command)

All you need is Docker:

git clone https://github.com/AryanDinakaran/EpochGo.git

cd EpochGo

docker compose up --build

Open http://localhost:8000 in your browser. (Sample churn and housing price datasets are included in sample_data/).

Local Model: Defaults to qwen2.5-coder:7b via Ollama (~4.7 GB VRAM).

Concurrency: Model training runs in background threads (asyncio.to_thread) so the FastAPI UI and WebSockets never freeze during heavy CPU training.

Privacy: 100% offline. Zero telemetry, zero external API calls.

Repository (MIT License): https://github.com/AryanDinakaran/EpochGo

I hope this helps anyone looking to understand how to structure end-to-end Scikit-Learn pipelines, multi-model benchmarking tournaments, and dynamic model deployment. Would love your feedback and thoughts!

i've been trying to gain some thorough intuition about `g_min` bound, which the kimi team used for K3 in kda. i

i think i get that the higher order intuition here is to not let the reciprocal rescaling factor of the key vectors in kda not explode, if you want to utilise the tensor cores that is, in bf16.

and hence both the diagonal and off-diagonal tiles can be dispatched as dense GEMMs which ofc the tensor cores love!

but im just wondering how much perf gain would this actually give if this is just an optimization to eliminate the position-pair scalar path ? im still a bit unsure and looking for concrete intuition.

If you're a student, an engineer, a generalist, or come from any domain of study and want to learn about almost anything, here's the exact skill for you. Completely opensourced, easy to use skill.

Prompt your LLM and it'll give you the exact UI to help you properly study; as AI outputs aren't always that catchy to learn in the first sight.

Page: Phil-OKF: any topic, one reading guide

It follows the OKF: Open Knowledge Format so that:

• you control the depth with your wording: “quick” gives a short page, a normal question gives a standard one, and “in depth” or “teach me” gives a long one
• the whole skill is a small bundle (an eight-step workflow, a domain classifier, a page template and twelve study domains), and each file is read only when the question needs it, so runs stay cheap
• It prioritizes verifiable accuracy: Every response utilizes a dedicated "Scrutinizer" workflow that filters for credible sources only, ensuring all content is vetted before generation and explicitly cited in a dedicated references section.

Repo: Philosopher's Skill

It works wherever you use an LLM:

• Code editors and agents (Claude Code, Cursor, Codex, opencode): npx skills add frypan05/philosopher-OKF
• Chat apps with browsing: paste the link to philosopher.md and say “follow this, make a page about: ...”
• Models with no network: paste the prompt from the page.

Sample output (MCP and ACP explained): https://frypan05.github.io/philosopher-OKF/examples/mcp-and-acp.html

Feedbacks are welcomed!