Dibri N.

🧠 𝗛𝗼𝘄 𝗱𝗼 𝗟𝗟𝗠𝘀 𝗹𝗲𝗮𝗿𝗻 𝘁𝗼 𝗴𝗲𝗻𝗲𝗿𝗮𝘁𝗲 𝗰𝗼𝗵𝗲𝗿𝗲𝗻𝘁 𝘁𝗲𝘅𝘁 ? The key lies in causal (or masked) attention -> a mechanism that ensures the model only attends to past and present tokens, never the future. 🔍 During training, future words are masked out in the attention matrix. This enforces unidirectional context, for example, while predicting “you” in “Practice makes you better everyday”, the model only sees “Practice” and “makes”. It has no access to “better” or “everyday” yet. This constraint forces the model to learn language autoregressively, one token at a time ..... mimicking the way humans speak and write. This is how LLMs generate fluent, context-aware outputs without cheating. #AI #LLM #Transformers #CausalAttention #DeepLearning #NLP #AutoregressiveModels

14

Okay, I know it's been a while, but welcome back to Part 2 of the Docker series! Now that we’ve built an image, let’s explore some everyday Docker commands: docker build -t myapp . → Builds an image and tags it. docker run -p 3000:3000 myapp → Runs a container, mapping port 3000 on your machine to port 3000 inside the container. docker ps → Lists running containers. docker stop <id> → Stops a container gracefully. docker exec -it <id> sh → Hops inside a running container for debugging. These commands are your “camera controls” for managing container snapshots in real time. But what if you need multiple containers, say, a Node.js app with a MongoDB backend? Enter Docker Compose. Instead of juggling multiple Docker run commands, you define services in a single docker-compose.yml. This helps manage multiple containers easily and ship faster. A key thing to note is that all these are ephemeral. Once you kill the container, that's the end, and you will lose all the data from that container. That's where Docker volumes come up. Much like storage on your system, you can create volumes and attach them as persistent storage to your container. In my next post, we will explore a crucial next step in the Docker series - networking. Hit me up if you wanna see something else. #docker

34

1 Comment

Unleashing the Power of Vector Search at Scale with Milvus Thrilled to share one of the most impactful systems papers from SIGMOD 2021: Milvus: A Purpose-Built Vector Data Management System. In an age where unstructured data is exploding and machine learning models rely heavily on high-dimensional embeddings, Milvus reimagines vector data management. Unlike traditional databases, Milvus treats vectors as first-class citizens, enabling: • Blazing-fast similarity search optimized for CPUs & GPUs • Advanced queries with attribute filtering & multi-vector processing • Dynamic data handling with real-time inserts, deletes, and updates • Cloud-native scalability with distributed architecture and snapshot isolation • Plug-and-play SDKs and REST APIs for developers in Python, Java, Go, and C++ The system outperforms industry benchmarks—up to 2 orders of magnitude faster than alternatives—and already powers image search, drug discovery, recommendation systems, and more. Milvus is open-source and backed by the LF AI & Data Foundation. Explore the repo: https://lnkd.in/e4d4WXqf #AI #MachineLearning #VectorSearch #DatabaseSystems #SIGMOD #Milvus #OpenSource #AIInfrastructure

4

#the_cultural_differences_in_dependency_propagation Many iOS/Swift libraries are intentionally designed with minimal dependencies. This is a cultural difference: - npm/JS: Heavy dependency usage is normal (lodash, moment, etc.) - iOS/Swift: Self-contained libraries are preferred to avoid "dependency hell" Libraries like Alamofire, Kingfisher, SnapKit, SwiftyJSON are genuinely zero-dependency by design. #softwareengineering #research #dependencies #vulnerabilities

1

🚀 Day 33 of 90 Days of Reinforcement Learning Topic: Value Decomposition Networks (VDN) As we continue exploring Multi-Agent Reinforcement Learning (MARL), today we focus on a key idea that enables agents to learn cooperatively while acting independently. 🎯 Value Decomposition Networks (VDN) VDN is one of the earliest and simplest approaches that fits within the Centralised Training, Decentralised Execution (CTDE) framework. 🧠 The Core Challenge in Cooperative MARL In many environments, multiple agents share a single team reward. Examples: Multi-robot coordination Drone swarm navigation Team-based strategy games But this creates a major problem: ⚠ Credit Assignment Problem Which agent contributed how much to the team reward? 💡 The VDN Idea VDN solves this by decomposing the team value function into individual agent values. Instead of learning one huge value function: [ Q_{total}(s,a_1,a_2,...,a_n) ] VDN assumes it can be written as the sum of individual Q-values: [ Q_{total} = Q_1 + Q_2 + ... + Q_n ] Each agent learns its own local Q-function, but training optimises the global team reward. ⚙️ How VDN Works 1️⃣ Each agent has its own Q-network 2️⃣ Individual Q-values are summed together 3️⃣ The summed value forms the team value 4️⃣ The system is trained using the global reward This keeps training centralised but execution decentralised. 📊 Advantages of VDN ✔ Simple and scalable ✔ Enables decentralized policies ✔ Reduces complexity of joint action spaces ✔ Encourages cooperative behavior ⚠️ Limitation VDN assumes the team value is additive. However, real-world cooperation can involve complex interactions between agents that cannot always be represented as a simple sum. This limitation led to more advanced approaches like QMIX, which we will explore next. 🌍 Applications Multi-robot coordination Swarm robotics Traffic control systems Cooperative game AI 🧠 Key Insight VDN shows that complex multi-agent coordination can emerge from simple decompositions. 🤝 Learn together, 🧩 but decompose the value. 🔗 A compilation of my daily RL learning journey is available here: https://lnkd.in/g6QHMFef

8

If anyone is interested in developing their skills in C (Programming Language), a quick thought based on my experience might be helpful. 💬 Here are some tips for developing this skill: 1. First of all, develop a low-level understanding of the data storage( memory model), flow, and operations to be applied to data, when and how to pass data by copy or to pass it by address (pointers) to a calling function, etc. 2. Practice a lot with syntax and try to solve various problems that actually implement some real-world scenarios, like developing a simple game or a software package for handling a minimal database, or a small HTTP server, etc. 3. Learn the use of code debuggers like gdb, build tools like make, and profilers to visualize memory leaks, etc. This really helps in understanding what is taking place underneath the abstract coding template, thus helping in writing clean, manageable and easy to debug code.

18