Everseen

✅ Actively involved in all stages of ML project lifecycle.

𝐄𝐯𝐞𝐫𝐬𝐞𝐞𝐧 is an AI company that empowers end-to-end visibility across the entire supply chain for the biggest retail clients in the world, aiming to  reduce shrink and increase perpetual inventory accuracy using it’s VisualAI platform.

☑ Worked on a theft-prevention system that was showcased at 𝐍𝐞𝐰𝐘𝐨𝐫𝐤 𝐍𝐑𝐅2023, and at numerous demo-sessions that 𝐚𝐭𝐭𝐫𝐚𝐜𝐭𝐞𝐝 3 𝐧𝐞𝐰 𝐜𝐥𝐢𝐞𝐧𝐭𝐬 into wanting the product for their stores. 

☑ 𝐇𝐚𝐧𝐝𝐥𝐢𝐧𝐠 project/tooling 𝐫𝐚𝐦𝐩-𝐮𝐩 phase for new members within the team, successfully reducing the period from 1 𝐦𝐨𝐧𝐭𝐡 𝐭𝐨 𝐥𝐞𝐬𝐬 𝐭𝐡𝐚𝐧 1 𝐰𝐞𝐞𝐤.

☑ Handled 𝐞𝐧𝐝-𝐭𝐨-𝐞𝐧𝐝 engineering and 𝐝𝐞𝐩𝐥𝐨𝐲𝐦𝐞𝐧𝐭 to 5 𝐩𝐢𝐥𝐨𝐭 𝐬𝐭𝐨𝐫𝐞𝐬.

☑ Improved the 𝐢𝐭𝐞𝐫𝐚𝐭𝐢𝐨𝐧 𝐬𝐩𝐞𝐞𝐝 within the team by 𝐚𝐮𝐭𝐨𝐦𝐚𝐭𝐢𝐧𝐠 𝐌𝐋𝐎𝐩𝐬 practices such as Structured Model Experimenting, Resources Monitoring, Model Registry, CI/CD and Jira Integrations.

☑ 𝐎𝐫𝐠𝐚𝐧𝐢𝐳𝐞𝐝 and established a 𝐝𝐨𝐜𝐮𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧 𝐬𝐭𝐫𝐮𝐜𝐭𝐮𝐫𝐞 which enabled us to 𝐫𝐞𝐚𝐜𝐡 > 70% 𝐜𝐨𝐯𝐞𝐫𝐚𝐠𝐞 both on code,tools documentation and custom models tailored for various clients.

☑ Worked on a live camera feed processing pipeline that ran 3 𝐝𝐞𝐞𝐩 𝐥𝐞𝐚𝐫𝐧𝐢𝐧𝐠 𝐦𝐨𝐝𝐮𝐥𝐞𝐬 while achieving 24-25 FPS on a 4K video stream with high QPS rate.

☑ Implemented a 𝐦𝐨𝐧𝐢𝐭𝐨𝐫𝐢𝐧𝐠 𝐩𝐢𝐩𝐞𝐥𝐢𝐧𝐞 𝐟𝐨𝐫 𝐨𝐮𝐫 𝐞𝐝𝐠𝐞 𝐝𝐞𝐩𝐥𝐨𝐲𝐦𝐞𝐧𝐭𝐬 that saved time with hardware requirements and optimisations using Prometheus, Grafana, Kibana and ES.

☑ Actively 𝐩𝐚𝐫𝐭𝐢𝐜𝐢𝐩𝐚𝐭𝐢𝐧𝐠 𝐢𝐧 𝐭𝐡𝐞 𝐥𝐢𝐟𝐞𝐜𝐲𝐜𝐥𝐞 of the current project, providing support to QA, Development and Deployment processes.

☑ 𝐀𝐮𝐭𝐨𝐦𝐚𝐭𝐞𝐝 the multi-gpu 𝐦𝐨𝐝𝐞𝐥 𝐜𝐨𝐧𝐯𝐞𝐫𝐬𝐢𝐨𝐧 and integration with high-throughput Model Serving technologies like Nvidia Triton Server.

Senior Machine Learning Engineer

Neural Bits

✅ Writing the Neural Bits Newsletter to help AI/ML Engineers upskill in their career.
☑ Making AI accessible to a larger general audience by explaining concepts in simple terms.
☑ Sharing insights and practical advice on AI/ML Systems.

Author

Decoding ML

Sharing insights and actionable advice towards building production-ready ML systems.

Co-Founder

HandsOnLLMs

✅ Contributed to a free hands-on course on end-to-end LLMops.

Worked alongside 𝐏𝐚𝐮 𝐋𝐚𝐛𝐚𝐫𝐭𝐚 𝐁𝐚𝐣𝐨 𝐚𝐧𝐝 𝐏𝐚𝐮𝐥 𝐈𝐮𝐬𝐳𝐭𝐢𝐧 into developing this end-to-end course to help students 𝐛𝐮𝐢𝐥𝐝 𝐚 𝐜𝐨𝐦𝐩𝐥𝐞𝐭𝐞 𝐋𝐋𝐌 𝐚𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧 while following the 𝐛𝐞𝐬𝐭 𝐩𝐫𝐚𝐜𝐭𝐢𝐜𝐞𝐬 both in software development, model deployment and MLOps integrations.

☑ Implemented the EDA stage on LLM fine-tuning dataset.
☑ Implemented the LangChain logic and modules that connected the QDrant vector database to inference pipeline and model registry.
☑ Worked on the training/fine-tuning pipeline and prompt monitoring using CometML.
☑ Provided support and approved Pull Requests.
☑ Implemented and documented best practices on Prompt Templates and LLM workflow.

Check the course here: http://bit.ly/3Rxjyvp

Co Author

IVFuture

✅ Worked on on a suite of tools including Generative AI, LLM’s and Vision Models.

𝐈𝐕𝐅𝐮𝐭𝐮𝐫𝐞’𝐬 mission is to transform common businesses, communities and people’s needs into intelligent and innovative software solutions, to simplify life through scalable technology.

☑ Implemented a 𝐝𝐞𝐦𝐨 for virtual try-on fashion tool called 𝐓𝐀𝐈𝐒, which was presented to investors and attracted interest from various fashion providers across Romania.

☑ Implemented a CV solution, that was able to accurately showcase over 25 𝐛𝐨𝐝𝐲 𝐦𝐞𝐚𝐬𝐮𝐫𝐞𝐦𝐞𝐧𝐭𝐬 𝐢𝐧 3𝐃 using 2D cameras, with an 𝐞𝐫𝐫𝐨𝐫-𝐫𝐚𝐭𝐞 𝐨𝐟 5-10% while using cheap hardware, <700$ 𝐩𝐞𝐫 𝐬𝐞𝐭𝐮𝐩, considering industry available setups 𝐞𝐱𝐜𝐞𝐞𝐝 10.000$.

☑ Developed and integrated an 𝐋𝐋𝐌 13𝐁 𝐜𝐡𝐚𝐭 𝐚𝐠𝐞𝐧𝐭, fine-tuned on specific descriptions that was used by the team to automatically 𝐥𝐚𝐛𝐞𝐥 𝐡𝐮𝐧𝐝𝐫𝐞𝐝𝐬 𝐨𝐟 𝐩𝐫𝐨𝐝𝐮𝐜𝐭𝐬.

☑ Fine-tuned 𝐒𝐭𝐚𝐛𝐥𝐞 𝐃𝐢𝐟𝐟𝐮𝐬𝐢𝐨𝐧1.5 and tailored it to specific product generation use-case.

☑ Worked on a solution for 𝐓𝐓𝐒 𝐚𝐧𝐝 𝐒𝐓𝐓 and exposed it as an API, which was able to accurately 𝐜𝐥𝐨𝐧𝐞 𝐯𝐨𝐢𝐜𝐞𝐬 𝐟𝐫𝐨𝐦 𝐚 𝐬𝐡𝐨𝐫𝐭 5𝐬𝐞𝐜 𝐚𝐮𝐝𝐢𝐨 𝐜𝐥𝐢𝐩 and synthesize text-to-speech and speech-to-text.

☑ Worked on a 𝐑𝐀𝐆 𝐚𝐠𝐞𝐧𝐭, that was able to ingest document context and provide assistant-like answers on user queries.

Machine Learning Consultant - Generative AI

Odeen Software

✅ Worked on Flowstate, a Computer Vision solution developed for 𝐔𝐑𝐁𝐍𝐒𝐔𝐑𝐅 𝐌𝐞𝐥𝐛𝐨𝐮𝐫𝐧𝐞, 𝐀𝐮𝐬𝐭𝐫𝐚𝐥𝐢𝐚, that generates 𝐬𝐨𝐜𝐢𝐚𝐥-𝐦𝐞𝐝𝐢𝐚 𝐫𝐞𝐞𝐥𝐬 𝐚𝐧𝐝 𝐬𝐡𝐨𝐫𝐭𝐬 for park attendees.

𝐎𝐝𝐞𝐞𝐧 is a company that provides IT services, staff augmentation and SASS solutions on various technology stacks, including Machine Learning, Web Development and more.

☑ Implemented a 𝐦𝐮𝐥𝐭𝐢-𝐜𝐚𝐦𝐞𝐫𝐚 𝐭𝐫𝐚𝐜𝐤𝐢𝐧𝐠 feature using SOTA Centroid ReID to track and re-identify person detections in multiple camera views.

☑ Integrated 𝐅𝐀𝐈𝐒𝐒 𝐕𝐞𝐜𝐭𝐨𝐫 𝐃𝐚𝐭𝐚𝐛𝐚𝐬𝐞 to store track embeddings and perform ReID searching for similar tracks in a batch fashion.

☑ Used 𝐃𝐞𝐞𝐩𝐅𝐚𝐜𝐞 to detect and group track detections with face detections, and human pose prediction to filter accurate poses to consider when generating reels.

☑ Worked on the video streaming workflow, offline batch tracking and edge integration with Viso.AI.

Machine Learning Consultant

Upwork

💎 Top Rated • 💯 Job Success Rate • ⭐⭐⭐⭐⭐ Reviews

✅ Developed plug-and-play ML/CV modules.

☑ Client had over 50𝐤 𝐫𝐞𝐜𝐞𝐢𝐩𝐭𝐬 from various stores, and needed to automate the process of analyzing these receipts. I’ve implemented a 𝐌𝐋 𝐬𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐬𝐚𝐯𝐢𝐧𝐠 𝐮𝐩 𝐭𝐨 80% of the time used to detect, decode and organise these receipts by their QR code metadata.

☑ Client wanted a 𝐄𝐝𝐮𝐓𝐞𝐜𝐡 𝐰𝐞𝐛 𝐩𝐥𝐚𝐭𝐟𝐨𝐫𝐦 that allows parents to create quizz tests for their children based on an uploaded document (.pdf, .docx). I’ve implemented a full-stack web application with included ML components which loaded a document, applied ETL, generated quizz test and construct the UI view.

☑ Client wanted a CV plugin that would detect various icons from a phone screen, classify them and automatically create app testing workflows. Using template matching, pyramid-detection and super-resolution GAN’s, I’ve managed to 𝐨𝐩𝐭𝐢𝐦𝐢𝐬𝐞 𝐚𝐧𝐝 𝐚𝐮𝐭𝐨𝐦𝐚𝐭𝐞 𝐜𝐥𝐨𝐬𝐞 𝐭𝐨 100% on a few use-cases, and around 30-40% 𝐨𝐧 𝐭𝐡𝐞 𝐫𝐞𝐬𝐭 of the use-cases required.

☑ 𝐂𝐨𝐧𝐬𝐮𝐥𝐭𝐞𝐝 on various Computer Vision topics and project ideas.

Top Rated Machine Learning Engineer

✅ Developed and deployed CV/ML modules into existing API's.

☑ Client wanted a CV solution that 𝐩𝐫𝐨𝐜𝐞𝐬𝐬𝐞𝐬 𝐬𝐩𝐨𝐫𝐭𝐬 𝐠𝐚𝐦𝐞𝐬 𝐚𝐧𝐝 𝐬𝐞𝐧𝐝𝐬 𝐧𝐨𝐭𝐢𝐟𝐢𝐜𝐚𝐭𝐢𝐨𝐧𝐬 𝐰𝐡𝐞𝐧𝐞𝐯𝐞𝐫 𝐭𝐡𝐞 𝐬𝐜𝐨𝐫𝐞 𝐜𝐡𝐚𝐧𝐠𝐞𝐬. whenever the score changes. I’ve applied smart-template matching, targeted motion detection and OCR to extract the team names, scores and send a push message whenever the score changed.

☑ Client wanted a CV solution that scans documents for hand signatures, identifies faulty ones and groups them in a specific structure. Solution was based on deep learning and OCR post-processing, deployed as a docker ML service which helped the client to 𝐬𝐩𝐞𝐞𝐝-𝐮𝐩 𝐭𝐡𝐞 𝐩𝐫𝐨𝐜𝐞𝐬𝐬 𝐛𝐲 𝐚 3𝐱 𝐟𝐚𝐜𝐭𝐨𝐫, relying far less on Humans-in-the-Loop activity.

☑ Client wanted a project concept report on how to apply custom texture from an image onto a 3D model. I’ve researched and planned a workflow that included Object Detection, Instance Segmentation and UV mapping.

Machine Learning Engineer

Elektrobit

✅ Developed multiple Computer Vision solutions and deployed them on edge devices.

𝐄𝐥𝐞𝐤𝐭𝐫𝐨𝐛𝐢𝐭 is key supplier of embedded software solutions for the automotive industry.

☑ Worked on a 𝐣𝐨𝐢𝐧𝐭-𝐩𝐫𝐨𝐣𝐞𝐜𝐭 𝐰𝐢𝐭𝐡 𝐁𝐌𝐖 𝐌𝐮𝐧𝐢𝐜𝐡 𝐟𝐨𝐫 𝐄𝐏𝐈 (European Processor Initiative 2020) and deployed 𝐚 𝐜𝐚𝐫 𝐝𝐞𝐭𝐞𝐜𝐭𝐢𝐨𝐧 𝐚𝐧𝐝 𝐩𝐚𝐭𝐡-𝐩𝐥𝐚𝐧𝐧𝐢𝐧𝐠 𝐬𝐨𝐥𝐮𝐭𝐢𝐨𝐧 on an Nvidia Jetson AGX board, placed in a real 𝐁𝐌𝐖 𝐱5 𝐭𝐞𝐬𝐭 𝐜𝐚𝐫, which was able to detect and map the environment around the test vehicle using video feed from 2xIntelCameras and 1xLidarSensor.

☑ 𝐒𝐮𝐜𝐜𝐞𝐬𝐬𝐟𝐮𝐥𝐥𝐲 𝐩𝐮𝐛𝐥𝐢𝐬𝐡𝐞𝐝 𝐚 𝐬𝐜𝐢𝐞𝐧𝐭𝐢𝐟𝐢𝐜 𝐩𝐚𝐩𝐞𝐫 titled GFPNet, under the supervision of the Head of AI @Elektrobit Romania, at the 𝐈𝐄𝐄𝐄 𝐑𝐨𝐛𝐨𝐭𝐢𝐜𝐬 𝐚𝐧𝐝 𝐀𝐮𝐭𝐨𝐦𝐚𝐭𝐢𝐨𝐧 𝐋𝐞𝐭𝐭𝐞𝐫𝐬 2020, within the Machine Learning and Robotics field that studied the shape reconstruction of occluded 3D objects.

☑ Generated synthetic data using 𝐂𝐚𝐫𝐥𝐚𝐒𝐢𝐦𝐮𝐥𝐚𝐭𝐨𝐫 (𝐔𝐄4) to train deep neural networks for specific autonomous driving scenarios, improving the accuracy of certain prediction.

☑ Worked on development and optimisation of a vehicle direction and position classifier neural network, integrated directly on the Renesas 𝐑-𝐂𝐚𝐫-𝐇3𝐄 𝐜𝐡𝐢𝐩 (𝐒𝐨𝐂), further deployed to one of the clients test car.

☑ Worked on a 𝐦𝐨𝐝𝐞𝐥 𝐜𝐨𝐧𝐯𝐞𝐫𝐬𝐢𝐨𝐧 𝐚𝐧𝐝 𝐝𝐞𝐩𝐥𝐨𝐲𝐦𝐞𝐧𝐭 𝐩𝐢𝐩𝐞𝐥𝐢𝐧𝐞 for edge devices, that allowed a model to be ported in Python/C++ with no further intervention, 𝐬𝐩𝐞𝐞𝐝𝐢𝐧𝐠 𝐮𝐩 𝐭𝐡𝐞 𝐩𝐫𝐨𝐜𝐞𝐬𝐬 𝐛𝐲 𝐨𝐯𝐞𝐫 50%.

✅ Researched computer vision topics, mainly targeted towards autonomous driving scenarios.

☑ Researched 𝐇𝐲𝐝𝐫𝐚𝐍𝐞𝐭𝐬 for 𝐚𝐮𝐭𝐨𝐦𝐨𝐭𝐢𝐯𝐞 𝐯𝐢𝐬𝐢𝐨𝐧 𝐭𝐚𝐬𝐤𝐬, using ResNet (50, 100) encoder backbones and multiple prediction heads (classification, 3D bounding-box, object detection and orientation), the research 𝐫𝐞𝐩𝐨𝐫𝐭 𝐛𝐞𝐢𝐧𝐠 𝐟𝐮𝐫𝐭𝐡𝐞𝐫 𝐮𝐬𝐞𝐝 to develop, train and deploy a model on a small 𝐟𝐨𝐮𝐫-𝐰𝐡𝐞𝐞𝐥𝐞𝐝 𝐫𝐨𝐛𝐨𝐭.

☑ Researched 𝐏𝐨𝐢𝐧𝐭𝐂𝐥𝐨𝐮𝐝 𝐬𝐞𝐠𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧 𝐟𝐫𝐨𝐦 𝐃𝐞𝐩𝐭𝐡 using a X-Box KinectSensor, feature that was further tested in a stack of models 𝐨𝐩𝐞𝐫𝐚𝐭𝐢𝐧𝐠 𝐨𝐧 𝐚 𝐟𝐥𝐲𝐢𝐧𝐠 𝐝𝐫𝐨𝐧𝐞 that followed QR markers on the floor.

☑ Worked on a model-development dashboard that 𝐚𝐥𝐥𝐨𝐰𝐞𝐝 𝐮𝐬𝐞𝐫𝐬 𝐭𝐨 𝐮𝐩𝐥𝐨𝐚𝐝 𝐝𝐚𝐭𝐚, 𝐛𝐮𝐢𝐥𝐝 𝐭𝐡𝐞 𝐦𝐨𝐝𝐞𝐥, 𝐬𝐜𝐡𝐞𝐝𝐮𝐥𝐞 𝐚 𝐭𝐫𝐚𝐢𝐧𝐢𝐧𝐠 𝐣𝐨𝐛, inspect metrics and download artifacts on specific targets (.pt, .onnx, .trt, .gzip).

Junior Machine Learning Engineer

Universitatea Transilvania din Brașov

✅ Teaching 𝐢𝐧𝐭𝐞𝐫𝐦𝐞𝐝𝐢𝐚𝐭𝐞 programming concepts and intro to 𝐦𝐚𝐜𝐡𝐢𝐧𝐞 𝐥𝐞𝐚𝐫𝐧𝐢𝐧𝐠.

☑ Java OOP, Python, Git
☑ Data Structures and Algorithms, Graphs
☑ Artificial Neural Networks
☑ Supervised and unsupervised learning
☑ House Price Prediction
☑ Activation Functions
☑ Hand Digits Recognition using Computer Vision and Deep Learning

Teaching Assistant

Siemens

✅ Platform to manage/schedule an industrial process workflow.

𝐒𝐢𝐞𝐦𝐞𝐧𝐬 𝐂𝐨𝐫𝐩𝐨𝐫𝐚𝐭𝐞 𝐓𝐞𝐜𝐡𝐧𝐨𝐥𝐨𝐠𝐲 is a strategic partner to Siemens operative units. It provides important services along the entire value chain – from research and development to production and quality assurance, as well as optimized business processes.

☑ 𝐏𝐥𝐚𝐧𝐧𝐞𝐝 𝐭𝐡𝐞 𝐜𝐨𝐦𝐩𝐨𝐧𝐞𝐧𝐭𝐬 for an app that would allow users to inspect and manage stock for a potato-chips factory.

☑ Implemented the 𝐬𝐞𝐜𝐮𝐫𝐢𝐭𝐲 𝐥𝐚𝐲𝐞𝐫 for admin, observer, user with different functionalities for each category.

☑ 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝 𝐭𝐡𝐞 𝐟𝐮𝐥𝐥-𝐬𝐭𝐚𝐜𝐤 𝐥𝐨𝐠𝐢𝐜, communications between components and frontend dashboard.

☑ 𝐖𝐨𝐧 3’rd place amongst over 10 projects presented.

Student Internship

Hard work always pays off, be consistent!

I'm a Senior Machine Learning Engineer with a keen interest in developing AI/ML solutions for real world problems and helping others get started on their Machine Learning Journey.

Let's connect @:
📘 https://medium.com/@alexandrurazvant
✉️ alexandrurazvant@gmail.com
🌐 https://www.neuraleaps.com

Alex Razvant

Want to learn about Agents, MCP, Multimodal AI, and LLMOps?

Miguel Otero and I have released an open-source course where we build an Multimodal Agent that can understand videos, step by step.

The project idea is simple: 𝐘𝐨𝐮 𝐮𝐩𝐥𝐨𝐚𝐝 𝐚 𝐯𝐢𝐝𝐞𝐨, 𝐚𝐧𝐝 𝐭𝐡𝐞𝐧 𝐜𝐡𝐚𝐭 𝐰𝐢𝐭𝐡 𝐢𝐭..

However, there are many complex challenges, underlying this simple idea.

Some of them are:
- How to build and debug MCP Servers in Python
- Understanding Multimodal Ingestion (video, audio, text, images)
- Designing efficient FastAPI APIs, Background Tasks
- Tool Calling / Router Agents from scratch, in Python
- Understanding Vision Language Models (VQA), Audio Transcription Models (STT)
- How to connect APIs (FastAPI) with UIs (React JS)

Throughout the course,  we explain each module with an general audience pace in mind.

We aimed for it to be easy to follow, easy to understand.

However, we still kept it technical enough.

You don't have to register or be an AI Expert to take this course. It's free.

The course lessons split:
1/ Course Overview
🔗 https://lnkd.in/dm73KT_i

2/ Understand Multimodal Pipelines
🔗  https://lnkd.in/dmn_RBfm

3/ Advanced FastAPI and Pydantic (extra)
🔗  https://lnkd.in/drpKtPFD

4/ Understand the MCP Protocol (extra)
🔗  https://lnkd.in/dJzNp8mH

5/ Build an MCP Server for Multimodal Ingestion
🔗  https://lnkd.in/d33Rsm4e

6/ Building a Tool Calling Agent from Scratch
🔗  https://lnkd.in/dDz6-zZU

7/ Building the full-stack (API, Agent, UI) Application
🔗 https://lnkd.in/dJezq4ry 

8/ Kubrick: The Multimodal Agent Round-up
🔗 https://lnkd.in/drZWiBdT 

Find the GitHub Repository here (give us a ⭐ ):
🔗 https://lnkd.in/dudc7BZS


Tech Stack:
- FastAPI, React JS, FastMCP, MCP Inspector, Docker Compose
- LLMOps with Opik (by @Comet)
- Multimodal Processing with @Pixeltable
- LLMs, VLMs and STT (Speech To Text) AI Models.

What you'll learn as a result:
- Build an MCP Server
- Build an API in Python with FastAPI
- Add LLM/Agent observability
- Process video/audio multimodal data.
- Connect multiple components into an AI System

Have fun learning & building!
✌️

Senior AI Engineer | Author @ NeuralBits | Helping engineers understand, build, and master AI.

CNNs remember where. ViTs remember what  

In a majority of Computer Vision models, the feature extractors (i.e, backbone networks) were built either as CNN encoders, ResNets, or Pyramid Networks.

Regardless of how large the Backbone is, CNNs are not that good at learning full-image context, due to how Receptive Fields work.

```
In deep learning, a receptive field is the specific area of the input data that influences the calculation of a single output feature or neuron in a CNN layer. 
```

1/ CNNs have inductive biases baked into their design
2/ Local receptive fields, hard to scale to High-Res images.
3/ Hierarchical feature extraction
4/ This can be improved, but at the cost of the model's depth

In the top section of the attached image, the `blue-square trace represents a receptive field from High-Level features onto Low-Level features`.

The red ❌  signs represent the feature regions that are not covered by the Receptive Field.

Thus, with CNNs, a larger image context is left out.

---

ViTs, on the other hand, see an image as a sequence of patches and mix them globally through self-attention. 

When feeding an image to a transformer, we first split it into patches of NxN pixels.
Each patch receives a positional encoding vector.
The resulting embedding vector is passed through the Transformer layers.

That makes Transformers:
1/ Permutation-invariant, positional embeddings are required.
2/ Focus on learning global + local level features 
3/ Adversarial Robustness (due to global-context, can spot tinkered features)
3/ Attention Mechanism over patches is computed in Many-to-Many order.
4/ Better for tasks that require image-wide context.

To summarize:
CNNs are limited in capturing global context due to their Receptive Fields.
ViTs compute relationships with and between each patch in the image.

CNNs are better for locality-focused tasks, e.g, Object Detection.
ViTs are better for context-focused tasks, e.,g VQA.

♻️ Reshare and let others learn this too.
Follow me to learn more about AI Engineering and production-ready AI Systems!

"What should I know about NVIDIA AI Stack?"

Here's my answer, tailored for those starting out in AI regarding NVIDIA's ecosystem.

𝗧𝗵𝗲 𝗘𝗰𝗼𝘀𝘆𝘀𝘁𝗲𝗺
NVIDIA doesn't just build the GPUs that power a large chunk of AI Infrastructure.

They've built a full end-to-end ecosystem.
> 𝙃𝙖𝙧𝙙𝙬𝙖𝙧𝙚: All the architectures and iterations (Turing, Ada, Hopper, Blackwell, etc.)
> 𝙎𝙤𝙛𝙩𝙬𝙖𝙧𝙚: CUDA, cuDNN, TensorRT, Triton, NeMo, Dynamo, and more.

This stack powers everything from training LLMs to deploying models at the edge, across various fields (Robotics, Vision, Language, Speech, Agentic and Embodied AI).

But for a beginner, these are too many, each with its place in the end-to-end AI workflow.
It's easy to get lost.

So, here's my advice, split into 3 categories:
1/ General Important Details
2/ Engineering Advice
3/ Software Stack

𝗚𝗲𝗻𝗲𝗿𝗮𝗹 𝗜𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝘁 𝗗𝗲𝘁𝗮𝗶𝗹𝘀
First, I recommend that you learn at a very high level the GPU components.

This will get you started in understanding the hardware black box and differentiating between various GPU/DSA architectures.

Learn about:
1. GPU Cores
What are they? What's the difference between a CUDA Core and a Tensor Core?

2. Memory Hierarchy
Differentiate between VRAM, SRAM, and Registers. This will open doors to understanding FlashAttention, which is a key optimization in LLMs.

3. Precision & Data Types
The majority of LLMs are trained in FP32 or Mixed (FP32/FP16). For Inference, FP16/BF16,  FP4. This will also help you understand the quantization data types.

𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗔𝗱𝘃𝗶𝗰𝗲
These will help you understand how to work more efficiently with NVIDIA's hardware and software stack.

1. Learn to read a GPU Cheatsheet (details about a GPU's performance)
2. Learn to use the Framework Compatibility Matrix (mandatory for SWEs, AIEs)
3. Learn to use NVIDIA's pre-built containers (built in robust, isolated environments)

𝗧𝗵𝗲 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗦𝘁𝗮𝗰𝗸
We have a lot on this layer, but for starters, just learn what each of these does:

1. 𝘊𝘰𝘳𝘦 > CUDA & cuDNN, the backbone for deep learning, both training and inference.
2. 𝘋𝘢𝘵𝘢 𝘗𝘳𝘰𝘤𝘦𝘴𝘴𝘪𝘯𝘨 > DeepStream for real-time video pipelines, cuDF for Dataframes on GPU.
3. 𝘐𝘯𝘧𝘦𝘳𝘦𝘯𝘤𝘦 > TensorRT/LLM for optimizing models, Triton, and Dynamo for deployment.
4. 𝘎𝘦𝘯𝘈𝘐 > Nemotron Models, NeMo Framework to create, customize, and deploy GenAI models.
5. 𝘌𝘯𝘵𝘦𝘳𝘱𝘳𝘪𝘴𝘦 > NIM for batteries-included GenAI deployments. Riva for Speech.
6. 𝘌𝘥𝘨𝘦 𝘈𝘐 > Jetson Xavier, DGX Spark, Orin platforms.
7. 𝘚𝘤𝘢𝘭𝘪𝘯𝘨 > K8S GPU Operator and KAI Scheduler for GPU resource management at scale.

---
There are a few more, but this is a solid start.

In the end, if you spend a few hours reading through these, you'll get a good overview of what's out there.

♻️ Share this post, and research it later.

Microsoft

Software Engineer II

NeoSage

NeoSage is a technical deep-dive newsletter for engineers, solopreneurs, and AI builders who want to develop in-depth intuition on all things AI, from how LLMs work to how to architect agentic systems.

This is where you’ll owl-ways get the insights to ride the AI wave skillfully.

Founder

Amazon Web Services (AWS)

Software Development Engineer II

Adobe

Member Of Technical Staff 2

Member Of Technical Staff

Amazon

Software Development Engineer

Worked on building working prototype(UI/UX development based on provided designs and workflow) of a project in ideation - comicBlast, the project was showcased in Adobe MAX sneaks 2020.

Experience Developer Intern

DMs might get missed, for collabs write to me at: collab.shivanivirdi@gmail.com

Hello 👋

I’m a Software Engineer passionate about solving complex problems and creating innovative solutions that enhance user experiences.

Things I talk about on LinkedIn:
- Artificial Intelligence and LLMs
- Software Engineering and Clean Code
- Productivity Hacks and Career Growth
- Insights from Building LLM-Powered Products

📲 If this resonates with you, let’s connect!

---

🎯 I’m an experienced Software Engineer with a creative mindset and a knack for building impactful solutions. My journey spans working on full-stack development, delivering unique user-facing features, to backend engineering, tackling distributed systems that process large-scale data.

🚀 I thrive on creating value for users by crafting elegant solutions to challenging problems, leveraging cutting-edge technologies, and delivering seamless experiences. My passion lies in blending technical expertise with creativity to build products that make a difference.

💻 Beyond coding, I’m dedicated to sharing practical insights to empower engineers, foster productivity, and drive growth, both in careers and life.

🌍 I aim to use technology as a force for positive change, building tools and systems that create meaningful impact.

🔍 If you’re looking to connect with someone who shares a passion for innovation, engineering excellence, and personal growth, feel free to reach out.

📲 Let’s connect here on LinkedIn or explore more about my journey through my posts!

Shivani Virdi

AI engineering isn't MCP.
AI engineering isn't RAG.
AI engineering isn't agents.
AI engineering isn't fine-tuning.
AI engineering isn't vector stores.

AI engineering is the disciplined practice of turning these components into one cohesive system.

It starts by understanding how each layer functions and connects.

1. 𝗧𝗵𝗲 𝗖𝗼𝗿𝗲 𝗨𝗻𝗶𝘁: 𝗧𝗵𝗲 𝗟𝗟𝗠
↳ Think of it as a powerful, but stateless, processing unit for language.

↳ Its job is to execute instructions based on the context you provide.

↳ Your job is to select the right model for the task's complexity and constraints.

2. 𝗧𝗵𝗲 𝗖𝗼𝗻𝘁𝗿𝗼𝗹 𝗦𝗶𝗴𝗻𝗮𝗹: 𝗣𝗿𝗼𝗺𝗽𝘁𝘀

A prompt is a runtime instruction, not just a question.

In any serious system, prompts require a lifecycle:
→ Versioning: Treat them like code in Git.
→ Testing: Unit and regression tests to prevent breaks.
→ Registry: A central place to manage and deploy them.

You don't YOLO prompts into production.

3. 𝗧𝗵𝗲 𝗦𝗽𝗲𝗰𝗶𝗮𝗹𝗶𝘀𝗮𝘁𝗶𝗼𝗻 𝗟𝗮𝘆𝗲𝗿𝘀: RAG and Fine-Tuning

These are your two primary methods for adapting the base model. 

They solve different problems.

→ RAG (Retrieval-Augmented Generation): 
• Use this to inject external knowledge. 
• It grounds the model in facts, providing it with a scalable, up-to-date knowledge base. 
• It’s for when you need accuracy and attribution.

→ Fine-Tuning: 
• Use this to teach new behaviour. 
• It modifies the model’s weights to alter its style, tone, format, or learn a specific function.
• It's expensive to perform and maintain

4. 𝗧𝗵𝗲 𝗗𝗮𝘁𝗮 𝗙𝗼𝘂𝗻𝗱𝗮𝘁𝗶𝗼𝗻
This underpins both RAG and fine-tuning. 

↳ Your system is only as good as its data pipeline. 

↳ This means robust processes for sourcing, cleaning, chunking, and vectorizing data for retrieval, and curating high-quality examples for tuning.

5. 𝗧𝗵𝗲 𝗦𝘁𝗮𝘁𝗲 𝗟𝗮𝘆𝗲𝗿: 𝗠𝗲𝗺𝗼𝗿𝘆
LLMs are stateless. 

Memory is the layer you build to give your system context, allowing it to track conversation history, user preferences, or task progress. 

This is what turns a single-shot tool into a coherent application.

6. 𝗧𝗵𝗲 𝗙𝗲𝗲𝗱𝗯𝗮𝗰𝗸 𝗟𝗼𝗼𝗽: 𝗢𝗯𝘀𝗲𝗿𝘃𝗮𝗯𝗶𝗹𝗶𝘁𝘆 & 𝗘𝘃𝗮𝗹𝘀

If you can't trace a decision from input → prompt → RAG result → LLM output, you're flying blind.

↳ Observability is your instrumentation. 
↳ Evals are your CI/CD pipeline for system quality, catching regressions in behaviour, not just code.

7. 𝗧𝗵𝗲 𝗖𝗼𝗻𝘀𝘁𝗿𝗮𝗶𝗻𝘁: 𝗖𝗼𝘀𝘁, 𝗟𝗮𝘁𝗲𝗻𝗰𝘆 & 𝗔𝗰𝗰𝘂𝗿𝗮𝗰𝘆
The fundamental engineering triangle. 

↳ Every architectural choice is a tradeoff. 
↳ Using a massive model gives you accuracy but costs more in latency and dollars. 
↳ A smaller, local model does the opposite. 
↳ The goal isn't to maximise one, but to engineer the optimal balance for your specific use case.

The hype is about the models.
The work is in the systems.

Stop chasing shiny new frameworks. 
Master how the fundamentals connect.

♻️ Repost this to help your network upskill

Engineering @ Microsoft | Building GenAI Systems | Creator of NeoSage | 70K+ Learn AI Engineering with Me

LLM fine-tuning is one of the key skills in AI product development.
This is the guide I wish I had when I started.

It’s the difference between constantly tweaking prompts and building a model that behaves exactly how your product needs it to.

I wrote a two-part deep dive that takes you from strategy to execution.

𝗣𝗮𝗿𝘁 𝟭: 𝗧𝗵𝗲 "𝗪𝗵𝘆" 𝗮𝗻𝗱 "𝗪𝗵𝗲𝗻"
Covers the strategy behind fine-tuning. When to use it and when not to.
You’ll learn:

• 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝘃𝘀. 𝗪𝗲𝗶𝗴𝗵𝘁𝘀
  Prompting and RAG inject context temporarily.
  Fine-tuning changes how the model 𝘵𝘩𝘪𝘯𝘬𝘴.
  
• 𝗚𝗿𝗲𝗲𝗻 𝗙𝗹𝗮𝗴𝘀
  Use fine-tuning when you need:
  - Reliable structured output (like strict JSON) 
  - Task-specific reasoning (e.g., complex taxonomies), 
  - Domain-native behaviour (not just facts) 
  - Multilingual capability transfer, 
  - Distilling SOTA large model into cheaper models
  
• 𝗥𝗲𝗱 𝗙𝗹𝗮𝗴𝘀
  Avoid fine-tuning when:
  - Your data changes often 
  - You lack clean, labelled examples 
  - You need fast iteration or dynamic control
  
𝗣𝗮𝗿𝘁 𝟮: 𝗧𝗵𝗲 𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝗣𝗹𝗮𝘆𝗯𝗼𝗼𝗸
Covers how to fine-tune well, without breaking your model.

You’ll learn:
• 𝗧𝗵𝗲 𝗙𝗶𝗻𝗲-𝗧𝘂𝗻𝗶𝗻𝗴 𝗟𝗼𝗼𝗽
  - Define the task → Curate data → Train → Evaluate → Refine.
  - Don’t aim for perfection in one go.
  - Aim to build an MVM (Minimum Viable Model) that fails 𝘪𝘯𝘧𝘰𝘳𝘮𝘢𝘵𝘪𝘷𝘦𝘭𝘺.
  
• 𝗗𝗮𝘁𝗮 𝗖𝘂𝗿𝗮𝘁𝗶𝗼𝗻
  - 1,000 clean examples > 50,000 noisy ones.
  - Your dataset is the source code for your model’s new behaviour.
  
• 𝗠𝗲𝘁𝗵𝗼𝗱𝘀 & 𝗧𝗿𝗮𝗱𝗲-𝗼𝗳𝗳𝘀
  - Full SFT: High power, high cost 
  - PEFT (LoRA/QLoRA): Lightweight, good for most cases 
  - DPO: Best for alignment and preferences
  
• 𝗠𝗼𝗱𝗲𝗿𝗻 𝗘𝘃𝗮𝗹𝘂𝗮𝘁𝗶𝗼𝗻
  Validation loss isn’t enough Use LLM-as-a-Judge, human review, and behaviour tests
  
• 𝗥𝗶𝘀𝗸 𝗠𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁
  Covers how to avoid:
  - Catastrophic forgetting 
  - Safety collapse 
  - Bias amplification 
  - Mode collapse
  
Fine-tuning isn’t a checkbox.
It’s a permanent change to model behaviour. 
Treat it with care.

𝗥𝗲𝗮𝗱 𝘁𝗵𝗲 𝗳𝘂𝗹𝗹 𝗶𝘀𝘀𝘂𝗲𝘀:
• Part 1: The Strategy → https://lnkd.in/gfDATWDe
• Part 2: The Execution Playbook → https://lnkd.in/g-hM7-fc
  
♻️ Repost to share with your network.
➕ Follow Shivani Virdi for more.

Fine-tuning LLMs

I taught myself AI engineering as a software engineer, and it's the best career move. Here's how I'd do it all over again.

Just the path that builds real skill, fast.
Here’s exactly where I’d start (and how I’d go deep):

𝗦𝘁𝗲𝗽 𝟬: Prerequisites You Can’t Skip
Build the intuition that’ll serve you forever.

→ Deep Learning Specialisation by Andrew Ng https://lnkd.in/gwqSPS4J

→ “Deep Learning” by Ian Goodfellow et al https://lnkd.in/grDi7rWE

𝗦𝘁𝗲𝗽 𝟭: Understand LLMs First — Before You Build
Most people skip this. Don’t.

→ Intro for busy users: https://lnkd.in/gg-NYzPe (Karpathy)

→ Deep dive into LLMs: https://lnkd.in/gCbqG56i (Karpathy)

→ The Core Paper: “Attention Is All You Need” https://lnkd.in/gXUccydp

→ Stanford CS25: https://lnkd.in/gUzsiN_e

→ Or read my NeoSage breakdowns for faster intuition
Issue 1: https://lnkd.in/g2pXsyHn
Issue 2: https://lnkd.in/gPimp6mv

𝗦𝘁𝗲𝗽 𝟮: Learn Prompting Like a Developer, Not a Dabbler
Prompting is design thinking, not guesswork.

→ OpenAI Prompt Guide https://lnkd.in/gqjcPxcQ

→ Prompting Guide https://lnkd.in/ga7FuQRT

→ Mini-Course: https://lnkd.in/gHwMeZzp

𝗦𝘁𝗲𝗽 𝟯: Get Your Hands Dirty — Application Layer

→ Get started with RAG here: https://lnkd.in/gTkNFRAz

Build these:
→ Chatbot 
→ Fine-tune a model
→ Build a RAG pipeline from scratch
here https://lnkd.in/gbdiAkPD


𝗦𝘁𝗲𝗽 𝟰: Go Deeper — Think in Systems
This is where 95% stop. And where real engineers begin.

→ Frameworks: Learn LangChain, LangGraph, and how they shape workflows

→ Protocols:
• Model Context Protocol (Article to get started: https://lnkd.in/gfdJqGU4)
• Google’s A2A 
→ Agents: Learn about planning, memory, and inter-agent coordination. Resources: https://lnkd.in/gFfxtN-c

→ Evaluations: If you can’t measure it, you can’t improve it

𝗥𝗲𝘀𝗼𝘂𝗿𝗰𝗲𝘀 𝗜 𝗧𝗿𝘂𝘀𝘁 𝗳𝗼𝗿 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴
• Deeplearning . ai
• OpenAI Academy
• Google’s white papers on Agents
• Andrej Karpathy’s YouTube Channel
• Hugging Face
• The Neural Maze by Miguel— newsletter with hands-on projects
• The LLM Engineer's Handbook by Paul & Maxime

• NeoSage by Yours Truly: systems thinking & intuition-first AI engineering https://blog.neosage.io

If I had to start all over again?
I’d follow this and ignore everything else.
Save it. Share it. Restart here.

Did I miss your favourite resource? Add it in the comments! 

♻️ Repost to your network.

Learn 𝘀𝘆𝘀𝘁𝗲𝗺 𝗱𝗲𝘀𝗶𝗴𝗻 before Agentic AI
Learn 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲𝘀 before RAG
Learn 𝗵𝗼𝘄 𝗔𝗣𝗜𝘀 𝘄𝗼𝗿𝗸 before MCP
Learn 𝗡𝗟𝗣 before prompt engineering
Learn 𝗱𝗮𝘁𝗮 𝗽𝗿𝗲𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴 before fine-tuning
Learn 𝗰𝗹𝗮𝘀𝘀𝗶𝗰 𝗠𝗟 before LLMs
Learn 𝗺𝗮𝘁𝗵 before neural networks
Learn 𝘁𝗼 𝗰𝗼𝗱𝗲 before vibe coding products
Learn 𝗵𝗼𝘄 𝘁𝗵𝗶𝗻𝗴𝘀 𝗯𝗿𝗲𝗮𝗸 before trying to scale them

There’s too much noise in this field
Everyone’s gathering information
Everyone’s hoarding roadmaps
Everyone has an 𝘶𝘯𝘭𝘪𝘮𝘪𝘵𝘦𝘥 𝘦𝘯𝘤𝘺𝘤𝘭𝘰𝘱𝘦𝘥𝘪𝘢 in their pocket,

But the 𝘤𝘰𝘳𝘦 𝘴𝘬𝘪𝘭𝘭 𝘰𝘧 𝘤𝘳𝘦𝘢𝘵𝘪𝘰𝘯 is getting lost
The skill of connecting the dots
Of building systems that 𝘢𝘤𝘵𝘶𝘢𝘭𝘭𝘺 work
Of learning by doing, not just consuming

So stop

You want to learn AI the right way?
→ Pick one resource
→ Stop hoarding
→ Stick to it
→ Go hands-on

Don’t know where to start? 
Here’s where I started:
👉 https://lnkd.in/gwqSPS4J

That’s it. No hacks. No shortcuts.
Just the hard, slow, real way to get good

♻️ Reposting might help someone who's lost in the noise

How do you shrink a 400B+ model to a 1B model that can run on device?
This paper shows you how.

It’s one of the most comprehensive surveys I’ve seen on Small Language Models (SLMs).

It’s a masterclass in the practical engineering techniques required to build, optimize, and deploy efficient models.

If you're a builder, this is what you need to know:

𝗦𝘁𝗲𝗽 𝟭: 𝗛𝗼𝘄 𝘁𝗼 𝗚𝗘𝗧 𝗮𝗻 𝗦𝗟𝗠 (𝗳𝗿𝗼𝗺 𝗮𝗻 𝗟𝗟𝗠)
You don't always have to train from scratch. 
You can "compress" a larger model using:

→ 𝗣𝗿𝘂𝗻𝗶𝗻𝗴: 
Systematically removing less important parameters, either individually (unstructured) or by entire components (structured).

→ 𝗞𝗻𝗼𝘄𝗹𝗲𝗱𝗴𝗲 𝗗𝗶𝘀𝘁𝗶𝗹𝗹𝗮𝘁𝗶𝗼𝗻 (𝗞𝗗): Training a small "student" SLM to mimic the outputs and behaviour of a large "teacher" LLM.

→ 𝗤𝘂𝗮𝗻𝘁𝗶𝘇𝗮𝘁𝗶𝗼𝗻: 
Reducing the numerical precision of the model's weights (e.g., from 32-bit to 4-bit) to save memory and compute.

𝗦𝘁𝗲𝗽 𝟮: 𝗛𝗼𝘄 𝘁𝗼 𝗘𝗡𝗛𝗔𝗡𝗖𝗘 𝗮𝗻 𝗦𝗟𝗠
A base SLM needs refinement. 
The paper details strategies to boost performance:

→ 𝗔𝗱𝘃𝗮𝗻𝗰𝗲𝗱 𝗗𝗶𝘀𝘁𝗶𝗹𝗹𝗮𝘁𝗶𝗼𝗻: 
Going beyond simple KD to improve SLM reasoning, often using high-quality Chain-of-Thought (CoT) data generated by an LLM.

→ 𝗦𝘂𝗽𝗲𝗿𝘃𝗶𝘀𝗲𝗱 𝗙𝗶𝗻𝗲-𝗧𝘂𝗻𝗶𝗻𝗴 (𝗦𝗙𝗧): 
The paper confirms that for SLMs, data quality is far more important than quantity.

→ 𝗣𝗮𝗿𝗮𝗺𝗲𝘁𝗲𝗿-𝗘𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝘁 𝗙𝗶𝗻𝗲-𝗧𝘂𝗻𝗶𝗻𝗴 (𝗣𝗘𝗙𝗧): 
Using methods like LoRA to adapt SLMs efficiently without retraining all parameters.

→ 𝗟𝗟𝗠 𝗧𝗲𝗰𝗵𝗻𝗶𝗾𝘂𝗲𝘀: 
Applying RAG and Mixture-of-Experts (MoE) to SLMs to give them external knowledge and specialised experts, just like their larger counterparts.

𝗦𝘁𝗲𝗽 𝟯: 𝗛𝗼𝘄 𝘁𝗼 𝗢𝗣𝗧𝗜𝗠𝗜𝗭𝗘 𝗳𝗼𝗿 𝗘𝗱𝗴𝗲 𝗗𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁
This is where the engineering tradeoffs get real, focusing on two bottlenecks:

→ 𝗠𝗲𝗺𝗼𝗿𝘆 𝗘𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝗰𝘆: 
Beyond quantization, this involves compressing the KV Cache, the context memory that grows with every new token.

→ 𝗥𝘂𝗻𝘁𝗶𝗺𝗲 𝗘𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝗰𝘆: 
Using techniques like Dynamic Early Exits, where the model can stop processing at an earlier layer for "easy" tokens, saving compute.

This just scratches the surface, 
the paper also covers 
specific model architectures, 
trustworthiness, 
and how SLMs can even 𝘩𝘦𝘭𝘱 LLMs.

This is a foundational paper for any engineer moving from massive models to practical, deployable systems.

Save this for the link. 
Read it this weekend.

Paper: https://lnkd.in/g_ms4NTv

♻️ Repost this to help your network build the real thing.

This is the simplest and the most complete introduction to RAG that you'll ever find.
I wish I had this guide when I first started.

Modern LLMs are powerful, but they’re static.

They can’t access your internal docs, recent tickets, or product updates.

They don’t “look up” answers. 
They interpolate. 
And when they don’t know, 
They hallucinate.

Most real-world use cases aren’t about abstract language.
They’re about your data.
→ What’s our refund policy?
→ What did the customer say last week?
→ What’s the latest HR guideline?
So, how do you bridge that gap?

You don’t need to fine-tune. 
You don’t need to prompt harder.
You need 𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹-𝗔𝘂𝗴𝗺𝗲𝗻𝘁𝗲𝗱 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗼𝗻 (𝗥𝗔𝗚).

Here’s what this guide breaks down:
🔹 𝗪𝗵𝘆 𝘀𝘁𝗮𝘁𝗶𝗰 𝗟𝗟𝗠𝘀 𝗳𝗮𝗶𝗹 𝗶𝗻 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻
They don’t have access to real-time or proprietary data, and when left unaided, they hallucinate with confidence.

🔹 𝗪𝗵𝘆 𝗽𝗿𝗼𝗺𝗽𝘁𝗶𝗻𝗴 𝗮𝗻𝗱 𝗳𝗶𝗻𝗲-𝘁𝘂𝗻𝗶𝗻𝗴 𝗳𝗮𝗹𝗹 𝘀𝗵𝗼𝗿𝘁
Prompting only changes 𝘩𝘰𝘸 the model responds. Fine-tuning changes the weights—but it’s costly, brittle, and still static. Neither gives the model 𝘯𝘦𝘸 𝘬𝘯𝘰𝘸𝘭𝘦𝘥𝘨𝘦 in real-time.

🔹 𝗪𝗵𝗮𝘁 𝗥𝗔𝗚 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗶𝘀
RAG doesn’t modify the model; it modifies the input. 
It retrieves relevant context (docs, tickets, policies) and feeds it into the prompt at inference time.

No retraining. Just better answers, grounded in your own data.

🔹 𝗪𝗵𝗮𝘁 𝘁𝗵𝗲 𝗥𝗔𝗚 𝗹𝗼𝗼𝗽 𝗹𝗼𝗼𝗸𝘀 𝗹𝗶𝗸𝗲 𝗲𝗻𝗱-𝘁𝗼-𝗲𝗻𝗱
→ Embed the user query
→ Perform vector search
→ Retrieve top-k relevant chunks
→ Inject those chunks into the prompt
→ Let the LLM generate a grounded response

🔹 𝗪𝗵𝗲𝗿𝗲 𝗻𝗮𝗶𝘃𝗲 𝗥𝗔𝗚 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝗳𝗮𝗶𝗹
• Bad chunking (splits mid-sentence, loses semantics)
• Embeddings that don’t reflect your domain
• Missing metadata filtering
• Model ignoring context
• Retrieval failures that sound fluent but mislead users

🔹 𝗪𝗵𝗮𝘁 𝗺𝗮𝗸𝗲𝘀 𝗥𝗔𝗚 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻-𝗿𝗲𝗮𝗱𝘆
✔ Hybrid retrieval (dense + sparse)
✔ Re-ranking with cross-encoders
✔ Semantic chunking + metadata tagging
✔ Feedback loops to improve retrieval over time
✔ Monitoring retrieval quality

🔹 𝗛𝗼𝘄 𝘁𝗼 𝗲𝘃𝗮𝗹𝘂𝗮𝘁𝗲 𝗮 𝗥𝗔𝗚 𝘀𝘆𝘀𝘁𝗲𝗺
Using the 𝗥𝗔𝗚 𝗧𝗿𝗶𝗮𝗱:
1. 𝘙𝘦𝘵𝘳𝘪𝘦𝘷𝘢𝘭 𝘘𝘶𝘢𝘭𝘪𝘵𝘺 – Did you fetch the right chunks?
2. 𝘍𝘢𝘪𝘵𝘩𝘧𝘶𝘭𝘯𝘦𝘴𝘴 – Did the model stick to the context?
3. 𝘈𝘯𝘴𝘸𝘦𝘳 𝘘𝘶𝘢𝘭𝘪𝘵𝘺 – Was the response complete, clear, and helpful?

If you’re building with LLMs, this is the system blueprint you’ll keep referring back to.

♻️ Repost to help your network upskill

—
🔗 Read the full breakdown here: https://lnkd.in/gTkNFRAz

𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹-𝗔𝘂𝗴𝗺𝗲𝗻𝘁𝗲𝗱 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗼𝗻

If I had to explain how true AI reasoning works in 90 seconds, I'd show you the DeepSeek-R1 playbook. Here's the exact 4-stage process they used to make a model 𝘥𝘪𝘴𝘤𝘰𝘷𝘦𝘳 logic.

AI reasoning is the hottest topic right now. 
But only a few deeply understand it
This guide teaches you how AI learns to reason

Standard models are trained to imitate reasoning, not to think. 
They copy examples. But struggle when patterns break.

DeepSeek-R1 flipped the script. 
It wasn’t taught reasoning. 
It was incentivised to discover it.

Part 1: The Core Idea — Incentives > Instructions

DeepSeek-R1 learned to reason with no human-written examples.

The standard Way (Supervised):
• Feed “correct” answers
• Model copies the format
• Limited by example quality

The 'DeepSeek R1 Zero' Way (Incentivised):
• The model generates multiple answers
• Rewarded only when the output is correct (math solved, code runs)
• Used GRPO (Group Relative Policy Optimisation), no critic model
• Model learned that step-by-step reasoning increases reward

Part 2: The 4-Stage Playbook

Turning a raw reasoner into an aligned system, one fix at a time:

Stage 1: Fixing the Mess 
Problem: Messy, verbose, mixed-language output 
Fix: Small fine-tuning pass to enforce structure & language consistency

Stage 2: Deepening Reasoning 
Problem: Logic was shallow, mixing persisted 
Fix: RL pass rewarding both accuracy and clean output

Stage 3: Broadening Skills 
Problem: STEM-strong, but couldn’t chat, write, summarise 
Fix: Fine-tuned on 800K examples (600K reasoning, 200K general tasks)

Stage 4: Aligning Behaviour 
Problem: Still unhelpful or unsafe in open-ended prompts 
Fix: Final RL round using reward models for tone, helpfulness, safety

Part 3: The Payoff — Distilling Genius
They used the final dataset (~800K samples) to fine-tune smaller models like Llama3 and Qwen2.5.
No RL needed. Just outputs → supervision → transfer of reasoning ability.

Key Takeaway: Reasoning is emergent. It cannot be taught through imitation alone. It needs a systematic approach to build reasoning in layers

Each stage debugged the last and built one of the strongest open reasoning models yet.

Want the full architecture + training breakdown? 
Read the full issue (Link in the comment and the PDF)

♻️ Reposting this helps everyone in your network build deep intuition

How AI Learns to Reason: DeepSeek-R1 Case Study

You can take away all my LLM subscriptions,  

But I’m not giving up ...
Claude Code.
 
Yup, it’s 𝘵𝘩𝘢𝘵 good.
 
Once you learn how to actually use it (and yes, there’s a curve),  
That 100x productivity everyone talks about?  
It’s real.
 
And no, I don’t switch off my brain when I use it.  
Quite the opposite.  
I stay in the driver’s seat the entire time.
 
Here’s exactly how I work with it:
 
↳ I design the system components myself
↳ I brainstorm the low-level details with it
↳ I never hand over full control (no “yes to all”)
↳ I read the docs first, then tell it what to look for (don’t let it roam free)
↳ I create dedicated development-progress docs in each phase to keep things accurate
↳ I set myself up for iteration: I review and test every sub-feature like I would a PR
↳ For the bugs it can’t solve: I research properly and 𝘨𝘶𝘪𝘥𝘦 𝘪𝘵 𝘰𝘯 𝘩𝘰𝘸 𝘵𝘰 𝘵𝘩𝘪𝘯𝘬
↳ I am extremely verbose with Claude
↳ I never offload the thinking, only the typing 
(It’s my intelligent typist, not my brain replacement)
 
And with this workflow, I’ve been able to build something genuinely 𝘦𝘯𝘨𝘪𝘯𝘦𝘦𝘳𝘪𝘯𝘨-𝘨𝘳𝘢𝘥𝘦 in a fraction of the time it would’ve otherwise taken.
 
(Spoiler: it still took me two months, because building for production doesn’t magically become a “weekend project,” even with all the AI in the world.)

How do you use AI-assisted coding?

The hardest part of building a production-grade RAG system isn’t retrieval. Isn’t generation.

It’s evaluation.

I’ve spent the last few months trying every stack under the sun to find something reliable, automated, and scalable, and here’s what everyone must understand:

Most RAG failures happen 𝘣𝘦𝘧𝘰𝘳𝘦 generation ever starts.
Because the real battle is the retrieval layer.

The metrics that truly decide whether your RAG works are:
Precision@k
Recall@k
MRR@k
NDCG@k

Answer relevance and faithfulness matter too, but they’re downstream.
They depend on your model, prompt, and what context you give it.

The hardest to tune is: retrieved context.

Let me break down what actually happens when you evaluate a RAG system.

1. The gold standard is still human evaluation
You look at:
↳ The question
↳ The answer
↳ The top-k retrieved chunks

And you judge:
• Are the chunks relevant?
• At what rank does the most relevant chunk appear?
• How much noise did the retriever pull in?
• Is the retrieved context 𝘤𝘰𝘮𝘱𝘭𝘦𝘵𝘦 𝘦𝘯𝘰𝘶𝘨𝘩 to answer the question?

The problem?
This requires a subject-matter expert.
It doesn’t scale across 100 questions, 20 iterations, or rapid experimentation.

So you automate it.
And this is where the fun ends.

2. Automation requires ground truth, and that’s its own nightmare
To evaluate retrieval, you need triples (question → expected answer → ground truth chunks).
Without ground truth, most metrics don’t even mean anything.

Synthetic test-set creation sounds great on paper: RAGAS, DeepEval, etc.
But depending on your domain, they may give you something:
• too generic
• too easy
• too harsh
• or completely unusable
Most of the time, you still end up hand-curating.

3. LLM-as-a-judge
The quality of your evaluation depends heavily on the model you pick.

↳ Some models can’t follow strict evaluation instructions 
↳ “Thinking models” do better, but cost more 
↳ LLMs can be too lax in one-shot scoring 
↳ Stricter control turns evaluation into a long-horizon pipeline

Once you force them to parse → compare → justify → score → verify, you’ve built an orchestration layer just to keep your judge honest.

In the end, LLM-based evaluation becomes another system you have to design, monitor, and pay for.

4. Semantic similarity metrics are stable, but dangerously rigid

The good part:
• deterministic
• repeatable
• cheap
• no hallucinated scoring
• perfectly consistent across runs

But here’s the real tradeoff:

↳ Semantic similarity only rewards matching the ground truth, not correctness
↳ If your ground truth is narrow, your system will look worse as it improves
↳ You lose the nuance that LLM judges provide

Evaluating RAG is hard.
You’re balancing:
• human judgment
• automated scoring
• ground truth creation
• retrieval tuning
• non-determinism across the pipeline

And it takes multiple cycles before you find a setup that actually reflects reality.

How do you evaluate your RAG?

♻️ Repost to share these insights.

If I could suggest one product as a masterclass in what context engineering can achieve... 

It would be Zerve.

Let me break down why.

Say you're doing exploratory data analysis on a new dataset.

Your workflow looks something like this:

1. Load the data, check shape and dtypes
2. Look at missing values: which columns, what percentage
3. Check distributions:  are there outliers? skewed features?
4. Look at correlations between variables
5. Visualize relationships with the target
6. Decide which features to keep, which to transform, which to drop

As a human, by step 5, you're holding a lot in your head:

↳ That 'income' has 12% nulls but 'age' is complete
↳ That 'transaction_amount' is heavily right-skewed (needs log transform)
↳ That 'region' has 47 unique values (probably needs grouping)
↳ That 'signup_date' and 'first_purchase' are highly correlated (keep one)
↳ The visualizations you made that informed these decisions

Now here's what Cursor sees:
↳ The files you're currently writing
↳ The other code files in your repo
↳ Not the actual outputs, the charts, the .describe() tables, the correlation matrix

It doesn't know that 'income' has nulls.
It can't see the histogram that showed the skew.
It doesn't know which features you've already decided to drop.

So when you ask "which features should I transform?" 
it's guessing based on code, not results.

This is the orchestration gap.
It's not about whether AI can execute code.
It's about whether AI can see your workflow as a connected system

I've been exploring what it looks like when context is actually built into the architecture.

Zerve is the clearest implementation I've found.

Here's how they structure it across 5 layers:

𝟭. 𝗖𝗼𝗱𝗲 𝗖𝗼𝗻𝘁𝗲𝘅𝘁
The agent sees all your code blocks, not just the one you're editing. 
It understands dependencies between them.

𝟮. 𝗗𝗮𝘁𝗮 𝗖𝗼𝗻𝘁𝗲𝘅𝘁
It connects to your actual data sources. 
Sees the schema, column types, row counts, sample values. 

𝟯. 𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝗖𝗼𝗻𝘁𝗲𝘅𝘁
Each block runs in real compute (Lambda, Fargate, GPU). 
The agent sees actual outputs, DataFrames, charts, error traces

𝟰. 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 (𝗗𝗔𝗚)
Your pipeline is a directed graph. 
Block A feeds Block B feeds Block C. 
The agent understands this structure, state flows forward, dependencies are explicit.

𝟱. 𝗙𝗲𝗲𝗱𝗯𝗮𝗰𝗸 𝗖𝗼𝗻𝘁𝗲𝘅𝘁
When code fails, the agent sees the real error in context. 
It tries a different approach automatically. 
Learnings carry forward, no manual copy-paste loop.

The key insight: it's not any single layer.
It's that all 5 are unified.

When you ask, "which features need transformation?" 

It gives recommendations based on actual results because it has the same context you do.

If you want to see this in action: https://lnkd.in/gPc6B6eb

♻️ Repost to share this with your network

The 5 layers of Context AI Agents Need

Please stop building multi-agent systems. 

Autonomy means nothing if the system can’t repeat its own success

𝟭. 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗻𝗲𝗲𝗱𝘀 "𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴"
It isn’t about “can it solve the problem?”

It’s “can it solve the problem under real constraints, and still make business sense?”

↳ Constraints: cost, latency, accuracy, compliance, security, privacy, ethics
↳ Value: measurable user impact (time saved, risk reduced, revenue unlocked)
↳ Unit economics: margins today or a credible path soon

Add even one constraint, and the search space explodes. 
Add scale, and it gets harder again.

𝟮. 𝗟𝗟𝗠𝘀 𝗮𝗿𝗲 𝗲𝘅𝗰𝗲𝗹𝗹𝗲𝗻𝘁 𝗮𝘁 𝗹𝗮𝗻𝗴𝘂𝗮𝗴𝗲, 𝘀𝗵𝗮𝗸𝘆 𝗮𝘁 𝗮𝗱𝗵𝗲𝗿𝗲𝗻𝗰𝗲
The creative variability we love trades off with reliability.
↳ Non-deterministic outputs
↳ Instruction drift across long tasks
↳ Sensitivity to prompt/context formatting

Great for ideation and synthesis; fragile for strict, long-horizon execution.

𝟯. 𝗘𝗻𝘁𝗲𝗿𝗽𝗿𝗶𝘀𝗲-𝗴𝗿𝗮𝗱𝗲 𝗺𝗲𝗮𝗻𝘀 𝗼𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗶𝗼𝗻
To tame non-determinism, you have to add structure. A lot of it.

↳ Task decomposition and state: break work into verifiable steps, persist state
↳ Data layer: sourcing → cleaning → chunking → embeddings → indexing (RAG)
↳ Prompt lifecycle: versioning, testing, registries, rollout/rollback
↳ Model routing & caching: pick the smallest model that meets quality, reuse context
↳ Evals & observability: ground-truth tests, regression suites, traces, guardrails
↳ The triangle you must balance every day: accuracy ↔ cost ↔ latency

Yes, the “mammoth thinking model” can brute-force quality, only if your users can wait and you can eat the bill. Most can’t.

𝟰. 𝗧𝗿𝗲𝗮𝘁 𝗔𝗜 𝗮𝘀 𝗮 𝗰𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁 𝗶𝗻 𝗮 𝘀𝘆𝘀𝘁𝗲𝗺, 𝘁𝗵𝗲𝗻 𝗰𝗵𝗼𝗼𝘀𝗲 𝘁𝗵𝗲 𝘀𝗶𝗺𝗽𝗹𝗲𝘀𝘁 𝘁𝗵𝗶𝗻𝗴 𝘁𝗵𝗮𝘁 𝘄𝗼𝗿𝗸𝘀

For most production use cases:

↳ 𝗥𝗔𝗚 𝘄𝗶𝘁𝗵 𝗱𝗲𝘁𝗲𝗿𝗺𝗶𝗻𝗶𝘀𝘁𝗶𝗰 𝗰𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁𝘀 > 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗥𝗔𝗚
(Tight retrieval, reranking, and schema constraints beat free-roaming planners.)

↳ 𝗛𝗲𝘂𝗿𝗶𝘀𝘁𝗶𝗰/𝗺𝗲𝘁𝗿𝗶𝗰-𝗯𝗮𝘀𝗲𝗱 𝗲𝘃𝗮𝗹𝘀 𝘄𝗶𝘁𝗵 𝗵𝗶𝗴𝗵-𝗾𝘂𝗮𝗹𝗶𝘁𝘆 𝗴𝗿𝗼𝘂𝗻𝗱 𝘁𝗿𝘂𝘁𝗵 > 𝗟𝗟𝗠-𝗮𝘀-𝗮-𝗷𝘂𝗱𝗴𝗲
(Use the model to propose, not police, unless you’ve calibrated it carefully.)

↳ 𝗗𝗲𝘁𝗲𝗿𝗺𝗶𝗻𝗶𝘀𝘁𝗶𝗰 𝗮𝘂𝘁𝗼𝗺𝗮𝘁𝗶𝗼𝗻 𝘄𝗶𝘁𝗵 𝗟𝗟𝗠 𝗮𝘁 𝘁𝗵𝗲 𝘀𝗲𝗮𝗺𝘀 > 𝗠𝘂𝗹𝘁𝗶-𝗮𝗴𝗲𝗻𝘁 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴
(Let the LLM read/plan/rewrite; let code and tools execute.)

↳ 𝗖𝗹𝗮𝘀𝘀𝗶𝗰 𝗠𝗟 𝗼𝗿 𝗿𝘂𝗹𝗲𝘀 𝗳𝗼𝗿 𝘀𝘁𝗮𝗯𝗹𝗲 𝘀𝗶𝗴𝗻𝗮𝗹𝘀 > 𝗠𝗮𝗻𝗮𝗴𝗶𝗻𝗴 𝗟𝗟𝗠 𝘀𝘁𝗼𝗰𝗵𝗮𝘀𝘁𝗶𝗰 𝗵𝗲𝗹𝗹
(Don’t use a bazooka to swat a fly; it's harder to aim)

LLMs are powerful, but they’re one part of a disciplined software system.

Engineer the system first. 

Insert the model where it actually improves reliability, speed, cost or efficiency.

♻️ Repost to share these insights.

Everyone’s talking about MCP. 
No one’s talking about how it connects attackers to your systems.

MCP acts as a bridge between an LLM and APIs, file systems, or other tools. 

But that bridge can open entirely new attack vectors that bypass traditional security controls.

Key risks to watch for:

1. Remote Code Execution (RCE) via Command Injection

If an MCP tool concatenates user input directly into a shell command (os.system(f"convert {filepath} ...")), attackers can append extra commands like "image.jpg; cat /etc/passwd". 

The shell treats the semicolon as a separator and executes both commands.

Impact: Full system compromise, data theft, or lateral movement across the network.

2. Data Exfiltration via Prompt Injection

Attackers can hide malicious instructions inside MCP tool metadata (e.g., its description). 

When passed to the LLM as trusted context, it executes them, for example, sending conversation history to a malicious URL.

Impact: Stealthy data leakage that bypasses application-layer defences.

3. Privilege Escalation via Leaked Tokens

MCP servers often store OAuth tokens or API keys for third-party services. 

If an attacker exploits RCE or path traversal, they can read these secrets from memory, environment variables, or insecure config files.

Impact: Ability to impersonate the AI tool or its users, with full access to connected systems.

4. Man-in-the-Middle via Server Spoofing

Without enforced mutual TLS and host verification, an attacker can spin up a rogue MCP server, intercepting and manipulating all traffic between agents and the real server.

Impact: Loss of confidentiality and integrity for all queries, responses, and sensitive data.

5. Supply Chain Attacks on MCP Libraries

Compromising a popular open-source MCP library (PyPI, npm) allows malicious code to spread to every system that uses it. 

This code may stay dormant until triggered, then deploy ransomware or exfiltrate credentials.

Impact: A single poisoned dependency can cause widespread, hard-to-trace breaches.

Securing MCP in production:

↳ Treat MCP as a critical attack surface:
threat-model every endpoint, tool, and context object.

↳ Implement Zero Trust:
strict authentication & authorization for all agent and tool calls.

↳ Enforce least privilege:
Only give tools the minimum permissions they require, and audit regularly.

↳ Validate and sanitize all inputs: 
Avoid passing raw user data to system shells.

↳ Harden the supply chain:
Verify MCP dependencies, pin versions, and scan continuously.

↳ Mandate mTLS for all AI agent ↔ MCP server communication.

↳ Maintain immutable logs and continuous monitoring for anomaly detection.

MCP’s utility is undeniable, but without proactive security engineering, it’s a ready-made entry point for attackers.

Over to you: Have you seen any security failures with MCPs in your setup?

♻️ Found this useful? Repost to help others upskill!

I wish I had this guide when I first started learning the basics of NLP. The advice I got was to read "Attention is all you need." But...

As a beginner (and honestly even as you advance), that paper is a tough read.

Here's the intuitive evolution of sequence modelling that you actually need to understand, starting from the most fundamental building block:

1. The Perceptron
The foundational unit of a neural network. It computes a weighted sum of inputs and passes the result through an activation function.

► Limitation: It's static and stateless, meaning it has no memory of past inputs. Unsuitable for sequences on its own.

⬇️

2. Recurrent Neural Networks (RNNs)
The first architecture designed for sequences. 

It introduces a hidden state that acts as memory, combining the current input with the information from the previous state.

► Limitations: The sequential nature prevents parallel processing. Long-range dependencies are lost due to the vanishing gradient problem during backpropagation.

⬇️

3. The Attention Mechanism
A radical shift that overcomes RNN limitations. 

It gives the model a superpower: to directly measure the relationship between any two words in a sentence, no matter how far apart they are.

► How it works (without jargon, intuition only):

1. Calculate Relevance: For any word, the model calculates a "relevance score" to every other word in the sentence. A high score means the words are highly related for the current task.
   
2. Distribute Influence: These scores are converted into "influence weights." A word with a high score gets a bigger say in the meaning of the word being analyzed.
   
3. Blend Information: The model creates a new, context-rich version of the original word by blending information from all other words according to their influence weights. 
   
   This is how the model knows "it" refers to "the car" and not "the street" in the sentence "The car drove down the street until it ran out of gas.”
   
► Crucial Detail: Since this system looks at all words at once, Positional Embeddings (codes that signify word order) are added to the input to ensure the model doesn't lose the original sentence structure.

⬇️

4. The Transformer
An architecture built entirely on self-attention, completely replacing the recurrence of RNNs.

► The Result: Massive parallelisation, superior handling of long-range dependencies, and the scalability that powers modern Large Language Models (LLMs). The "T" in GPT literally stands for Transformer.

To dive deeper, I can't recommend these three videos enough:
1️⃣ Introduction to Transformers w/ Andrej Karpathy 
https://lnkd.in/gKZ7MKeZ

2️⃣ MIT 6.S191: RNNs, Transformers, and Attention
https://lnkd.in/gfSgxkGg

3️⃣ Attention Is All You Need by Yannic
https://lnkd.in/gewCufwP

Over to you: what's your favourite NLP learning resource?

♻️ Repost to share these insights.

taplio

The Battle

Alex Razvant

Shivani Virdi

Followers

Posts

Engagements

Likes

Performance ScoreAlex Razvant's LinkedIn Performance

Performance ScoreShivani Virdi's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Alex Razvant

Shivani Virdi

Followers

Posts

Engagements

Likes

Performance Score.css-goub6s{font-size:var(--chakra-fontSizes-md);font-weight:500;color:var(--chakra-colors-gray-600);display:block;margin-top:var(--chakra-space-1);}Alex Razvant's LinkedIn Performance

Performance ScoreShivani Virdi's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScoreAlex Razvant's LinkedIn Performance