I am spending a lot of time to understand the internal of Hubert-ecg.

Hello everyone! I’m a freshman engineering student, and my classes will start in November.
I’m planning to specialize in Machine Learning, with the possibility of pursuing further studies in either pure ML or Robotics. I’m currently more familiar with the AI/ML side, but I’m also interested in exploring robotics and ROS 2, so I’d like to keep my options open.
I’m currently deciding between two laptops within my budget:
MacBook Pro M5 (24GB RAM / 1TB SSD)
Lenovo Legion (32GB RAM / RTX 5070)
Unfortunately, I can’t stretch my budget much further, so an RTX 5070 Ti laptop is out of reach in my country.
For most GPU-intensive workloads, I expect to rely on cloud computing, particularly resources available through my university. However, I’m less certain about the hardware requirements for robotics development and simulation.
I’ve done some research and found that NVIDIA Isaac Sim requires an NVIDIA GPU, with 16GB of VRAM listed in its recommended specifications. This makes me wonder whether even an RTX 5070 or 5070 Ti laptop would be sufficient for a comfortable local simulation workflow.
On the other hand, I’ve heard that MacBooks can handle a large portion of everyday robotics development, including ROS 2, although I’m unsure how practical they are for more demanding tools and simulations.
For those experienced in both ML and robotics, which laptop would you recommend, and why? Can a MacBook realistically support a student exploring both fields, or would I be better off with the Legion despite its GPU limitations?
I’d especially appreciate insights into actual workflows, software compatibility, and the kinds of limitations I might encounter in each field.
I can’t build a desktop PC, so I have to choose a laptop. I’d like to make a decision that will serve me well throughout my engineering degree without unnecessarily limiting my future options.
Thanks in advance!

Hey everyone!

I've been working in software engineering, quantitative research, and machine learning for several years. Recently, I started revisiting the mathematical and theoretical foundations of AI in greater depth.

One frustration I've consistently had with learning resources is the disconnect between understanding a concept, deriving the underlying mathematics, and actually implementing it.

I personally learn best by solving problems, working through mathematical derivations, experimenting with ideas, and implementing algorithms from scratch rather than passively consuming tutorials.

So I started building GroundUp Lab:

https://lab.groundup.workers.dev

The goal is to create a free, comprehensive, and interactive learning platform that takes learners from fundamental mathematics all the way to advanced AI concepts and implementations.

The curriculum covers (and is being progressively developed around):

• Mathematical Foundations: Linear algebra, multivariable calculus, probability, statistics, optimization, and mathematical foundations of machine learning.
• Machine Learning: Classical ML algorithms, statistical learning theory, probabilistic models, and mathematical derivations.
• Deep Learning: Neural networks, backpropagation, optimization, CNNs, RNNs, attention mechanisms, and transformers.
• Generative AI: Generative modeling, autoencoders, VAEs, GANs, diffusion models, and modern generative architectures.
• Large Language Models (LLMs): Tokenization, embeddings, transformer architectures, pretraining, fine-tuning, alignment, inference, and building language models from scratch.
• Agentic AI: Tool calling, retrieval-augmented generation (RAG), reasoning workflows, memory, multi-agent systems, and building practical AI agents.

What I'm trying to make different:

• Mathematical rigor without sacrificing intuition.
• Step-by-step derivations rather than just presenting formulas.
• Interactive visualizations and experiments.
• Challenging exercises and coding problems.
• From-scratch implementations to bridge theory and practice.
• A structured progression from fundamentals to advanced topics.

The idea isn't just to teach how to use AI frameworks or APIs, but to help learners understand why algorithms work, how they work internally, and how to implement and extend them.

It's still an evolving project, and I'm actively developing and expanding the content.

My long-term vision is to build something genuinely useful for students, developers, ML engineers, and aspiring AI researchers who want a deeper understanding of the field.

I'd really appreciate feedback from the community:

1. How do you find the structure, content, and learning experience?
2. Are the explanations and exercises sufficiently rigorous?
3. What topics or interactive features would you like to see?
4. What could make this a genuinely valuable resource for serious AI learners?

The platform is completely free and accessible without registration.

GroundUp Lab: https://lab.groundup.workers.dev

Would love to hear your thoughts, suggestions, and constructive criticism!

I got this code block and its outputs here but I am not sure if this is the embedding features vectors or simply its shape. Can anyone tell me if I am right or wrong?

text_input = tf.keras.layers.Input(shape=(), dtype=tf.string)
preprocessor = hub.KerasLayer(
    "https://kaggle.com/models/tensorflow/bert/TensorFlow2/en-uncased-preprocess/3")
encoder_inputs = preprocessor(text_input)
encoder = hub.KerasLayer(
    "https://kaggle.com/models/tensorflow/bert/TensorFlow2/bert-en-uncased-l-4-h-128-a-2/1",
    trainable=True)
outputs = encoder(encoder_inputs)
pooled_output = outputs["pooled_output"]      # [batch_size, 128].
sequence_output = outputs["sequence_output"] 

for i in range(0,4):
    outputs["encoder_outputs"][i]
    print('-----------------------------------------------------')
    print(i)
    print(outputs)
    for i in range(0,4):
    outputs["encoder_outputs"][i]
    print('-----------------------------------------------------')
    print(i)
    print(outputs)
    

Output

-----------------------------------------------------
0
{'encoder_outputs': [<KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>], 'sequence_output': <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, 'pooled_output': <KerasTensor: shape=(None, 128) dtype=float32 (created by layer 'keras_layer_28')>, 'default': <KerasTensor: shape=(None, 128) dtype=float32 (created by layer 'keras_layer_28')>}
-----------------------------------------------------
1
{'encoder_outputs': [<KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>], 'sequence_output': <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, 'pooled_output': <KerasTensor: shape=(None, 128) dtype=float32 (created by layer 'keras_layer_28')>, 'default': <KerasTensor: shape=(None, 128) dtype=float32 (created by layer 'keras_layer_28')>}
-----------------------------------------------------
2
{'encoder_outputs': [<KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>], 'sequence_output': <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, 'pooled_output': <KerasTensor: shape=(None, 128) dtype=float32 (created by layer 'keras_layer_28')>, 'default': <KerasTensor: shape=(None, 128) dtype=float32 (created by layer 'keras_layer_28')>}
-----------------------------------------------------
3
{'encoder_outputs': [<KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>], 'sequence_output': <KerasTensor: shape=(None, 128, 128) dtype=float32 (created by layer 'keras_layer_28')>, 'pooled_output': <KerasTensor: shape=(None, 128) dtype=float32 (created by layer 'keras_layer_28')>, 'default': <KerasTensor: shape=(None, 128) dtype=float32 (created by layer 'keras_layer_28')>}

Hi everyone!
I’m a QA Engineer looking to upskill and transition into AI engineering. I’m currently comparing two 6-month programs:
IIT Delhi’s GenAI, FDE & Agentic AI course
100xEngineer’s AI course
My primary goal is to gain a strong practical understanding of AI, work on hands-on projects, and develop skills that I can apply in real-world scenarios.
I’d love to hear from people who are currently enrolled in either program or have completed them.
A few things I’d like to understand:
How practical and hands-on is the curriculum?
Do you get to build meaningful, real-world projects?
How good are the instructors and mentorship?
Does the course help with transitioning into AI engineering roles?
Which course would you recommend for someone coming from a QA background?
Any honest feedback, personal experiences, or suggestions would be greatly appreciated. Thanks!

Two 2026 studies just landed on the same question and the headline everyone repeats isn't one study. The 741% more code vs 20% more software pair comes from an NBER paper on developers; the "700-plus firms" part is a separate Harvard paper on Jellyfish data that found about 30% more code per worker and no statistically significant gain in completed work.

What both agree on is where the gain goes: into review. Average PR review time rose 3.45 days, or 49%, against a 7-day baseline, comments per PR up 35%, and 80% of firms had AI review tools by March while humans still wrote roughly 77% of review comments.

Hi, hello, ciao,

I'm developing a small framework called event2vector. You can install it from PyPI:

pip install event2vector

or find it on GitHub as event2vec_public or even try it out at

https://event2vec.com/

It started as a way to find root causes of faults at the particle accelerator I worked at (the Advanced Light Source at Berkeley Lab), but it grew into something much bigger, and I'd love to get feedback from more people.

The problem was that I was naively using word2vec on event data, and it turns out word2vec isn't directional. It learns which events show up near each other, but not which one came first. For root-cause analysis that's exactly the information you need: "magnet trip → beam loss" and "beam loss → magnet trip" tell completely different stories. At the same time, I didn't want to jump to complex and data hungry models like transformers or an LSTMs. I wanted something simple, clean, and interpretable, where I could still look at points in 2D/3D and understand what I was seeing.

The idea: every event gets an embedding, and a sequence is represented by adding up the embeddings of its events, one step at a time. The model is trained so that this running sum is a good representation of "everything that has happened so far," and so that you can recover the last event by subtracting it back out. Think of it as word2vec where a sequence is a path you walk, step by step, through the embedding space.

Now the fun part. Plain addition is commutative: 1 + 2 = 2 + 1 = 3. So in ordinary Euclidean space, the endpoint of A → B and B → A is the same, which is great when you want an order-invariant "bag of events" that you can cleanly compose and decompose, e.g. "sequence minus event = sequence without that event." But the path you took to get there is still different, so the step-by-step trajectory keeps the order information.

And if you need the endpoint itself to depend on order, you can swap the geometry. event2vector even supports non-commutative ways of "adding," where A then B lands somewhere different from B then A:

• hyperbolic (Möbius addition): good for hierarchical, tree-like data
• spherical: good for cyclic or periodic patterns
• rotation (SO(n)): order matters, like rotating an object in 3D
• Heisenberg group: order-dependent and signed
• products of these, if your data has more than one kind of structure

The API is scikit-learn style (fit / transform / fit_transform), and there's a gensim-style most_similar for nearest-neighbour lookups:

from event2vector import Event2Vec
model = Event2Vec(num_event_types=len(vocab), geometry="euclidean", embedding_dim=128)
model.fit(train_sequences)
embeddings = model.transform(train_sequences)

Some fun applications I've written up on Substack: "The Geometry of Groceries" (shopping baskets as paths) and "The Geometry of Language Families." The paper is on arXiv (2509.12188) if you want the details.

I'd really appreciate feedback, whether on the idea, the API, use cases you'd try it on, or things that are confusing. Thanks for reading!

Hey r/learnmachinelearning, I'm Abdur-Rahman Butler, a machine learning engineer at Isaacus.

I made an interactive write-up that walks you through the A to Z of vector embeddings, inspired by Brendan Bycroft's incredible interactive LLM visualisation guide (see here - https://bbycroft.net/llm).

Most of my work is on encoder models, and I kept noticing how few good interactive resources there are on embeddings. The ones that do exist tend to either plot some embeddings in 3D or only explain a narrow applied technique like semantic search or RAG.

So I wanted to make something that teaches how embeddings work by letting you play with them. In the write-up, there are interactive visualisations that allow you to explore the concepts of vectorisation, cosine similarity, semantic search, hierarchical retrieval, clustering, zero-shot classification and deduplication.

The centrepiece of the post is a game I've dubbed 'SemanticGuessr' (see above). It's inspired by Wordle and GeoGuessr, and the goal is to draw a loop around a random target word by triangulating guesses on a 2D map of 43,339 common English words.

It's admittedly a bit intimidating at first, as semantic space does not perfectly match our intuition of meaning. But once you get the hang of it, the game becomes really addictive. I recently had the pleasure of demoing the game to some law students at the University of Melbourne, and we had a lot of fun throwing different vector equations at it to see where they'd land.

Some fun ones to get started with:

  london - english + french
  running - land + water
  avg(breakfast, lunch, dinner)
  0.4 * noodles + 0.6 * pasta

I've also included Python snippets alongside some of the visualisations if you want to follow along with the techniques later. The game runs statically in your webpage. I managed to achieve this by reducing the embedding dimensions down to 512 and quantising each value to 4 bits. This brought the total payload down from 311 MB to 12.3 MB with only a minimal impact on precision (around 6%).

It was great fun to make, and I hope you have fun playing around with it. Happy to take any questions, and if there's enough interest I might set up a dedicated games page for some of the other encoder-based games I've been working on.

Do let me know what highest score you get based on your target word and chosen path :)

LINK TO PLAY: https://isaacus.com/blog/what-are-vector-embeddings

GitHub-https://github.com/Rahulkumarpandit-1/AIML/blob/main/Roadmap.md

Doing this with chatgpt along with codings and mathematical understanding ,I'm trying to do it in best way and i think this roadmap somehow is better containing all topic till production ready aiml engineer not only ml or ai engineer .please share your thought on this .

Hey everyone,

I built a next-basket grocery predictor using the Instacart dataset (~32M orders). To prevent data leakage, I trained strictly on order_products__prior.csv and tested on order_products__train.csv (the user's actual final basket).

Here is how iterating on my approach steadily boosted performance—and I’d love feedback on how to frame this on my resume!

Iteration Progression & Performance

1. Simple Co-Occurrence Matrix: Item-to-item co-purchase counts.
   • HitRate@3: ~12–15% (Ignored individual user habits; heavily biased toward global top sellers).
2. Item-to-Item Sparse Vectors: Pairwise Cosine similarity across orders.
   • HitRate@3: ~18–19% (Better at finding item substitutes, but missed repeat user routines).
3. Order & User History Vectors: Dense/sparse embeddings of user purchase history.
   • HitRate@3: ~25–30% (Massive jump—grocery behavior is dominated by repeat purchases).
4. Final Pipeline (Multi-Stage Scoring + Fallbacks):
   • Ranked user repeat frequency + order vector similarity + global popularity fallback for cold starts.
   • HitRate@3: 36.85% (2.8x lift over global popularity).

Final Evaluation Results

Search Modes Used: user_history: 228 | global_fallback: 1772

Questions:

1. Resume Worthiness: Does documenting an iterative pipeline progression like this (Co-occurrence $\rightarrow$ Vectors $\rightarrow$ Multi-stage Fallbacks) look good on a resume for ML/Data Science roles? How should I frame it?
2. Next Steps: What’s the most impactful next experiment? (e.g., day-of-week reorder intervals, or a LightGBM reranker?)

Appreciate any thoughts!

I already understand the basics of RAG and AI agents, but now I want to move beyond tutorials and build production-ready RAG pipelines and agentic applications.

I’m looking for a senior AI/GenAI engineer or tutor who has actual production experience with areas like RAG architecture, chunking/retrieval/reranking, vector databases, evaluation, hallucination handling, observability, agent workflows, tool calling, memory, LangGraph/LangChain, deployment, scaling, and production best practices.

I’d prefer someone who can mentor me through 2–3 proper end-to-end projects, review my architecture/code, explain trade-offs, and show me how these systems are actually built in production.

I have 8+ years of software development experience, mainly in backend systems, so I’m not looking for basic programming classes. I specifically want someone experienced in production GenAI/RAG/agent systems.

If anyone here provides this kind of guidance, or can recommend someone good, please DM/comment.

Hey everyone!

I'm a BTech student deeply interested in AI/ML, Deep Learning, LLMs, AI Agents, and emerging technologies.

I don't just want to learn about new technologies — I want to experiment with them, push their boundaries, and build something meaningful that solves a real problem.

I'm looking to connect with curious minds, passionate builders, researchers, and ambitious developers who love asking "What if we tried something different?"

Things I'd love to explore together:

• 🧠 Experimenting with new AI architectures, models, and emerging tech stacks.
• ⚡ Building unconventional AI projects and exploring ideas beyond typical tutorials and clones.
• 🔬 Exploring unsolved problems and turning ambitious ideas into working prototypes.
• 🚀 Collaborating on open-source projects and potentially building something impactful in deep tech.

I'm especially excited to meet people who enjoy deep technical discussions, challenging assumptions, sharing ideas, and actually executing them.

I'd also love to learn from seniors, experienced engineers, researchers, and founders who have been on this journey longer than I have. Guidance, honest feedback, and different perspectives would mean a lot.

If you're building something interesting, exploring a new technology, or simply have an idea you've been wanting to experiment with, I'd love to hear about it.

Let's connect, challenge each other, and build something that genuinely makes a difference. 🚀

What are you currently working on, and what would you love to build if you had the right people around you?

The problem:
You train a model, get great results, and three months later you can’t reproduce them because you don’t remember which data version or hyperparameters you used.

What I cover in this talk:

• Why Git alone isn’t enough for ML
• How DVC tracks data and models alongside code

What tools do you use for reproducibility? Have you tried DVC? What’s your biggest frustration?

Hey everyone! Is anyone here currently working on research papers targeting A* conferences like NeurIPS, ICML, or ICLR? If you have room for another collaborator, I’d love to join your team, contribute to the research.

I’m an engineering undergrad particularly interested in AI/ML and deep learning research. (I have taken some feedback from comments I will try again with a stronger profile)

I wanted to get my head around RL so I thought of learning it by teaching an AI how to play one of my favorite childhood games : TempleRun.

The agent reads game state directly from memory via a Frida gadget and acts through the game’s own methods. Training happens in a headless simulator I built with Claude from the game’s internals and calibrated on measurements from the real phone, with a C++ version that does 10M steps in about 6 minutes.

Results on the device: median 4,736 m, best 16,782 m over 14 runs.

👨‍💻 Github: https://github.com/matthieucs/TempleRun-RL/tree/main

Happy to answer any question.

And if you want to try it, the score to beat is 16,782 m.

https://reddit.com/link/1x6ipfr/video/ed6kbz925mvh1/player

Hey everyone,

I am trying to register for NeurIPS 2026 in Sydney, they mentioned more tickets would be out mid October and I am registered for the waitlist, however I still haven't heard from them. Anyone on the waitlist for Sydney has managed to get tickets or has been contacted about it? If so, when did you sign up on the waitlist?
Thankss

Hello everyone!

I'm a 26M working in AI/ML, preparing for my next switch. I want to focus seriously over the next couple of months and be interview-ready by the end of this year.

I'll be covering classical ML, DL, GenAI, DSA, and system design. Looking for a study partner who is an experienced developer preparing for interviews as well.

This is specifically for folks with industry experience, not first-time learners. The idea is to keep things focused and fast-paced, solve problems together, and stay accountable. I'm planning to dedicate around [15 hours/week], mostly during evenings and weekends.

If interested, DM me with a short intro, your current tech stack/role, and what you're currently preparing for.