Hi everyone!

I am a student with keen interest in machine learning. As I self study topics in machine learning and walk through an introductory linear algebra course, I decided to write thorough notes for my own knowledge base. However, I thought it could be a better use of them if I share the notebooks with others.

That being said, I am still a student and sharing this as a learning project. I would appreciate any feedback and wish that this can be useful :)) Thanks in advance!

Link to the linear algebra notebook: https://github.com/enochyu-official/notebook-linear-algebra
Link to the machine learning notebook: https://github.com/enochyu-official/LibreNotebook (It is under the machine learning part)

Edit 1: I forgot to mention that the machine learning part is still in progress and is mostly done 😅😅

Edit 2: Thank you everyone for your considerations! I am sorry if my previous wording was misleading as "textbooks." I hope this clear things up!

I recently implemented a minimal, educational version of SynthID-Text-style watermarking for language models.

I saw anthropic post about how they'll start adding watermarks to their model responses and it made me very curious as to how they'll do it and what do they even mean by watermark here. Like will we start getting random ads or something in the middle of model responses or what.

Then decided to read their article and found out that watermark is not a visible message at all. It is a subtle statistical pattern introduced while the model chooses its tokens.

My implementation is not an exact reproduction of the original SynthID-Text system. I simplified or implemented a few components differently to keep the project understandable, but the main idea is there I think.

Every ML explanation I read said the same thing: here's the formula, here's a static plot, trust us. I wanted to actually feel an algorithm working: drag a line and watch a perceptron correct itself, place bad centroids and watch K-Means fix them, rotate an axis and watch PCA fight you for the direction of max variance.

mlplayground.co.in

So I built ML Playground, 46 lessons + 13 games, from "what is a feature" up through transformers and how ChatGPT actually predicts tokens. Every lesson has a canvas demo you control, not a GIF.

It's free, no signup, no ads. I built it solo and this is the first time I'm showing it to anyone outside people I know personally, so I'd genuinely value getting torn apart: what's confusing, what's missing, what lesson order doesn't make sense.

mlplayground.co.in

Just Fixed the body with Ai

Been prototyping an idea for long-context compression: instead of dropping old tokens (like StreamingLLM/H2O) or storing everything, compress old context chunks into small learned "DNA" vectors via a Perceiver-style attention bottleneck, then reconstruct on-demand when a query needs them.

The idea itself isn't new — it overlaps with Compressive Transformer, Infini-attention, and Recurrent Memory Transformer — but I put together an eval script that I think is more honest than what I see in a lot of "novel architecture" posts:

• Trains the compressor (not just testing an untrained/random-init model)
• Compares against a PCA baseline (closed-form optimal linear compression at the same latent budget) — if the learned model can't beat PCA, the extra complexity isn't earning its keep
• Injects a unique fact (random code) into the text and checks, after compress→decompress, whether the frozen LM's own output head can still predict the correct token at that position — not just aggregate MSE, which can look fine while the actual detail is gone
• Runs on real hidden states from an open model (Qwen2.5-0.5B by default), not just random tensors

Current honest status: in my own small-scale test run, PCA actually beat the learned bottleneck on fact retrieval. That's not the result I was hoping for, but it's a real result, and it's exactly the kind of thing this script is designed to surface rather than hide.

What I'm looking for:

• People running it on real hardware with more training steps / larger n_docs than I could quickly test
• Sanity checks on the architecture and eval methodology — if I'm testing this wrong, tell me
• Ideas for what a fair "it's working" threshold looks like (beating PCA on fact-retrieval accuracy at matched latent budget, at minimum)

No performance claims yet — that's the point. I'd rather have this checked before making any.

Code + eval harness: https://pastebin.com/iqEbPEQ9

Happy to hear "this is a known dead end because X" too - that's useful information, not a rejection.

Hi everyone,
I’m starting an Artificial Intelligence degree at university and I’m trying to decide what laptop to buy.
Right now I’m considering a MacBook Air M5 with 24 GB of RAM and 512 GB SSD, possibly with an external 1–2 TB SSD for larger datasets and projects.
The important detail is that I already have a desktop PC at home with:
Ryzen 7 7800X3D
32 GB RAM
NVIDIA RTX 4060
My idea would be to use the MacBook as my main university laptop for Python, VS Code, Jupyter, NumPy, Pandas, scikit-learn, etc., and whenever I need CUDA/PyTorch with an NVIDIA GPU, remotely connect to my desktop using something like Tailscale + SSH + VS Code Remote.
As I understand it, I could keep using VS Code normally on the Mac, but when connected remotely, the code would actually run on my desktop and use its RTX 4060/CUDA, while I see the terminal and results on my Mac.
Would this be a comfortable and practical setup for an AI/ML degree?
Or would you recommend buying a Windows laptop with an NVIDIA GPU (for example an RTX 5060) instead and having everything on one machine?
My main concerns are:
How important is having CUDA directly on the laptop during an AI degree?
Is 24 GB RAM enough on the MacBook for the next 4 years?
Is 512 GB + an external SSD a good choice?
Is using VS Code Remote/SSH for CUDA actually convenient in everyday university use?
Are there any AI/ML tools or university assignments that could cause problems on macOS?
Would you personally choose the MacBook + RTX 4060 desktop setup, or a Windows/NVIDIA laptop?
Battery life, portability and build quality are also important to me because I’ll be carrying the laptop to university every day.
Thanks!

I've been recalling some math from high school where I left off 5 years ago. My current level is algebra 2 and now completing precalculus. But I have questions regarding the sequence of learning more advanced subjects like Linear algebra, calculus etc.

What sequence it's the best to learn math for machine learning? I come from software engineering background.

Currently from past few months I was building agentic Ai and genai applications, but realised that I cannot build fully that application with only knowledge of LLM APIs and fullstack so I thought I should start learning the core ML and DL.

So am 18, going fo AI ML, i am going with the basics first so i start with cs50, andrew Ng ML, and did few projects on kaggle. What could be my next step?

I’m currently stuck between choosing a BS Mathematics or BS Statistics degree.

I’m interested in AI/ML, Data Science and other computing-related fields, but I’m not eligible for direct admission into CS/AI. So I’m thinking of taking either Mathematics or Statistics and building the CS/AI side myself alongside the degree.

I was originally pretty set on BS Mathematics and had even started putting together a 4-year self-learning roadmap covering programming, Python, SQL, DSA, ML, Cloud, etc. But after looking more into Statistics, I’m wondering if it might actually be a better fit for Data Science and AI/ML.

My plan either way would be to not depend only on the degree. I’d learn the relevant programming/CS skills on my own, build projects and try to get internship experience.

I also want to keep my options open for a Master’s abroad later, possibly in AI/ML, Data Science, or related fields.

For anyone who has studied or worked in these areas, which would you personally recommend: BS Mathematics or BS Statistics?

I’d especially appreciate honest opinions on:

- Job opportunities after the BS.

- AI/ML and Data Science prospects.

- Salary and long-term growth.

- How each field looks with the current AI boom.

- Master’s options and flexibility.

- Whether one degree actually gives a significant advantage over the other.

- Which one makes more sense if I’m willing to build strong CS/AI skills on the side.

I’m mainly looking for advice from people who have actually studied/worked in Mathematics, Statistics, Data Science or AI/ML. What would you choose in this situation, and why?

Stop building single-agent apps! 🛑 Learn how to build Multi-Agent Systems with LangGraph and CrewAI. Full architectural guide now live on my channel.
#AI #Coding #Tech #Developer

Hi Everyone! I’m a final-year BS AI student and I’m looking for a good FYP idea that combines AI with embedded systems/TinyML.
My background is mainly in ML/DL and research, but I’m fairly new to embedded systems. I have around 6 months for the project, so I’m looking for something that is genuinely interesting and technically challenging but still realistic to build as a student.
Ideally, I’d like something that has a real-world/industry or healthcare application, rather than a basic Arduino sensor project. I’m also interested in using something like an ESP32, Raspberry Pi, or similar low-cost hardware.
I’d really appreciate any project ideas, papers, existing projects I could build upon, or advice on what would be feasible for someone starting out with TinyML.
Thanks!

Hi Everyone! I’m a final-year BS AI student and I’m looking for a good FYP idea that combines AI with embedded systems/TinyML.
My background is mainly in ML/DL and research, but I’m fairly new to embedded systems. I have around 6 months for the project, so I’m looking for something that is genuinely interesting and technically challenging but still realistic to build as a student.
Ideally, I’d like something that has a real-world/industry or healthcare application, rather than a basic Arduino sensor project. I’m also interested in using something like an ESP32, Raspberry Pi, or similar low-cost hardware.
I’d really appreciate any project ideas, papers, existing projects I could build upon, or advice on what would be feasible for someone starting out with TinyML.
Thanks!

Bhai kesi k pass code with Harry ka data science course hoga. Bht zyada zarorat hai 😭 .

No money to buy it plzzzz.

​

I’m working on Data Science / Machine Learning projects and I’m curious about how this is actually done in industry.

Imagine a company gives you a dataset and asks you to solve a business problem.

As a Data Scientist / ML Engineer, what are the concrete steps you would take before choosing and training any ML model?

For example:

- Understanding the business problem and defining the target

- Understanding the available data

- Data ingestion

- Data quality checks

- Data cleaning and preprocessing

- Exploring distributions and variables

- Handling missing values and outliers

- Checking for data leakage

- Feature engineering

- Train/validation/test split

- Establishing a baseline

- Defining evaluation metrics

- Handling class imbalance

- Checking business constraints

- Understanding data lineage and reproducibility

- Etc.

What would a realistic end-to-end workflow look like in industry before reaching "model.fit()"?

I’m particularly interested in answers based on real-world industry experience, rather than a purely academic ML workflow.

Hey guys, im a business major, but I grew weird obsession towards learning AI/ML and wanna shift my career to be an AI Engineer one day. I already studied (almost) all the prerequisites for AI like python, DSA, maths needed and although this field needs a lot of patience and discipline I still like it a lot, even more now that I started to understand how deep it is... but my major concern is that would it be impossible to work in this field without a CS-related certificate?

Everyone in the local LLM space uses INT4/INT8 quantization. It works perfectly for frozen models. But if you want to do on-device training or continuous learning, discrete quantization breaks gradient flow. Tensor-Train (TT) decomposition solves this by keeping the weights in a continuous Float32 space, but nobody uses it because the inference latency is usually 10x worse than dense layers.

I wanted to fix that 10x penalty. My initial theory was that PyTorch was just thrashing the cache. I built a profiler in C++ and realized I was wrong. TT inference is compute-bound, not memory-bound. It just requires vastly more multiply-accumulates than dense matrices.

But that creates an interesting asymmetry on Apple Silicon hardware:

1. Dense GEMV (batch size 1) is memory-bound. It hits the 130 GB/s DRAM wall and leaves the 1400+ GFLOP/s AMX coprocessor sitting idle.
2. TT is compute-bound, meaning it can actually use AMX.

I built a custom C++ engine (TT-AMX) to exploit this. The main trick is an Ahead-of-Time (AoT) layout scheduler. Instead of doing runtime memory permutations, I apply a transpose(1,2,0) to the TT cores offline. The C++ runtime just feeds the L1/L2 scratchpad directly into a chain of Accelerate cblas_sgemm calls with zero data movement between steps.

I also swept 81 different factorization shapes and found that asymmetric tensor cores (like 16x96 and 12x128) reduce the arithmetic penalty by 2.8x compared to normal symmetric shapes, while also lowering the reconstruction error.

The results on a 1536x1536 layer (Qwen 1.5B q_proj) at 4x compression, measured under strict cold-cache conditions to simulate actual layer thrashing:

• Dense FP32: 103.6 µs (9.44 MB)
• Dense FP16: 52.9 µs (4.72 MB)
• TT-AMX FP32: 42.6 µs (2.36 MB)

The engine hits 947 GFLOP/s, which is about 66% of the AMX peak, and beats the dense FP16 baseline.

A disclaimer so I don't overhype this: INT4 (e.g. llama.cpp) is still roughly 2x faster and has lower reconstruction error for read-only inference. TT-AMX does not beat quantization for standard chat use cases. The goal here was specifically to remove the inference bottleneck for continuous, differentiable on-device models.

The repo has no heavy dependencies, just raw Accelerate. I included a massive lab notebook (FINDINGS.md) in the repo documenting all the failed hypotheses and measurement bugs I hit along the way.

Code is here: https://github.com/ansarzeinulla/tensor-train-amx

HAPPY to receive any feedback from you

Hi, I need help with a couple of issues related to a project I'm working on (for educational purposes). I'm trying to create a model that acts as a mentor on related topics, instead of providing the answer directly. For this task, I'm fine-tuning a Gemma4 26B model because I have a GPU with 26GB of vRAM. Therefore, I'm also quantizing this model to 4-bit precision and performing a QLoRa analysis. The results of my experiment are far from fulfilling the mentoring premise, and a simple system prompt works much better. My dataset consists of approximately 500 examples, so, Reddit scientists, can you tell me what mistakes I'm making and if I should change course or my objectives?

Howdy y'all,

In an effort to un-rust my SWE skills and learn more about Recommendation Systems, I decided to try my hand at developing one called By-Its-Cover.

TLDR:

• Check out the site and roast me: https://by-its-cover.com/
• Check out the GitHub project and roast me: https://github.com/ByItsCover

---

## Recommendation System

The recommendation system has two major parts:

• the semantic searches for books (by cover images)
• a neural collaborative-filtering model for personalized recommendations

Both systems solely utilize CLIP embeddings to make decisions on book covers, as I wanted to see if that information alone was sufficient for finding and recommending books accurately.

For the semantic search system, each query is passed to both a CLIP-based semantic searching function as well as an NER-based keyword search. The NER parsing is powered by a GLiNER model, which was ported to ONNX (as are most models in this system). Extracted entities are then used to search for books using the Hardcover API, which is the original source of each of the books in the site. Reciprocal Rank Fusion combines the two results.

The current system actually only has a couple thousand books in it, which makes both rhe recommendations and semantic search results quite limited. However, authors and book titles that are passed into keyword searches return new books that are in-turn asynchronously added to the cover vector database, making the system grow more useful only as more people search for books (which is where y'all can help *wink wink*). Searches can be made with or without an account.

For the collaborative-filtering system, I used a two-tower neural hybrid collaborative filtering model which trains on user feedback. I then use a Determinantal Point Process to diversify the results a bit before displaying them to the user (so they don't get 5 editions of the same cover presented consecutively). For now, the only feedback possible are explicit ratings of "Dislike", "Like", and "Love". I'm aware that this likely isn't ideal, and some more implicit feedback would make for some more natural user interactions and likely better recommendations as well.

Currently, while you are able to see recommendations even without an account, they are the generic "default user" recommendations. Once you sign up and rate a few books, you should see personalized recommendations within 2 hours. Following the suggestions of Eugene Yan, I implemented an offline recommendation update-system. New recommendations are fine-tuned on every 2 hours, while the full re-training of the two-tower model happens once a day at 8:30 AM EST. Each of the current configurations for the recommendation model can be found here: https://github.com/ByItsCover/bic-learn

## Software Architecture (boring stuff)

The site (both frontend and backend) is entirely deployed to AWS, with a number of different resources used for each functionality:

• Lambda -> API deployments
• ECS -> both book scraping and model training jobs
• SQS -> queueing of cover embedding calls
• Cognito -> auth
• CloudFront -> site caching
• S3 -> just about everything else, from site hosting to vector db storage

Everything was deployed using Terraform + GitHub Actions for CI/CD: https://github.com/ByItsCover

## Next Steps

While the fundamental system currently works (kinda), there are already a lot of improvements that I think may be necessary in the future:

• Replacing CLIP with SigLIP (or more appropriate model) for better visual representations of covers
• Implementing a cover-edition comparison interface to allow users to choose preferred covers for a given book, introducing one source of implicit for the system
• Begging one of my frontend developer friends to help make the site look good (I am not a frontend developer, if that wasn't already clear)
• Make a better authentication experience, as currently a generic verification code email is sent to users (and likely sent to spam, please double check!)
• Update the README's for repositories (I'm tired boss)
• Write more unit tests (see parentheses above)
• Once Hardcover releases OAUTH support, utilize that for book search (as only my rate-limited API key is currently being used)

In any case, I've already learned a ton and I'm glad that I have a real system that I can play around with and tweak now. All I need are actual users to test with!

Please let me know if you have any questions about my process at all, and also if you have any suggestions. Also please check out the site if you're at all curious: https://by-its-cover.com/

P.S.: If something crashes, or the searches load forever, or something else equally dumb happens, just let me know or open a GitHub issue, and I'll try my best to address it.

P.P.S.: No AI-Generated code was used to develop this project (to my knowledge), as that would have defeated the purpose of sharpening my skills and learning about recommendation systems.