Paul Iusztin

Decoding ML

⚫️ ML & MLOps engineering learning hub

Helping machine learning engineers level up through hands-on practical articles and tutorials on designing and productionizing ML systems.

Co-Founder

Metaphysic.ai

🟡 Scalable ML batch infrastructure for continuous training & inference

The client, a generative AI leader, struggled with manual training and calling their ML models. As a tedious and unscalable process, they needed to automate their ML processes completely and integrate them with their current web platform.

➞ 𝐃𝐞𝐬𝐢𝐠𝐧𝐞𝐝 and 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝 a modular 𝐏𝐲𝐭𝐡𝐨𝐧 𝐩𝐚𝐜𝐤𝐚𝐠𝐞 that composes the ML model required steps into 3 main batch pipelines that can easily be automated: feature, training, and inference, 𝐞𝐥𝐢𝐦𝐢𝐧𝐚𝐭𝐢𝐧𝐠 a 𝐭𝐞𝐝𝐢𝐨𝐮𝐬 𝟐-𝐡𝐨𝐮𝐫 𝐦𝐚𝐧𝐮𝐚𝐥 𝐩𝐫𝐨𝐜𝐞𝐬𝐬/𝐯𝐢𝐝𝐞𝐨.
➞ 𝐃𝐞𝐩𝐥𝐨𝐲𝐞𝐝 a scalable & cost-effective 𝐛𝐚𝐭𝐜𝐡 𝐚𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 and 𝐂𝐈/𝐂𝐃 𝐩𝐢𝐩𝐞𝐥𝐢𝐧𝐞 on top of AWS ECS & SQS that scales in and out based on the number of jobs, 𝐬𝐚𝐯𝐢𝐧𝐠 𝐭𝐡𝐨𝐮𝐬𝐚𝐧𝐝𝐬 𝐨𝐟 𝐝𝐨𝐥𝐥𝐚𝐫𝐬/𝐦𝐨𝐧𝐭𝐡.
➞ 𝐒𝐚𝐯𝐞𝐝 𝐦𝐨𝐧𝐭𝐡𝐬 𝐨𝐟 𝐟𝐮𝐭𝐮𝐫𝐞 𝐝𝐞𝐯𝐞𝐥𝐨𝐩𝐦𝐞𝐧𝐭 by using good software practices to make the Python module & batch cloud infrastructure flexible and composable.
➞ 𝐁𝐮𝐢𝐥𝐭 a 𝐯𝐨𝐢𝐜𝐞 𝐬𝐲𝐧𝐭𝐡𝐞𝐬𝐢𝐬 𝐏𝐨𝐂 in ~1 week required to 𝐜𝐥𝐨𝐬𝐞 the 𝐝𝐞𝐚𝐥 with one of the 𝐜𝐮𝐫𝐫𝐞𝐧𝐭 𝐜𝐥𝐢𝐞𝐧𝐭𝐬.

⚫️ Big data ingestion & archiving pipeline

The client wanted to expand its platform features by securely and safely ingesting, preprocessing, and storing TB of data into their platform.

➞ 𝐂𝐨𝐧𝐭𝐫𝐢𝐛𝐮𝐭𝐞𝐝 to the 𝐝𝐞𝐬𝐢𝐠𝐧 and 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧 of a 𝐝𝐚𝐭𝐚 𝐢𝐧𝐠𝐞𝐬𝐭𝐢𝐨𝐧 𝐩𝐢𝐩𝐞𝐥𝐢𝐧𝐞 that supports 𝐢𝐧𝐠𝐞𝐬𝐭𝐢𝐧𝐠 >𝟓 𝐓𝐁 of data in 𝐨𝐧𝐞 𝐠𝐨 in a reliable, fast, and secure way.
➞ 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝 a scalable 𝐝𝐚𝐭𝐚 𝐩𝐫𝐞𝐩𝐫𝐨𝐜𝐞𝐬𝐬𝐢𝐧𝐠 𝐩𝐢𝐩𝐞𝐥𝐢𝐧𝐞 that supports multiple media types (images, videos, audio, 3D objects) and creates small preview files that are cheap to transfer, store and visualize. The 𝐨𝐫𝐢𝐠𝐢𝐧𝐚𝐥 𝐟𝐢𝐥𝐞𝐬 are 𝐚𝐫𝐜𝐡𝐢𝐯𝐞𝐝 on an affordable storage solution 𝐫𝐞𝐝𝐮𝐜𝐢𝐧𝐠 𝐜𝐨𝐬𝐭𝐬 𝐛𝐲 𝐮𝐩 𝐭𝐨 𝟖𝟏%.

Senior Machine Learning Engineer

Remote Work

💼 Senior machine learning engineer, contractor, consultant, and freelancer with 𝟔+ 𝐲𝐞𝐚𝐫𝐬 𝐨𝐟 𝐞𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞 offering scalable and modular machine learning solutions for businesses worldwide.

➞ I can design, implement, train, evaluate, and operate end-to-end ML pipelines for your business. I can scale up your ML systems by leveraging the latest MLOps technologies.

➞ I have spent 7+ years writing code in Python, but I also enjoy using Node.js for web development and C/C++ for optimizing various applications.

➞ My go-to machine learning frameworks are PyTorch, Keras, and Sklearn. Also, my favorite MLOps tech stack is AWS, W&B/MLFlow, and DVC.

🔥The world of AI is constantly changing, new technologies are born almost daily, and therefore, I am always open to new challenges.

💬 𝐂𝐨𝐧𝐭𝐚𝐜𝐭 𝐦𝐞, and let's see how I can help your business.

Senior Machine Learning Engineer • Freelancer • Contractor

Towards Data Science

⚫️ ML and MLOps engineering blog

Helping machine learning engineers level up through hands-on practical articles and tutorials on designing and productionizing ML systems.

➞ Published 𝐓𝐡𝐞 𝐅𝐮𝐥𝐥 𝐒𝐭𝐚𝐜𝐤 𝟕-𝐒𝐭𝐞𝐩𝐬 𝐌𝐋𝐎𝐩𝐬 𝐅𝐫𝐚𝐦𝐞𝐰𝐨𝐫𝐤 with 90k+ views on Medium and 600+ stars on GitHub. An MLE & MLOps course that teaches you how to design, build, and deploy an end-to-end ML batch system: https://github.com/iusztinpaul/energy-forecasting

↳🔗 Follow me: https://pauliusztin.medium.com

Machine Learning Engineer / Technical Writer

CoreAI

⚫️ Real-time social media recommender system using machine learning & Kafka

The client, a social media start-up from Israel, needed a real-time dashboard and recommender system on top of their Kafka infrastructure using modern ML and MLOps solutions.

➞ 𝐋𝐞𝐝 the architecture system design of a modular real-time social media recommender system built on top of the client's Kafka nervous system that leverages streaming and ML technologies such as Kafka Streams, Kotlin, PyTorch, Python, and Docker.

➞ Quickly 𝐩𝐥𝐚𝐧𝐧𝐞𝐝 and 𝐝𝐞𝐯𝐞𝐥𝐨𝐩𝐞𝐝 a scalable recommender system based on heuristics, picked through A/B testing, using Kafka Streams and Kotlin. It served as a vital entry point and baseline for future algorithms.

➞ 𝐃𝐞𝐬𝐢𝐠𝐧𝐞𝐝 and 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝 a dashboard that computes KPIs in 𝐫𝐞𝐚𝐥-𝐭𝐢𝐦𝐞 𝐟𝐨𝐫 𝟏𝟎𝟎𝐤+ 𝐮𝐬𝐞𝐫𝐬 on the client's Kafka infrastructure using ksqlDB, SQL, Elasticsearch, and Apache Superset.

Machine Learning Tech Lead

🟡 coreControl - end-to-end MLOps infrastructure

The client, a machine learning service provider, required an end-to-end ML/MLOps infrastructure to scale their operations and save development resources across multiple AI projects.

➞ 𝐋𝐞𝐝 the 𝐝𝐞𝐬𝐢𝐠𝐧 and 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧 of coreControl by integrating the software with the client's products and collaborating with other ML engineers, developers, and graphic designers.

➞ 𝐑𝐞𝐝𝐮𝐜𝐞𝐝 the 𝐝𝐞𝐯𝐞𝐥𝐨𝐩𝐦𝐞𝐧𝐭 𝐭𝐢𝐦𝐞 across the client's machine learning projects 𝐛𝐲 𝟑𝟎% using coreControl.

➞ 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝 the data backbone of coreControl that syncs the data between multiple MLOps tools and exposes them to a UI through a RESTful API using Python, FastAPI, PostgreSQL, Docker, and AWS.

➞ 𝐃𝐞𝐯𝐞𝐥𝐨𝐩𝐞𝐝 a Python package that wraps various MLOps tools that standardizes the data scientists' work and centralizes all the ML artifacts to easily be analyzed in a single place using Python, DVC, and ClearML.

⚫️ Prototyping AI solutions for Demand Forecasting, Churn Prediction, and Customer Segmentation

The client, a machine learning start-up, wanted to expand their services portfolio by prototyping and gaining knowledge in various AI fields that leverage structured retail data.

➞ 𝐋𝐞𝐝 𝐚 𝐭𝐞𝐚𝐦 𝐨𝐟 𝟐 to develop an ML clustering solution that aggregates data from multiple sources and finds customer segments and insights for new potential clients.

➞ 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝 a prototype for churn and demand forecasting used as a proof of concept to close deals with various clients.

➞ 𝐒𝐚𝐯𝐞𝐝 𝟒𝟎% of 𝐞𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐢𝐧𝐠 𝐫𝐞𝐬𝐨𝐮𝐫𝐜𝐞𝐬 by building a reusable Python ML framework that can quickly be tailored to custom problems based on structured data.

Politehnica University of Timisoara

⚫️ Teaching the foundations of 𝐚𝐫𝐭𝐢𝐟𝐢𝐜𝐢𝐚𝐥 𝐢𝐧𝐭𝐞𝐥𝐥𝐢𝐠𝐞𝐧𝐜𝐞 laboratory.

➞ Supervised and unsupervised learning
➞ Linear regression, SVMs, Decision trees
➞ Clustering, Dimensionality reduction
➞ Dense neural networks
➞ Convolutional neural networks
➞ Recurrent neural networks
➞ Transformers

Teaching Assistant

Everseen

🟡 Autonomous supply chain system using computer vision & deep learning

The client, a well-known player in the retail sector, needed to expand its deep learning and computer vision solutions by researching and building autonomous systems for its operations in the retail industry.

➞ 𝐓𝐫𝐚𝐢𝐧𝐞𝐝 a Mask-RCNN model for 2D object detection and segmentation on 100k proprietary retail images, with an 𝐦𝐀𝐏 𝐨𝐟 𝟖𝟓%.

➞ 𝐒𝐩𝐞𝐞𝐝 𝐮𝐩 the 𝐢𝐧𝐟𝐞𝐫𝐞𝐧𝐜𝐞 𝐭𝐢𝐦𝐞 of the Mask-RCNN model 𝐛𝐲 𝟓𝟎% by levering Docker, ONNX, and TensorRT to containerize and accelerate the models.

➞ 𝐓𝐫𝐚𝐢𝐧𝐞𝐝 a scalable classifier using an image retrieval model that can dynamically handle new classes without additional training.

➞ 𝐈𝐧𝐜𝐫𝐞𝐚𝐬𝐞𝐝 the 𝐫𝐞𝐩𝐫𝐨𝐝𝐮𝐜𝐢𝐛𝐢𝐥𝐢𝐭𝐲 of the 𝐭𝐫𝐚𝐢𝐧𝐢𝐧𝐠 𝐩𝐫𝐨𝐜𝐞𝐬𝐬 by implementing MLOps solutions, such as DVC & MLFlow, that included data & model versioning, registries, and experiment tracking features.

Continental

🟡 Autonomous driving system using computer vision & deep learning

The client, a well-known player in the automotive sector, needed to create an autonomous driving car prototype that could accurately detect traffic participants by leveraging DL and CV solutions.

➞ 𝐋𝐞𝐝 the 𝐝𝐞𝐯𝐞𝐥𝐨𝐩𝐦𝐞𝐧𝐭 of a prototype for real-time traffic participants detection by deploying a CenterNet model for 3D object detection on a test car using an Nvidia Drive AGX C++ platform.

➞ 𝐈𝐦𝐩𝐫𝐨𝐯𝐞𝐝 the reproducibility of the experimentation process by implementing MLOps solutions (DVC) that version unstructured big data.

➞ 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝 a replacement to the Hungarian algorithm that 𝐢𝐧𝐜𝐫𝐞𝐚𝐬𝐞𝐝 the 𝐬𝐩𝐞𝐞𝐝 by 𝟑𝟎%, making the system 𝐫𝐞𝐚𝐥-𝐭𝐢𝐦𝐞.

➞ 𝐒𝐚𝐯𝐞𝐝 𝟐 𝐝𝐚𝐲𝐬, in 𝐞𝐯𝐞𝐫𝐲 𝐦𝐨𝐧𝐭𝐡, of 𝐫𝐞𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 work by automating the steps for the creation of the 𝐦𝐨𝐧𝐭𝐡𝐥𝐲 demo.

Mid-Level Machine Learning Researcher

⚫️ Autonomous driving research using computer vision & deep learning

The client, a well-known player in the automotive sector, needed to expand its research into the autonomous driving field using novel deep learning and computer vision methods.

➞ 𝐑𝐞𝐬𝐞𝐚𝐫𝐜𝐡 in 3D object detection, depth estimation & completion, tracking, and sensor fusion algorithms using various sensors such as images, radar & LiDAR point clouds.

➞ 𝐑𝐞𝐝𝐮𝐜𝐞𝐝 𝐛𝐲 𝟒𝟎% the 𝐦𝐞𝐦𝐨𝐫𝐲 𝐮𝐬𝐚𝐠𝐞 of the 3D object detection code by introducing the Dynamic Voxelization algorithm into the preprocessing pipeline.

➞ 𝐓𝐫𝐚𝐢𝐧𝐞𝐝 state-of-the-art models to generate LiDAR-like dense point clouds from sparse Radar point clouds on various autonomous driving datasets, such as KITTI, nuScenes, DDAD, and A2D2.

Junior Machine Learning Researcher

Elementum Technologies

⚫️ Dorel - An Uber for handymen

𝐃𝐨𝐫𝐞𝐥 is an app that connects handypersons with customers. It contains a review and portfolio system where any handyperson can build ility. Based on that, a user can determine t fit for the job. The app intends to bring, once again, trust in handypersons. 

➞ 𝐌𝐚𝐧𝐚𝐠𝐞𝐝 the backend components of the software solution of Dorel using an Agile methodology. 

➞ 𝐋𝐞𝐝 the 𝐝𝐞𝐬𝐢𝐠𝐧 and 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧 of the Django RESTful API server and the notifications microservice.

➞ 𝐃𝐞𝐬𝐢𝐠𝐧𝐞𝐝 and 𝐝𝐞𝐯𝐞𝐥𝐨𝐩𝐞𝐝 the Redux layer of the React Native mobile app.

SafeFleet Telematics

⚫️ Smart parking management platform

The client, a local player in the urban parking payment systems, needed to scale its operations into the private sector by building a new parking platform. 

➞ 𝐄𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐞𝐝 the Redux layer of the onboarding mechanism of the React Native mobile application.

➞ 𝐁𝐮𝐢𝐥𝐭 an autonomous system that could detect license numbers and automatically open the parking barrier for registered users using MQTT.

➞ 𝐃𝐞𝐯𝐞𝐥𝐨𝐩𝐞𝐝 the Python async notifications microservice for the Android & IOS mobile apps.

Mid-Level Software Developer

⚫️ Smart parking management platform

The client, a local player in the urban parking payment systems, needed to scale its operations into the private sector by building a new parking platform. 

➞ 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝 a suite of unit tests that 𝐝𝐞𝐜𝐫𝐞𝐚𝐬𝐞𝐝 the 𝐝𝐞𝐯𝐞𝐥𝐨𝐩𝐦𝐞𝐧𝐭 𝐭𝐢𝐦𝐞 by 𝟐𝟎%.

➞ 𝐃𝐞𝐯𝐞𝐥𝐨𝐩𝐞𝐝 various Django RESTful API server features, such as new endpoints, serializers, and CRUD operations.

➞ 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝 a real-time business metrics dashboard on the office TV  using Grafana on a Raspberry Pi.

Junior Backend Developer

🤖 Senior Machine Learning Engineer • MLOps • Contractor ~ Helping startups engineer production-ready ML/AI systems.

I am a senior machine learning engineer and contractor with 𝟔+ 𝐲𝐞𝐚𝐫𝐬 𝐨𝐟 𝐞𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞. I design and implement modular, scalable, and production-ready ML systems for startups worldwide.

⭐ My mission is to build data-intensive AI/ML systems that innovate the world.

I am passionate about designing and implementing scalable and modular AI/ML systems using MLOps good practices. With my extensive background in machine learning, software engineering, and mathematics, I can research, architect, build, deploy, test, and monitor clean artificial intelligence solutions that directly impact your business.

🌎 Only open to full remote positions as a contractor.

.

Also, I help machine learning engineers level up through hands-on practical posts, articles, and tutorials on designing and productionizing ML systems.

I actively post about MLE & MLOps on LinkedIn, Medium, and Decoding ML (my weekly Newsletter). Find all my socials here: https://www.pauliusztin.me/

.

About my primary skills:

⚫️ Programming languages:
• Python, SQL, C++, Java

⚫️ Technologies:
• PyTorch, Scikit-Learn, Keras
• NumPy, Pandas, OpenCV, CUDA
• AWS, GCP
• Docker, FastAPI, Airflow, Kafka, Spark
• DVC, Weights & Biases, MLFlow
• PostgreSQL, Elasticsearch, Redis

🟡 MLOps:
• batch & online serving
• code, model & data versioning
• feature & model store
• continuous training & monitoring
• orchestration

⚫️ Machine Learning Engineering:
• structured data: tabular & time series
• unstructured data: images, videos & point clouds
• computer vision
• deep learning
• classic ML
• REST API, gRPC & streaming design
• cloud & microservices
• distributed systems

.

💬 Do you need machine learning solutions for your business? 𝐋𝐞𝐭'𝐬 𝐝𝐢𝐬𝐜𝐮𝐬𝐬!

.

📱 Phone: +40 732 509 516
✉️ Email: p.b.iusztin@gmail.com
💻 GitHub: https://github.com/iusztinpaul
🖋️ Medium:  https://pauliusztin.medium.com
⌨️ Newsletter: https://pauliusztin.substack.com/
🐦 Twitter: https://twitter.com/iusztinpaul

Looking to 𝗯𝗲𝗰𝗼𝗺𝗲 a 𝗣𝗥𝗢 in 𝗟𝗮𝗻𝗴𝗖𝗵𝗮𝗶𝗻? Then 𝗰𝗵𝗲𝗰𝗸 𝗼𝘂𝘁 this 𝗯𝗼𝗼𝗸 on 𝗵𝗮𝗻𝗱𝘀-𝗼𝗻 𝗟𝗮𝗻𝗴𝗖𝗵𝗮𝗶𝗻: from 𝗯𝗲𝗴𝗶𝗻𝗻𝗲𝗿 to 𝗮𝗱𝘃𝗮𝗻𝗰𝗲𝗱 ↓

→ It's called: 𝘎𝘦𝘯𝘦𝘳𝘢𝘵𝘪𝘷𝘦 𝘈𝘐 𝘸𝘪𝘵𝘩 𝘓𝘢𝘯𝘨𝘊𝘩𝘢𝘪𝘯: 𝘉𝘶𝘪𝘭𝘥 𝘓𝘓𝘔 𝘢𝘱𝘱𝘴 𝘸𝘪𝘵𝘩 𝘗𝘺𝘵𝘩𝘰𝘯, 𝘊𝘩𝘢𝘵𝘎𝘗𝘛, 𝘢𝘯𝘥 𝘰𝘵𝘩𝘦𝘳 𝘓𝘓𝘔𝘴 by Ben Auffarth , published by Packt

𝘏𝘦𝘳𝘦 𝘪𝘴 𝘢 𝘴𝘩𝘰𝘳𝘵 𝘣𝘳𝘦𝘢𝘬𝘥𝘰𝘸𝘯:

- It begins with some theoretical chapters on LLMs & LangChain

- It explores the critical components of LangChain: chains, agents, memory, tools

𝗧𝗵𝗲𝗻, 𝗺𝘆 𝗳𝗮𝘃𝗼𝗿𝗶𝘁𝗲 𝗽𝗮𝗿𝘁...

𝗜𝘁 𝗷𝘂𝗺𝗽𝘀 𝗱𝗶𝗿𝗲𝗰𝘁𝗹𝘆 𝗶𝗻𝘁𝗼 𝗵𝗮𝗻𝗱𝘀-𝗼𝗻 𝗲𝘅𝗮𝗺𝗽𝗹𝗲𝘀 - 𝗪𝗜𝗧𝗛 𝗣𝗬𝗧𝗛𝗢𝗡 𝗖𝗢𝗗𝗘 ↓

- takes off with beginner-friendly examples of using LangChain with agents, HuggingFace, GCP/VertexAI, Azure, Anthropic, etc.

- shows an end-to-end example of building a customer services application with LangChain & VertexAI

- how to mitigate hallucinations using the 𝘓𝘓𝘔𝘊𝘩𝘦𝘤𝘬𝘦𝘳𝘊𝘩𝘢𝘪𝘯 class

- how to implement map-reduce pipelines

- how to monitor token usage & costs

- how to extract information from documents such as PDFs

- building a Streamlit interface

- how reasoning works in agent

- building a chatbot like ChatGPT from SCRATCH

.

I haven't finished it yet, but I love it so far —I plan to finish it soon.

.

𝗪𝗵𝗼 𝗶𝘀 𝘁𝗵𝗶𝘀 𝗳𝗼𝗿?

If you are 𝘀𝘁𝗮𝗿𝘁𝗶𝗻𝗴 𝗼𝘂𝘁 in the LLM world, this is a great book to 𝗿𝗲𝗮𝗱 𝗲𝗻𝗱-𝘁𝗼-𝗲𝗻𝗱.

Even if you are 𝗲𝘅𝗽𝗲𝗿𝗶𝗲𝗻𝗰𝗲𝗱, I think it is 𝗲𝘅𝘁𝗿𝗲𝗺𝗲𝗹𝘆 𝘂𝘀𝗲𝗳𝘂𝗹 to 𝘀𝗸𝗶𝗺 𝗶𝘁 to refresh the fundamentals, learn new details, and see how everything is implemented in LangChain.

.

𝗜𝘀 𝘁𝗵𝗶𝘀 𝗳𝗼𝗿 𝘆𝗼𝘂? 🫵

𝗖𝗵𝗲𝗰𝗸 𝗶𝘁 𝗼𝘂𝘁: 🔗 https://lnkd.in/dtbSPnWM

#machinelearning #mlops #datascience

.

💡 Follow me for daily content on production ML and MLOps engineering.

No alternative text description for this image

This is how I 𝗿𝗲𝗱𝘂𝗰𝗲𝗱 the 𝗹𝗮𝘁𝗲𝗻𝗰𝘆 of my 𝗣𝘆𝗧𝗼𝗿𝗰𝗵 𝗰𝗼𝗱𝗲 by 𝟴𝟮% 𝘂𝘀𝗶𝗻𝗴 𝗼𝗻𝗹𝘆 𝗣𝘆𝘁𝗵𝗼𝗻 & 𝗣𝘆𝗧𝗼𝗿𝗰𝗵. 𝗡𝗢 𝗳𝗮𝗻𝗰𝘆 𝘁𝗼𝗼𝗹𝘀 𝗶𝗻𝘃𝗼𝗹𝘃𝗲𝗱! 
 
𝙏𝙝𝙚 𝙥𝙧𝙤𝙗𝙡𝙚𝙢? 
 
During inference, I am using 5 DL at ~25k images at once. 
 
The script took around ~4 hours to run. 
 
The problem is that this isn't a batch job that runs over the night... 
 
Various people across the company required it to run in "real-time" multiple times a day. 
 
𝙏𝙝𝙚 𝙨𝙤𝙡𝙪𝙩𝙞𝙤𝙣? 
 
The first thing that might come to your mind is to start using some fancy optimizer (e.g., TensorRT). 
 
Even though that should be done at some point... 
 
First, you should 𝗮𝘀𝗸 𝘆𝗼𝘂𝗿𝘀𝗲𝗹𝗳: 
 
- I/O bottlenecks: reading & writing images 
- preprocessing & postprocessing - can it be parallelized? 
- are the CUDA cores used at their maximum potential? 
- is the bandwidth between the CPU & GPU throttled? 
- can we move more computation to the GPU? 
 
That being said... 
 
𝗛𝗲𝗿𝗲 is what I did I 𝗱𝗲𝗰𝗿𝗲𝗮𝘀𝗲𝗱 the 𝗹𝗮𝘁𝗲𝗻𝗰𝘆 of the script by 𝟴𝟮%  
 
↓↓↓ 
 
𝟭. 𝗕𝗮𝘁𝗰𝗵𝗲𝗱 𝘁𝗵𝗲 𝗶𝗻𝗳𝗲𝗿𝗲𝗻𝗰𝗲 𝘀𝗮𝗺𝗽𝗹𝗲𝘀 
 
Batching is not only valuable for training but also mighty in speeding up your inference time. 
 
Otherwise, you waste your GPU CUDA cores. 
 
Instead of passing through the models one sample at a time, I now process 64. 
 
𝟮. 𝗟𝗲𝘃𝗲𝗿𝗮𝗴𝗲𝗱 𝗣𝘆𝗧𝗼𝗿𝗰𝗵'𝘀 𝗗𝗮𝘁𝗮𝗟𝗼𝗮𝗱𝗲𝗿 
 
This has 2 main advantages: 
 
- parallel data loading & preprocessing on multiple processes (NOT threads) 
- copying your input images directly into the pinned memory (avoid a CPU -> CPU copy operation) 
 
𝟯. 𝗠𝗼𝘃𝗲𝗱 𝗮𝘀 𝗺𝘂𝗰𝗵 𝗼𝗳 𝘁𝗵𝗲 𝗽𝗼𝘀𝘁𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴 𝗼𝗻 𝘁𝗵𝗲 𝗚𝗣𝗨 
 
I saw that the tensor was moved too early on the CPU and mapped to a NumPy array. 
 
I refactored the code to keep it on the GPU as much as possible, which had 2 main advantages: 
 
- tensors are processed faster on the GPU 
- at the end of the logic, I had smaller tensors, resulting in smaller transfers between the CPU & GPU 
 
𝟰. 𝗠𝘂𝗹𝘁𝗶𝘁𝗵𝗿𝗲𝗮𝗱𝗶𝗻𝗴 𝗳𝗼𝗿 𝗮𝗹𝗹 𝗺𝘆 𝗜/𝗢 𝘄𝗿𝗶𝘁𝗲 𝗼𝗽𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝘀 
 
For I/O bottlenecks, using Python threads is extremely powerful. 
 
I moved all my writes under a 𝘛𝘩𝘳𝘦𝘢𝘥𝘗𝘰𝘰𝘭𝘌𝘹𝘦𝘤𝘶𝘵𝘰𝘳, batching my write operations. 
 
. 
 
Note that I used only good old Python & PyTorch code. 
 
→ When the code is poorly written, no tool can save you 
 
Only now is the time to add fancy tooling, such as TensorRT. 
 
. 
 
So remember... 
 
To optimize the PyTorch code by 82%: 
 
1. Batched the inference samples 
2. Leveraged PyTorch's DataLoader 
3. Moved as much of the postprocessing on the GPU 
4. Multithreading for all my I/O write operations 
 
What other methods do you have in mind? Leave them in the comments ↓ 
 
#machinelearning #mlops #datascience 
 


𝗦𝘁𝗲𝗽-𝗯𝘆-𝘀𝘁𝗲𝗽 𝗴𝘂𝗶𝗱𝗲 to 𝗯𝘂𝗶𝗹𝗱𝗶𝗻𝗴 a 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗟𝗟𝗠 𝘀𝘆𝘀𝘁𝗲𝗺 with 𝟰 𝗣𝘆𝘁𝗵𝗼𝗻 𝗺𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀 using 𝗠𝗟𝗢𝗽𝘀 & the 𝟯-𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 

As an example, you will build a system for an LLM Twin.

But you can use the same strategy for most use cases.

𝘏𝘦𝘳𝘦 𝘪𝘴 𝘵𝘩𝘦 𝘢𝘳𝘤𝘩𝘪𝘵𝘦𝘤𝘵𝘶𝘳𝘦 𝘰𝘧 𝘰𝘶𝘳 𝘓𝘓𝘔 𝘛𝘸𝘪𝘯 ↓

𝟭. 𝗗𝗮𝘁𝗮 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 𝗣𝗶𝗽𝗲𝗹𝗶𝗻𝗲 + 𝗖𝗗𝗖

The 𝗱𝗮𝘁𝗮 𝗰𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲 will crawl your digital data (only yours) from various platforms, such as Medium, Substack, LinkedIn, and GitHub.

- An ETL pipeline for every platform built with 𝘴𝘦𝘭𝘦𝘯𝘪𝘶𝘮 to crawl the data and 𝘉𝘦𝘢𝘶𝘵𝘪𝘧𝘶𝘭 𝘚𝘰𝘶𝘱 to parse the HTML

- The data is loaded into a MongoDB normalized as posts, articles or code

Using 𝗖𝗗𝗖, a watcher will listen to changes made to the MongoDB. 

An event will be added to a RabbitMQ queue during any CRUD operation.

𝟮. 𝗠𝗟 𝗣𝗶𝗽𝗲𝗹𝗶𝗻𝗲𝘀

Here, we will leverage the 3-pipeline architecture and split the ML system into 3 pipelines:

𝗧𝗵𝗲 𝗳𝗲𝗮𝘁𝘂𝗿𝗲 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲

→ A streaming ingestion pipeline using Bytewax as its streaming engine

𝘐𝘯𝘱𝘶𝘵: queue 

𝘖𝘶𝘵𝘱𝘶𝘵: Qdrant (feature store)

- listens to the RabbitMQ queue
- cleans the data and creates a snapshot into Qdrant used for fine-tuning
- chunks and embeds the data for a second snapshot into Qdrant used for RAG

𝗧𝗵𝗲 𝘁𝗿𝗮𝗶𝗻𝗶𝗻𝗴 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲

→ A fine-tuning pipeline using open-source LLMs from Hugging Face

𝘐𝘯𝘱𝘶𝘵: Qdrant (feature store)

𝘖𝘶𝘵𝘱𝘶𝘵: fine-tuned LLM stored in Comet's Model registry

- uses the retrieval client to access your articles, posts, or code
- uses ChatGPT to create a custom Q&A dataset
- fine-tunes the LLM using QLoRA
- logs all the metrics using Comet 's model registry
- picks the best LLM and publishes it to the model registry as the production candidate
- a second evaluation step is performed using an LLM evaluation tool
- if it passes, the LLM is flagged as accepted and deployed to the inference pipeline

𝗧𝗵𝗲 𝗶𝗻𝗳𝗲𝗿𝗲𝗻𝗰𝗲 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲

-> Acts as the RAG real-time client 

𝘐𝘯𝘱𝘶𝘵: fined-tuned LLM from the model registry

𝘖𝘶𝘵𝘱𝘶𝘵: real-time predictions

- loads & quantized the LLM from the model registry
- accepts client requests using a REST API endpoint
- augments the prompt using RAG
- calls the LLM Twin & logs everything to a prompt monitoring tool

.

Ok, ok, that sounds great...

𝗕𝘂𝘁 𝘄𝗵𝗲𝗿𝗲 𝗶𝘀 𝘁𝗵𝗲 𝗰𝗼𝗱𝗲?

Check it out on Decoding ML 's GitHub repository

↓↓↓

🔗 LLM Twin Course: https://lnkd.in/dzat6PB6

#machinelearning #mlops #datascience

I am 𝗾𝘂𝗶𝘁𝘁𝗶𝗻𝗴 𝗰𝗿𝗲𝗮𝘁𝗶𝗻𝗴 𝗰𝗼𝗻𝘁𝗲𝗻𝘁... 𝗝𝗼𝗸𝗶𝗻𝗴, but here is 𝗵𝗼𝘄 to 𝗯𝘂𝗶𝗹𝗱 your 𝗟𝗟𝗠 𝘁𝘄𝗶𝗻 for 𝗴𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗻𝗴 posts or articles 𝘂𝘀𝗶𝗻𝗴 𝘆𝗼𝘂𝗿 𝘃𝗼𝗶𝗰𝗲 ↓

𝗪𝗵𝗮𝘁 𝗶𝘀 𝗮𝗻 𝗟𝗟𝗠 𝘁𝘄𝗶𝗻?

It's an AI character who writes like you, using your writing style and personality.

𝗪𝗵𝘆 𝗻𝗼𝘁 𝗱𝗶𝗿𝗲𝗰𝘁𝗹𝘆 𝘂𝘀𝗲 𝗖𝗵𝗮𝘁𝗚𝗣𝗧? 𝗬𝗼𝘂 𝗺𝗮𝘆 𝗮𝘀𝗸...

When generating content using an LLM, the results tend to:

- be very generic and unarticulated,
- contain misinformation (due to hallucination),
- require tedious prompting to achieve the desired result.

𝗧𝗵𝗮𝘁 𝗶𝘀 𝘄𝗵𝘆, 𝗳𝗼𝗿 𝗴𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗻𝗴 𝗰𝗼𝗻𝘁𝗲𝗻𝘁, 𝘆𝗼𝘂 𝗻𝗲𝗲𝗱 𝗮 𝘀𝗽𝗲𝗰𝗶𝗮𝗹𝗶𝘇𝗲𝗱 𝘁𝗼𝗼𝗹 𝘁𝗵𝗮𝘁:

→ is fine-tuned on your digital content to replicate your persona

→ has access to a vector DB (with relevant data) to avoid hallucinating and write only about concrete facts

.

𝗛𝗲𝗿𝗲 𝗮𝗿𝗲 𝘁𝗵𝗲 𝗺𝗮𝗶𝗻 𝘀𝘁𝗲𝗽𝘀 𝗿𝗲𝗾𝘂𝗶𝗿𝗲𝗱 𝘁𝗼 𝗯𝘂𝗶𝗹𝗱 𝘆𝗼𝘂𝗿 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻-𝗿𝗲𝗮𝗱𝘆 𝗟𝗟𝗠 𝘁𝘄𝗶𝗻:

1. A data collection pipeline will gather your digital data from Medium, Substack, LinkedIn and GitHub. It will be normalized and saved to a Mongo DB.

2. Using CDC, you listen to any changes made to the Mongo DB and add them as events to a RabbitMQ queue.

3. A Bytewax streaming ingestion pipeline will listen to the queue to clean, chunk, and embed the data in real time using Superlinked .

4. The cleaned and embedded data is loaded to a Qdrant vector DB.

5. On the training pipeline side, you use a vector DB retrieval client to build your training dataset, which consists of the cleaned data (augmented using RAG).

6. You fine-tune an open-source Mistral LLM using QLoRA and push all the experiment artifacts to a Comet experiment tracker.

7. Based on the best experiment, you push the LLM candidate to Comet's model registry. You carefully evaluate the LLM candidate using Comet's prompt monitoring dashboard. If the evaluation passes, you tag it as accepted.

8. On the inference pipeline side, you deploy the new LLM model by pulling it from the model registry, loading it, and quantizing it.

9. The inference pipeline is wrapped by a REST API, which allows users to make ChatGPT-like requests.

.

Do you want to learn how to code such a beast? 🫵

Me and Decoding ML are working on a FREE course that will contain:

- 11 written lessons
- open-source code

𝗖𝗵𝗲𝗰𝗸 𝗶𝘁 𝗼𝘂𝘁 𝗼𝗻 𝗚𝗶𝘁𝗛𝘂𝗯 𝗮𝗻𝗱 𝘀𝘂𝗽𝗽𝗼𝗿𝘁 𝘂𝘀 𝘄𝗶𝘁𝗵 𝗮 ⭐️

↓↓↓

🔗 𝘓𝘓𝘔 𝘛𝘸𝘪𝘯 𝘊𝘰𝘶𝘳𝘴𝘦: 𝘉𝘶𝘪𝘭𝘥𝘪𝘯𝘨 𝘠𝘰𝘶𝘳 𝘗𝘳𝘰𝘥𝘶𝘤𝘵𝘪𝘰𝘯-𝘙𝘦𝘢𝘥𝘺 𝘈𝘐 𝘙𝘦𝘱𝘭𝘪𝘤𝘢 GitHub Repository: https://lnkd.in/dY6_Hi9r

#machinelearning #mlops #datascience 


Here are 3 techniques you must know to evaluate your LLMs quickly. 
 
Manually testing the output of your LLMs is a tedious and painful process → you need to automate it. 
 
In generative AI, most of the time, you cannot leverage standard metrics. 
 
Thus, the real question is, how do you evaluate the outputs of an LLM? 
 
#𝟭. 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝗱 𝗮𝗻𝘀𝘄𝗲𝗿𝘀 - 𝘆𝗼𝘂 𝗸𝗻𝗼𝘄 𝗲𝘅𝗮𝗰𝘁𝗹𝘆 𝘄𝗵𝗮𝘁 𝘆𝗼𝘂 𝘄𝗮𝗻𝘁 𝘁𝗼 𝗴𝗲𝘁 
 
Even if you use an LLM to generate text, you can ask it to generate a response in a structured format (e.g., JSON) that can be parsed. 
 
You know exactly what you want (e.g., a list of products extracted from the user's question). 
 
Thus, you can easily compare the generated and ideal answers using classic approaches. 
 
For example, when extracting the list of products from the user's input, you can do the following: 
- check if the LLM outputs a valid JSON structure 
- use a classic method to compare the generated and real answers 
 
#𝟮. 𝗡𝗼 "𝗿𝗶𝗴𝗵𝘁" 𝗮𝗻𝘀𝘄𝗲𝗿 (𝗲.𝗴., 𝗴𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗻𝗴 𝗱𝗲𝘀𝗰𝗿𝗶𝗽𝘁𝗶𝗼𝗻𝘀, 𝘀𝘂𝗺𝗺𝗮𝗿𝗶𝗲𝘀, 𝗲𝘁𝗰.) 
 
When generating sentences, the LLM can use different styles, words, etc. Thus, traditional metrics (e.g., BLUE score) are too rigid to be useful. 
 
You can leverage another LLM to test the output of our initial LLM. The trick is in what questions to ask. 
 
Here, we have another 2 sub scenarios: 
 
↳ 𝟮.𝟭 𝗪𝗵𝗲𝗻 𝘆𝗼𝘂 𝗱𝗼𝗻'𝘁 𝗵𝗮𝘃𝗲 𝗮𝗻 𝗶𝗱𝗲𝗮𝗹 𝗮𝗻𝘀𝘄𝗲𝗿 𝘁𝗼 𝗰𝗼𝗺𝗽𝗮𝗿𝗲 𝘁𝗵𝗲 𝗮𝗻𝘀𝘄𝗲𝗿 𝘁𝗼 (𝘆𝗼𝘂 𝗱𝗼𝗻'𝘁 𝗵𝗮𝘃𝗲 𝗴𝗿𝗼𝘂𝗻𝗱 𝘁𝗿𝘂𝘁𝗵) 
 
You don't have access to an expert to write an ideal answer for a given question to compare it to. 
 
Based on the initial prompt and generated answer, you can compile a set of questions and pass them to an LLM. Usually, these are Y/N questions that you can easily quantify and check the validity of the generated answer. 
 
This is known as "Rubric Evaluation" 
 
For example: 
""" 
- Is there any disagreement between the response and the context? (Y or N) 
- Count how many questions the user asked. (output a number) 
... 
""" 
 
This strategy is intuitive, as you can ask the LLM any question you are interested in as long it can output a quantifiable answer (Y/N or a number). 
 
↳ 𝟮.𝟮. 𝗪𝗵𝗲𝗻 𝘆𝗼𝘂 𝗱𝗼 𝗵𝗮𝘃𝗲 𝗮𝗻 𝗶𝗱𝗲𝗮𝗹 𝗮𝗻𝘀𝘄𝗲𝗿 𝘁𝗼 𝗰𝗼𝗺𝗽𝗮𝗿𝗲 𝘁𝗵𝗲 𝗿𝗲𝘀𝗽𝗼𝗻𝘀𝗲 𝘁𝗼 (𝘆𝗼𝘂 𝗵𝗮𝘃𝗲 𝗴𝗿𝗼𝘂𝗻𝗱 𝘁𝗿𝘂𝘁𝗵) 
 
When you have access to an answer manually created by a group of experts, things are easier. 
 
You will use an LLM to compare the generated and ideal answers based on semantics, not structure. 
 
For example: 
""" 
(A) The submitted answer is a subset of the expert answer and entirely consistent. 
... 
(E) The answers differ, but these differences don't matter. 
""" 
 
#machinelearning #mlops #datascience

The 𝗛𝗮𝗻𝗱𝘀-𝗼𝗻 𝗟𝗟𝗠𝘀 FREE 𝗰𝗼𝘂𝗿𝘀𝗲 passed 2.1k+ ⭐️ on GitHub - the place to 𝗹𝗲𝗮𝗿𝗻 the 𝗳𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀 of 𝗟𝗟𝗠 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 & 𝗟𝗟𝗠𝗢𝗽𝘀 
 
𝘛𝘩𝘦 𝘤𝘰𝘶𝘳𝘴𝘦 𝘪𝘴 𝘵𝘩𝘦 𝘨𝘰-𝘵𝘰 𝘩𝘶𝘣 𝘧𝘰𝘳 𝘭𝘦𝘢𝘳𝘯𝘪𝘯𝘨 𝘵𝘩𝘦 𝘧𝘶𝘯𝘥𝘢𝘮𝘦𝘯𝘵𝘢𝘭𝘴 𝘰𝘧 𝘱𝘳𝘰𝘥𝘶𝘤𝘵𝘪𝘰𝘯-𝘳𝘦𝘢𝘥𝘺 𝘓𝘓𝘔𝘴 & 𝘓𝘓𝘔𝘖𝘱𝘴 
 
It will walk you through an 𝗲𝗻𝗱-𝘁𝗼-𝗲𝗻𝗱 𝗽𝗿𝗼𝗰𝗲𝘀𝘀... 
 
...from data preparation to deployment & monitoring: 
 
- the 3-pipeline design 
- building your custom financial dataset using GPT-4 
- a streaming pipeline to ingest financial news in real-time 
- fine-tuning an LLM using QLoRA 
- building a custom RAG pipeline 
- deploying the streaming pipeline to AWS 
- deploying the training & inference pipelines to Beam 
- using MLOps components: model registries, experiment trackers, prompt monitoring 
 
. 
 
𝗖𝗵𝗲𝗰𝗸 𝗶𝘁 𝗼𝘂𝘁  
 
↓↓↓ 
 
🔗 𝘏𝘢𝘯𝘥𝘴-𝘰𝘯 𝘓𝘓𝘔𝘴 𝘊𝘰𝘶𝘳𝘴𝘦 - 𝘓𝘦𝘢𝘳𝘯 𝘵𝘰 𝘛𝘳𝘢𝘪𝘯 𝘢𝘯𝘥 𝘋𝘦𝘱𝘭𝘰𝘺 𝘢 𝘙𝘦𝘢𝘭-𝘛𝘪𝘮𝘦 𝘍𝘪𝘯𝘢𝘯𝘤𝘪𝘢𝘭 𝘈𝘥𝘷𝘪𝘴𝘰𝘳: https://lnkd.in/dZgqtf8f 
 
#machinelearning #mlops #datascience

The 𝟮𝗻𝗱 𝗟𝗲𝘀𝘀𝗼𝗻 of the FREE 𝗟𝗟𝗠 𝗧𝘄𝗶𝗻 𝗰𝗼𝘂𝗿𝘀𝗲 on 𝗱𝗮𝘁𝗮 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲𝘀, 𝗘𝗧𝗟𝘀, 𝗰𝗿𝗮𝘄𝗹𝗶𝗻𝗴 𝗱𝗮𝘁𝗮 and 𝗔𝗪𝗦 𝗶𝗻𝗳𝗿𝗮𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 is out 🫵

Welcome to the 2nd article written by Alex Vesa of the new FREE hands-on series: 𝘓𝘓𝘔 𝘛𝘸𝘪𝘯 𝘊𝘰𝘶𝘳𝘴𝘦: 𝘉𝘶𝘪𝘭𝘥𝘪𝘯𝘨 𝘠𝘰𝘶𝘳 𝘗𝘳𝘰𝘥𝘶𝘤𝘵𝘪𝘰𝘯-𝘙𝘦𝘢𝘥𝘺 𝘈𝘐 𝘙𝘦𝘱𝘭𝘪𝘤𝘢

𝘛𝘩𝘦 2𝘯𝘥 𝘢𝘳𝘵𝘪𝘤𝘭𝘦 𝘪𝘴 𝘢𝘭𝘭 𝘢𝘣𝘰𝘶𝘵 𝘣𝘶𝘪𝘭𝘥𝘪𝘯𝘨 𝘺𝘰𝘶𝘳 𝘥𝘢𝘵𝘢 𝘦𝘯𝘨𝘪𝘯𝘦𝘦𝘳𝘪𝘯𝘨 𝘱𝘪𝘱𝘦𝘭𝘪𝘯𝘦.

𝗛𝗲𝗿𝗲 𝗶𝘀 𝗮 𝗾𝘂𝗶𝗰𝗸 𝗯𝗿𝗲𝗮𝗸𝗱𝗼𝘄𝗻:

- Data collection process -> Medium, Github, Substack & Linkedin crawlers

- ETL pipelines -> data is cleaned and normalized

- ODM (Object Document Mapping ) -> a technique that maps between an object model in an application and a document database

- NoSQL Database (MongoDB) & CDC (Change Data Capture) pattern

- Tracks data changes, logs them, and queues messages for real-time system updates

.

𝘾𝙪𝙧𝙞𝙤𝙪𝙨?

𝗧𝗵𝗲𝗻 𝘁𝗿𝘆 𝗶𝘁 𝘆𝗼𝘂𝗿𝘀𝗲𝗹𝗳 🫵

↓↓↓

🔗  𝗔𝗿𝘁𝗶𝗰𝗹𝗲 - 𝘛𝘩𝘦 𝘐𝘮𝘱𝘰𝘳𝘵𝘢𝘯𝘤𝘦 𝘰𝘧 𝘋𝘢𝘵𝘢 𝘗𝘪𝘱𝘦𝘭𝘪𝘯𝘦𝘴 𝘪𝘯 𝘵𝘩𝘦 𝘌𝘳𝘢 𝘰𝘧 𝘎𝘦𝘯𝘦𝘳𝘢𝘵𝘪𝘷𝘦 𝘈𝘐: https://lnkd.in/e4ssuhnM

🔗  𝗚𝗶𝘁𝗛𝘂𝗯 𝗥𝗲𝗽𝗼𝘀𝗶𝘁𝗼𝗿𝘆 - 𝘓𝘓𝘔 𝘛𝘸𝘪𝘯 𝘊𝘰𝘶𝘳𝘴𝘦: 𝘉𝘶𝘪𝘭𝘥𝘪𝘯𝘨 𝘠𝘰𝘶𝘳 𝘗𝘳𝘰𝘥𝘶𝘤𝘵𝘪𝘰𝘯-𝘙𝘦𝘢𝘥𝘺 𝘈𝘐 𝘙𝘦𝘱𝘭𝘪𝘤𝘢: https://lnkd.in/dY6_Hi9r

#machinelearning #mlops #datascience







 

Looking for an 𝗲𝗻𝗱-𝘁𝗼-𝗲𝗻𝗱 𝗙𝗥𝗘𝗘 𝗰𝗼𝘂𝗿𝘀𝗲 on 𝗵𝗼𝘄 to 𝗯𝘂𝗶𝗹𝗱 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻-𝗿𝗲𝗮𝗱𝘆 𝗟𝗟𝗠 𝘀𝘆𝘀𝘁𝗲𝗺𝘀? Then 𝗰𝗵𝗲𝗰𝗸 𝗼𝘂𝘁 our 𝟭𝘀𝘁 𝗹𝗲𝘀𝘀𝗼𝗻 ↓ 
 
We recently started 𝗿𝗲𝗹𝗲𝗮𝘀𝗶𝗻𝗴 an 𝗲𝗻𝗱-𝘁𝗼-𝗲𝗻𝗱 𝗰𝗼𝘂𝗿𝘀𝗲 on 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗟𝗟𝗠𝘀 by teaching you how to 𝗯𝘂𝗶𝗹𝗱 an 𝗟𝗟𝗠 𝘁𝘄𝗶𝗻: 𝘠𝘰𝘶𝘳 𝘗𝘳𝘰𝘥𝘶𝘤𝘵𝘪𝘰𝘯-𝘙𝘦𝘢𝘥𝘺 𝘈𝘐 𝘙𝘦𝘱𝘭𝘪𝘤𝘢 
 
𝘛𝘩𝘦 𝘤𝘰𝘶𝘳𝘴𝘦 𝘸𝘪𝘭𝘭 𝘸𝘢𝘭𝘬 𝘺𝘰𝘶 𝘵𝘩𝘳𝘰𝘶𝘨𝘩 𝘢 𝘧𝘶𝘭𝘭-𝘴𝘵𝘢𝘤𝘬 𝘱𝘳𝘰𝘤𝘦𝘴𝘴: 
 
→ from data gathering... 
 
...until deploying and monitoring your LLM twin using LLMOps ← 
 
. 
 
With that in mind... 
 
𝗪𝗲 𝗷𝘂𝘀𝘁 𝗿𝗲𝗹𝗲𝗮𝘀𝗲𝗱 𝘁𝗵𝗲 𝟭𝘀𝘁 𝗹𝗲𝘀𝘀𝗼𝗻 𝘁𝗵𝗮𝘁 𝘄𝗶𝗹𝗹 𝘄𝗮𝗹𝗸 𝘆𝗼𝘂 𝘁𝗵𝗿𝗼𝘂𝗴𝗵: 
 
- the issues of generating content using ChatGPT (or other similar solutions) 
- the 3-pipeline design 
- the system design of the LLM twin 
 
. 
 
Within the 𝘀𝘆𝘀𝘁𝗲𝗺 𝗱𝗲𝘀𝗶𝗴𝗻 𝘀𝗲𝗰𝘁𝗶𝗼𝗻, we will present all the 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗮𝗹 𝗱𝗲𝗰𝗶𝘀𝗶𝗼𝗻𝘀 on 𝗵𝗼𝘄 to 𝗯𝘂𝗶𝗹𝗱: 
 
- a data collection pipeline 
- a real-time feature pipeline using a streaming engine 
- hook the data and feature pipelines using the CDC pattern 
- a continuous fine-tuning pipeline 
- an inference pipeline deployed as a REST API 
 
 
A 𝗽𝗮𝗿𝘁𝗶𝗰𝘂𝗹𝗮𝗿 𝗳𝗼𝗰𝘂𝘀 will be on 𝗶𝗻𝘁𝗲𝗴𝗿𝗮𝘁𝗶𝗻𝗴 𝗠𝗟𝗢𝗽𝘀 & 𝗟𝗟𝗠𝗢𝗽𝘀 𝗴𝗼𝗼𝗱 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲𝘀:  
 
- prompt versioning 
- model registries 
- experiment tracker 
- prompt monitoring 
- CI/CD 
- IaC 
- Docker 
 
. 
 
𝙒𝙖𝙣𝙩 𝙩𝙤 𝙙𝙞𝙜 𝙞𝙣𝙩𝙤 𝙩𝙝𝙚 1𝙨𝙩 𝙡𝙚𝙨𝙨𝙤𝙣? 
 
𝗖𝗵𝗲𝗰𝗸 𝗶𝘁 𝗼𝘂𝘁. It's FREE, and no registration is required 
 
↓↓↓ 
 
🔗  𝘓𝘦𝘴𝘴𝘰𝘯 1 - 𝘈𝘯 𝘌𝘯𝘥-𝘵𝘰-𝘌𝘯𝘥 𝘍𝘳𝘢𝘮𝘦𝘸𝘰𝘳𝘬 𝘧𝘰𝘳 𝘗𝘳𝘰𝘥𝘶𝘤𝘵𝘪𝘰𝘯-𝘙𝘦𝘢𝘥𝘺 𝘓𝘓𝘔 𝘚𝘺𝘴𝘵𝘦𝘮𝘴 𝘣𝘺 𝘉𝘶𝘪𝘭𝘥𝘪𝘯𝘨 𝘠𝘰𝘶𝘳 𝘓𝘓𝘔 𝘛𝘸𝘪𝘯: https://lnkd.in/dwHREJJE 
 
#machinelearning #mlops #datascience 


𝟲 𝘀𝘁𝗲𝗽𝘀 to 𝗯𝘂𝗶𝗹𝗱 your 𝗔𝗪𝗦 𝗶𝗻𝗳𝗿𝗮𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 (using 𝗜𝗮𝗖) and a 𝗖𝗜/𝗖𝗗 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲 that will 𝘄𝗼𝗿𝗸 for 𝟵𝟬% of your 𝗽𝗿𝗼𝗷𝗲𝗰𝘁𝘀 ↓

We will use the data collection pipeline from our free digital twin course as an example, but it can easily be extrapolated to most of your projects.

𝘍𝘪𝘳𝘴𝘵, 𝘭𝘦𝘵'𝘴 𝘴𝘦𝘦 𝘸𝘩𝘢𝘵 𝘪𝘴 𝘪𝘯 𝘰𝘶𝘳 𝘵𝘰𝘰𝘭𝘣𝘦𝘭𝘵:

- Docker
- AWS ECR
- AWS Lambda
- MongoDB
- Pulumni
- GitHub Actions

𝘚𝘦𝘤𝘰𝘯𝘥𝘭𝘺, 𝘭𝘦𝘵'𝘴 𝘲𝘶𝘪𝘤𝘬𝘭𝘺 𝘶𝘯𝘥𝘦𝘳𝘴𝘵𝘢𝘯𝘥 𝘸𝘩𝘢𝘵 𝘵𝘩𝘦 𝘥𝘢𝘵𝘢 𝘤𝘰𝘭𝘭𝘦𝘤𝘵𝘪𝘰𝘯 𝘱𝘪𝘱𝘦𝘭𝘪𝘯𝘦 𝘪𝘴 𝘥𝘰𝘪𝘯𝘨

It automates your digital data collection from LinkedIn, Medium, Substack, and GitHub. The normalized data will be loaded into MongoDB.

𝘕𝘰𝘸, 𝘭𝘦𝘵'𝘴 𝘶𝘯𝘥𝘦𝘳𝘴𝘵𝘢𝘯𝘥 𝘩𝘰𝘸 𝘵𝘩𝘦 𝘈𝘞𝘚 𝘪𝘯𝘧𝘳𝘢𝘴𝘵𝘳𝘶𝘤𝘵𝘶𝘳𝘦 𝘢𝘯𝘥 𝘊𝘐/𝘊𝘋 𝘱𝘪𝘱𝘦𝘭𝘪𝘯𝘦 𝘸𝘰𝘳𝘬𝘴 ↓

1. We wrap the application's entry point with a `𝘩𝘢𝘯𝘥𝘭𝘦(𝘦𝘷𝘦𝘯𝘵, 𝘤𝘰𝘯𝘵𝘦𝘹𝘵: 𝘓𝘢𝘮𝘣𝘥𝘢𝘊𝘰𝘯𝘵𝘦𝘹𝘵)` function. The AWS Lambda serverless computing service will default to the `𝘩𝘢𝘯𝘥𝘭𝘦()` function. 

2. Build a Docker image of your application inheriting the `𝘱𝘶𝘣𝘭𝘪𝘤.𝘦𝘤𝘳.𝘢𝘸𝘴/𝘭𝘢𝘮𝘣𝘥𝘢/𝘱𝘺𝘵𝘩𝘰𝘯:3.11` base Docker image

→ Now, you can quickly check your AWS Lambda function locally by making HTTP requests to your Docker container.

3. Use Pulumni IaC to create your AWS infrastructure programmatically: 

- an ECR as your Docker registry
- an AWS Lambda service
- a MongoDB cluster
- the VPC for the whole infrastructure

4. Now that we have our Docker image and infrastructure, we can build our CI/CD pipeline using GitHub Actions. The first step is to build the Docker image inside the CI and push it to ECR when a new PR is merged into the main branch.

5. On the CD part, we will take the fresh Docker image from ECR and deploy it to AWS Lambda.

6. Repeat the same logic with the Pulumni code → Add a CD GitHub Action that updates the infrastructure whenever the IaC changes.

With 𝘁𝗵𝗶𝘀 𝗳𝗹𝗼𝘄, you will do fine for 𝟵𝟬% of your 𝗽𝗿𝗼𝗷𝗲𝗰𝘁𝘀 🔥

.

𝘛𝘰 𝘴𝘶𝘮𝘮𝘢𝘳𝘪𝘻𝘦, 𝘵𝘩𝘦 𝘊𝘐/𝘊𝘋 𝘸𝘪𝘭𝘭 𝘭𝘰𝘰𝘬 𝘭𝘪𝘬𝘦 𝘵𝘩𝘪𝘴:

feature PR -> merged to main -> build Docker image -> push to ECR -> deploy to AWS Lambda

. 

𝗪𝗮𝗻𝘁 𝘁𝗼 𝗿𝘂𝗻 𝘁𝗵𝗲 𝗰𝗼𝗱𝗲 𝘆𝗼𝘂𝗿𝘀𝗲𝗹𝗳?

Check out 𝗟𝗲𝘀𝘀𝗼𝗻 𝟮 from the FREE 𝗟𝗟𝗠 𝗧𝘄𝗶𝗻 𝗰𝗼𝘂𝗿𝘀𝗲 hosted by @company_decoding-ml

It contains a 𝘀𝘁𝗲𝗽-𝗯𝘆-𝘀𝘁𝗲𝗽 𝗮𝗿𝘁𝗶𝗰𝗹𝗲 & 𝗼𝗽𝗲𝗻-𝘀𝗼𝘂𝗿𝗰𝗲 𝗰𝗼𝗱𝗲.

↓↓↓

🔗 𝘛𝘩𝘦 𝘐𝘮𝘱𝘰𝘳𝘵𝘢𝘯𝘤𝘦 𝘰𝘧 𝘋𝘢𝘵𝘢 𝘗𝘪𝘱𝘦𝘭𝘪𝘯𝘦𝘴 𝘪𝘯 𝘵𝘩𝘦 𝘌𝘳𝘢 𝘰𝘧 𝘎𝘦𝘯𝘦𝘳𝘢𝘵𝘪𝘷𝘦 𝘈𝘐: https://lnkd.in/e4ssuhnM 

#machinelearning #mlops #datascience











𝗠𝗼𝗻𝗶𝘁𝗼𝗿𝗶𝗻𝗴 is 𝗧𝗛𝗘 𝗸𝗲𝘆 𝗠𝗟𝗢𝗽𝘀 𝗲𝗹𝗲𝗺𝗲𝗻𝘁 in ensuring your 𝗺𝗼𝗱𝗲𝗹𝘀 in 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 are 𝗳𝗮𝗶𝗹-𝘀𝗮𝗳𝗲. Here is an 𝗮𝗿𝘁𝗶𝗰𝗹𝗲 on 𝗠𝗟 𝗺𝗼𝗻𝗶𝘁𝗼𝗿𝗶𝗻𝗴 using Triton, Prometheus and Grafana ↓

Alexandru Razvant wrote a fantastic 𝘀𝘁𝗲𝗽-𝗯𝘆-𝘀𝘁𝗲𝗽 𝗮𝗿𝘁𝗶𝗰𝗹𝗲 in Decoding ML on 𝗺𝗼𝗻𝗶𝘁𝗼𝗿𝗶𝗻𝗴 your 𝗗𝗟 𝗺𝗼𝗱𝗲𝗹𝘀 while in 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻.

Within his article, he started with an example where, in one of his projects, a main processing task was supposed to take <5 𝘩𝘰𝘶𝘳𝘴, but while in production, it jumped to >8 𝘩𝘰𝘶𝘳𝘴.

→ 𝘛𝘩𝘪𝘴 (𝘰𝘳 𝘴𝘰𝘮𝘦𝘵𝘩𝘪𝘯𝘨 𝘴𝘪𝘮𝘪𝘭𝘢𝘳) 𝘸𝘪𝘭𝘭 𝘩𝘢𝘱𝘱𝘦𝘯 𝘵𝘰 𝘢𝘭𝘭 𝘰𝘧 𝘶𝘴. 

Even to the greatest.

It's impossible always to anticipate everything that will happen in production (sometimes it is a waste of time even to try to).

That is why you always need eyes and years on your production ML system.

Otherwise, imagine how much $$$ or users he would have lost if he hadn't detected the ~3-4 hours loss in performance as fast as possible. 

.

Afterward, he explained step-by-step how to use:

- 𝗰𝗔𝗱𝘃𝗶𝘀𝗼𝗿 to scrape RAM/CPU usage per container

- 𝗧𝗿𝗶𝘁𝗼𝗻 𝗜𝗻𝗳𝗲𝗿𝗲𝗻𝗰𝗲 𝗦𝗲𝗿𝘃𝗲𝗿 to serve ML models and yield GPU-specific metrics.

- 𝗣𝗿𝗼𝗺𝗲𝘁𝗵𝗲𝘂𝘀 to bind between the metrics generators and the consumer.

- 𝗚𝗿𝗮𝗳𝗮𝗻𝗮 to visualize the metrics

𝗖𝗵𝗲𝗰𝗸 𝗶𝘁 𝗼𝘂𝘁 𝗼𝗻 𝗗𝗲𝗰𝗼𝗱𝗶𝗻𝗴 𝗠𝗟

↓↓↓

🔗 𝘏𝘰𝘸 𝘵𝘰 𝘦𝘯𝘴𝘶𝘳𝘦 𝘺𝘰𝘶𝘳 𝘮𝘰𝘥𝘦𝘭𝘴 𝘢𝘳𝘦 𝘧𝘢𝘪𝘭-𝘴𝘢𝘧𝘦 𝘪𝘯 𝘱𝘳𝘰𝘥𝘶𝘤𝘵𝘪𝘰𝘯? https://lnkd.in/dcNbu9cz

#machinelearning #mlops #datascience

This is how I FAILED to 𝗼𝗽𝘁𝗶𝗺𝗶𝘇𝗲 the 𝗶𝗻𝗳𝗲𝗿𝗲𝗻𝗰𝗲 of my 𝗗𝗟 𝗺𝗼𝗱𝗲𝗹𝘀 when 𝗿𝘂𝗻𝗻𝗶𝗻𝗴 𝘁𝗵𝗲𝗺 on a 𝗡𝘃𝗶𝗱𝗶𝗮 𝗚𝗣𝗨. Let me tell you 𝘄𝗵𝗮𝘁 𝘁𝗼 𝗮𝘃𝗼𝗶𝗱 ↓ 
 
I had a simple task. To reduce the latency of the DL models used in production. 
 
We had 4 DL models that were running on Nvidia GPUs. 
 
After a first look at the inference code, I saw that the inputs to the models weren't batched.  
 
We were processing one sample at a time. 
 
I said to myself: "Ahaa! That's it. I cracked it. We just have to batch as many samples as possible, and we are done." 
 
So, I did just that...  
 
After 2-3 days of work adding the extra batch dimension to the PyTorch preprocessing & postprocessing code, 𝗜 𝗿𝗲𝗮𝗹𝗶𝘇𝗲𝗱 𝗜 𝗪𝗔𝗦 𝗪𝗥𝗢𝗡𝗚. 
 
𝗛𝗲𝗿𝗲 𝗶𝘀 𝘄𝗵𝘆 
 
↓↓↓ 
 
We were using Nvidia GPUs from the A family (A6000, A5000, etc.). 
 
As these GPUs have a lot of memory  (>40GB), I managed to max out the VRAM and squash a batch of 256 images on the GPU. 
 
Relative to using a "𝘣𝘢𝘵𝘤𝘩 = 1" it was faster, but not A LOT FASTER, as I expected. 
 
Then I tried batches of 128, 64, 32, 16, and 8. 
 
...and realized that everything > batch = 16 was running slower than using a batch of 16.  
 
→ 𝗔 𝗯𝗮𝘁𝗰𝗵 𝗼𝗳 𝟭𝟲 𝘄𝗮𝘀 𝘁𝗵𝗲 𝘀𝘄𝗲𝗲𝘁 𝘀𝗽𝗼𝘁. 
 
But that is not good, as I was using only ~10% of the VRAM... 
 
𝗪𝗵𝘆 𝗶𝘀 𝘁𝗵𝗮𝘁? 
 
The Nvidia A family of GPUs are known to: 
 
- having a lot of VRAM 
- not being very fast (the memory transfer between the CPU & GPU + the number of CUDA cores isn't that great) 
 
That being said, my program was throttled. 
 
Even if my GPU could handle much more memory-wise, the memory transfer & processing speeds weren't keeping up. 
 
In the end, it was a good optimization: ~75% faster 
 
𝗕𝘂𝘁 𝘁𝗵𝗲 𝗹𝗲𝘀𝘀𝗼𝗻 𝗼𝗳 𝘁𝗵𝗶𝘀 𝘀𝘁𝗼𝗿𝘆 𝗶𝘀: 
 
→ ALWAYS KNOW YOUR HARDWARE ← 
 
Most probably, running a bigger batch on an A100 or V100 wouldn't have the same problem. 
 
I plan to try that. 
 
But that is why... 
 
→ 𝙮𝙤𝙪 𝙖𝙡𝙬𝙖𝙮𝙨 𝙝𝙖𝙫𝙚 𝙩𝙤 𝙤𝙥𝙩𝙞𝙢𝙞𝙯𝙚 𝙩𝙝𝙚 𝙥𝙖𝙧𝙖𝙢𝙚𝙩𝙚𝙧𝙨 𝙤𝙛 𝙮𝙤𝙪𝙧 𝙨𝙮𝙨𝙩𝙚𝙢 𝙗𝙖𝙨𝙚𝙙 𝙤𝙣 𝙮𝙤𝙪𝙧 𝙝𝙖𝙧𝙙𝙬𝙖𝙧𝙚! 
 
. 
 
In theory, I knew this, but it is completely different when you encounter it in production. 
 
Let me know in the comments if you want more similar stories on "DO NOTs" from my experience. 
 
#machinelearning #mlops #datascience 
 
. 
 
💡 Follow me for daily content on production ML and MLOps engineering.

𝗕𝗮𝘁𝗰𝗵 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 are the 𝗽𝗮𝘀𝘁. Here is how to 𝘄𝗿𝗶𝘁𝗲 a 𝘀𝘁𝗿𝗲𝗮𝗺𝗶𝗻𝗴 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝘀𝘆𝘀𝘁𝗲𝗺 for 𝗥𝗔𝗚 on 𝘀𝗼𝗰𝗶𝗮𝗹 𝗺𝗲𝗱𝗶𝗮 𝗱𝗮𝘁𝗮 ↓

𝗪𝗵𝘆 𝘀𝘁𝗿𝗲𝗮𝗺𝗶𝗻𝗴 𝗼𝘃𝗲𝗿 𝗯𝗮𝘁𝗰𝗵?

In environments where data evolves quickly (e.g., social media platforms), the system's response time is critical for your application's user experience.

That is why TikTok is so addicting. Its recommender system adapts in real-time based on your interaction with the app.

How would it be if the recommendations were updated daily or hourly?

Well, it would work, but you would probably get bored of the app much faster.

The same applies to RAG for highly intensive data sources...

→ where you must sync your source and vector DB in real time for up-to-date retrievals.

.

I wrote a 𝘀𝘁𝗲𝗽-𝗯𝘆-𝘀𝘁𝗲𝗽 𝘁𝘂𝘁𝗼𝗿𝗶𝗮𝗹 on 𝗩𝗲𝗰𝘁𝗼𝗿𝗛𝘂𝗯 by Superlinked (the best place to learn about VectorDBs & RAG). 

𝙃𝙚𝙧𝙚 𝙞𝙨 𝙖 𝙦𝙪𝙞𝙘𝙠 𝙗𝙧𝙚𝙖𝙠𝙙𝙤𝙬𝙣.

↓↓↓

The 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝘀𝘆𝘀𝘁𝗲𝗺 is based on 𝟮 𝗱𝗲𝘁𝗮𝗰𝗵𝗲𝗱 𝗰𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁𝘀:
- the streaming ingestion pipeline
- the retrieval client

The 𝘀𝘁𝗿𝗲𝗮𝗺𝗶𝗻𝗴 𝗶𝗻𝗴𝗲𝘀𝘁𝗶𝗼𝗻 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲 runs 24/7 to keep the vector DB synced with the current raw LinkedIn posts data source.

The 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗰𝗹𝗶𝗲𝗻𝘁 is used in RAG applications to query the vector DB.

→ These 2 components are completely decoupled and communicate with each other through the vector DB.

#𝟭. 𝗧𝗵𝗲 𝘀𝘁𝗿𝗲𝗮𝗺𝗶𝗻𝗴 𝗶𝗻𝗴𝗲𝘀𝘁𝗶𝗼𝗻 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲

→ Implemented in Bytewax - a streaming engine built in Rust (speed& reliability) that exposes a Python interface

𝘔𝘢𝘪𝘯 𝘧𝘭𝘰𝘸:

- uses CDC to add changes from the source DB to a queue
- listens to the queue for new events
- cleans, chunks, and embeds the LI posts
- loads them to a Qdrant vector DB

and... everything in real-time!

#𝟮. 𝗧𝗵𝗲 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗰𝗹𝗶𝗲𝗻𝘁

→ A standard Python module.

The goal is to retrieve similar posts using a variety of query types - e.g., posts, questions, sentences.

𝘔𝘢𝘪𝘯 𝘧𝘭𝘰𝘸:

- preprocess user queries (the same way as they were ingested)
- search the Qdrant vector DB for the most similar results
- use rerank to improve the retrieval system's accuracy
- visualize the results on a 2D plot using UMAP

.

𝗪𝗮𝗻𝘁 𝘁𝗼 𝘀𝗲𝗲 𝘁𝗵𝗲 𝗰𝗼𝗱𝗲? 🫵

𝗖𝗵𝗲𝗰𝗸 𝗶𝘁 𝗼𝘂𝘁 on 𝗩𝗲𝗰𝘁𝗼𝗿𝗛𝘂𝗯...

...along a step-by-step 𝘁𝘂𝘁𝗼𝗿𝗶𝗮𝗹 on how to build a full-fledged 𝘀𝘁𝗿𝗲𝗮𝗺𝗶𝗻𝗴 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲 using only 𝗣𝘆𝘁𝗵𝗼𝗻.

↓↓↓ 

🔗 𝘈 𝘙𝘦𝘢𝘭-𝘵𝘪𝘮𝘦 𝘙𝘦𝘵𝘳𝘪𝘦𝘷𝘢𝘭 𝘚𝘺𝘴𝘵𝘦𝘮 𝘧𝘰𝘳 𝘚𝘰𝘤𝘪𝘢𝘭 𝘔𝘦𝘥𝘪𝘢 𝘋𝘢𝘵𝘢: https://lnkd.in/dVYqj8Rd

#machinelearning #mlops #datascience

Here is the 𝘁𝗲𝗰𝗵 𝘀𝘁𝗮𝗰𝗸 used to 𝗯𝘂𝗶𝗹𝗱 a 𝗖𝗵𝗮𝗻𝗴𝗲 𝗗𝗮𝘁𝗮 𝗖𝗮𝗽𝘁𝘂𝗿𝗲 (𝗖𝗗𝗖) 𝗰𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁 for implementing an 𝗲𝘃𝗲𝗻𝘁-𝗱𝗿𝗶𝘃𝗲𝗻 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 in our 𝗟𝗟𝗠 𝗧𝘄𝗶𝗻 𝗰𝗼𝘂𝗿𝘀𝗲

𝗪𝗵𝗮𝘁 𝗶𝘀 𝗖𝗵𝗮𝗻𝗴𝗲 𝗗𝗮𝘁𝗮 𝗖𝗮𝗽𝘁𝘂𝗿𝗲 (𝗖𝗗𝗖)?

The purpose of CDC is to capture insertions, updates, and deletions applied to a database and to make this change data available in a format easily consumable by downstream applications.

𝗪𝗵𝘆 𝗱𝗼 𝘄𝗲 𝗻𝗲𝗲𝗱 𝗖𝗗𝗖 𝗽𝗮𝘁𝘁𝗲𝗿𝗻?

- Real-time Data Syncing
- Efficient Data Pipelines
- Minimized System Impact
- Event-Driven Architectures

𝗪𝗵𝗮𝘁 𝗱𝗼 𝘄𝗲 𝗻𝗲𝗲𝗱 𝗳𝗼𝗿 𝗮𝗻 𝗲𝗻𝗱-𝘁𝗼-𝗲𝗻𝗱 𝗶𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁𝗮𝘁𝗶𝗼𝗻 𝗼𝗳 𝗖𝗗𝗖?

We will take the tech stack used in our LLM Twin course as an example, where...

... we built a feature pipeline to gather cleaned data for fine-tuning and chunked & embedded data for RAG

𝗘𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 𝘄𝗶𝗹𝗹 𝗯𝗲 𝗱𝗼𝗻𝗲 𝗼𝗻𝗹𝘆 𝗶𝗻 𝗣𝘆𝘁𝗵𝗼𝗻! 

𝘏𝘦𝘳𝘦 𝘵𝘩𝘦𝘺 𝘢𝘳𝘦

↓↓↓

1. 𝗧𝗵𝗲 𝘀𝗼𝘂𝗿𝗰𝗲 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲: MongoDB (it (also works for most databases such as MySQL, PostgreSQL, Oracle, etc.)

2. 𝗔 𝘁𝗼𝗼𝗹 𝘁𝗼 𝗺𝗼𝗻𝗶𝘁𝗼𝗿 𝘁𝗵𝗲 𝘁𝗿𝗮𝗻𝘀𝗮𝗰𝘁𝗶𝗼𝗻 𝗹𝗼𝗴: MongoDB Watcher (also Debezium is a popular & scalable solution)

3. 𝗔 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝗾𝘂𝗲𝘂𝗲: RabbitMQ (another popular option is to use Kafka, but it was overkill in our use case)

4. 𝗔 𝘀𝘁𝗿𝗲𝗮𝗺𝗶𝗻𝗴 𝗲𝗻𝗴𝗶𝗻𝗲: Bytewax (great streaming engine for the Python ecosystem)

5. 𝗔 𝘀𝗼𝘂𝗿𝗰𝗲 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲: Qdrant (this works with any other database, but we needed a vector DB to store our data for fine-tuning and RAG)

.

𝘍𝘰𝘳 𝘦𝘹𝘢𝘮𝘱𝘭𝘦, 𝘩𝘦𝘳𝘦 𝘪𝘴 𝘩𝘰𝘸 𝘢 𝘞𝘙𝘐𝘛𝘌 𝘰𝘱𝘦𝘳𝘢𝘵𝘪𝘰𝘯 𝘸𝘪𝘭𝘭 𝘣𝘦 𝘱𝘳𝘰𝘤𝘦𝘴𝘴𝘦𝘥:

1. Write a post to the MongoDB warehouse
2. A "𝘤𝘳𝘦𝘢𝘵𝘦" operation is logged in the transaction log of Mongo
3. The MongoDB watcher captures this and emits it to the RabbitMQ queue
4. The Bytewax streaming pipelines reads the event from the queue
5. It cleans, chunks, and embeds it right away - in real time!
6. The cleaned & embedded version of the post is written to Qdrant


.

𝘞𝘢𝘯𝘵 𝘵𝘰 𝘴𝘦𝘦 𝘢 𝘩𝘢𝘯𝘥𝘴-𝘰𝘯 𝘪𝘮𝘱𝘭𝘦𝘮𝘦𝘯𝘵𝘢𝘵𝘪𝘰𝘯 𝘰𝘧 𝘵𝘩𝘦 𝘵𝘰𝘰𝘭𝘴 𝘥𝘦𝘴𝘤𝘳𝘪𝘣𝘦𝘥 𝘢𝘣𝘰𝘷𝘦?

𝗖𝗵𝗲𝗰𝗸 𝗼𝘂𝘁 𝗟𝗲𝘀𝘀𝗼𝗻 𝟯 𝗼𝗳 𝘁𝗵𝗲 𝗟𝗟𝗠 𝗧𝘄𝗶𝗻 𝗰𝗼𝘂𝗿𝘀𝗲 𝗽𝗼𝘄𝗲𝗿𝗲𝗱 𝗯𝘆 Decoding ML

𝘐𝘵'𝘴 𝘍𝘙𝘌𝘌

↓↓↓

🔗 𝘊𝘩𝘢𝘯𝘨𝘦 𝘋𝘢𝘵𝘢 𝘊𝘢𝘱𝘵𝘶𝘳𝘦: 𝘌𝘯𝘢𝘣𝘭𝘪𝘯𝘨 𝘌𝘷𝘦𝘯𝘵-𝘋𝘳𝘪𝘷𝘦𝘯 𝘈𝘳𝘤𝘩𝘪𝘵𝘦𝘤𝘵𝘶𝘳𝘦𝘴: https://lnkd.in/d3RdPCN7

#machinelearning #mlops #datascience

.

💡 Follow me for daily content on production ML and MLOps engineering.




What is the 𝗯𝗲𝘀𝘁 𝘁𝗼𝗼𝗹 to 𝗼𝗿𝗴𝗮𝗻𝗶𝘇𝗲 and 𝗹𝗼𝗮𝗱 your 𝗠𝗟 𝗰𝗼𝗻𝗳𝗶𝗴𝘂𝗿𝗮𝘁𝗶𝗼𝗻 𝗳𝗶𝗹𝗲𝘀? 𝗛𝘆𝗱𝗿𝗮 🐉  → Here is a 𝗾𝘂𝗶𝗰𝗸 𝗴𝘂𝗶𝗱𝗲 to 𝗴𝗲𝘁 𝘆𝗼𝘂 𝘀𝘁𝗮𝗿𝘁𝗲𝗱.

𝗧𝗵𝗲 𝗽𝗿𝗼𝗯𝗹𝗲𝗺? 

The bigger the ML projects get, the harder it gets to keep them organized.

That's where the magic of proper configuration management comes in.

Configuration files are present in every stage of your ML pipelines:

- data
- features
- training
- inference

Managing complex configurations is a must-have rather than a nice-to-have.

For complex projects, it is as critical as versioning your data or models.

𝗧𝗵𝗲 𝘀𝗼𝗹𝘂𝘁𝗶𝗼𝗻?

→ 𝙃𝙮𝙙𝙧𝙖 

.

Alexandru Razvant compiled 𝗮 𝗾𝘂𝗶𝗰𝗸 𝗴𝘂𝗶𝗱𝗲 for you on  Decoding ML that 𝘄𝗶𝗹𝗹 𝗴𝗲𝘁 𝘆𝗼𝘂 𝘀𝘁𝗮𝗿𝘁𝗲𝗱 with 𝗛𝘆𝗱𝗿𝗮 on 𝗵𝗼𝘄 to:

- structure your project to use it
- define your config files 
- use it in your Python code
- leverage the flexibility of Hydra

𝘌𝘷𝘦𝘳𝘺𝘵𝘩𝘪𝘯𝘨 𝘺𝘰𝘶 𝘯𝘦𝘦𝘥 𝘵𝘰 𝘴𝘵𝘢𝘳𝘵 𝘵𝘳𝘺𝘪𝘯𝘨 𝘪𝘵 𝘺𝘰𝘶𝘳𝘴𝘦𝘭𝘧 𝘪𝘯 𝘺𝘰𝘶𝘳 𝘱𝘳𝘰𝘫𝘦𝘤𝘵𝘴  🫵

.

To find out more...

𝗖𝗵𝗲𝗰𝗸 𝗶𝘁 𝗼𝘂𝘁 

↓↓↓

🔗 Mastering ML Configurations by leveraging OmegaConf and Hydra: https://lnkd.in/dKkE9hPD

#machinelearning #mlops #datascience

𝗕𝘂𝗶𝗹𝗱, 𝗱𝗲𝗽𝗹𝗼𝘆 to 𝗔𝗪𝗦, 𝗜𝗮𝗖, and 𝗖𝗜/𝗖𝗗 for a 𝗱𝗮𝘁𝗮 𝗰𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲 that 𝗰𝗿𝗮𝘄𝗹𝘀 your 𝗱𝗶𝗴𝗶𝘁𝗮𝗹 𝗱𝗮𝘁𝗮 → 𝗪𝗵𝗮𝘁 do you need 🤔

𝗧𝗵𝗲 𝗲𝗻𝗱 𝗴𝗼𝗮𝗹? 

𝘈 𝘴𝘤𝘢𝘭𝘢𝘣𝘭𝘦 𝘥𝘢𝘵𝘢 𝘱𝘪𝘱𝘦𝘭𝘪𝘯𝘦 𝘵𝘩𝘢𝘵 𝘤𝘳𝘢𝘸𝘭𝘴, 𝘤𝘰𝘭𝘭𝘦𝘤𝘵𝘴, 𝘢𝘯𝘥 𝘴𝘵𝘰𝘳𝘦𝘴 𝘢𝘭𝘭 𝘺𝘰𝘶𝘳 𝘥𝘪𝘨𝘪𝘵𝘢𝘭 𝘥𝘢𝘵𝘢 𝘧𝘳𝘰𝘮:

- LinkedIn
- Medium
- Substack
- Github

𝗧𝗼 𝗯𝘂𝗶𝗹𝗱 𝗶𝘁 - 𝗵𝗲𝗿𝗲 𝗶𝘀 𝘄𝗵𝗮𝘁 𝘆𝗼𝘂 𝗻𝗲𝗲𝗱 ↓

𝟭. 𝗦𝗲𝗹𝗲𝗻𝗶𝘂𝗺: a Python tool for automating web browsers. It’s used here to interact with web pages programmatically (like logging into LinkedIn, navigating through profiles, etc.)

𝟮. 𝗕𝗲𝗮𝘂𝘁𝗶𝗳𝘂𝗹𝗦𝗼𝘂𝗽: a Python library for parsing HTML and XML documents. It creates parse trees that help us extract the data quickly.

𝟯. 𝗠𝗼𝗻𝗴𝗼𝗗𝗕 (𝗼𝗿 𝗮𝗻𝘆 𝗼𝘁𝗵𝗲𝗿 𝗡𝗼𝗦𝗤𝗟 𝗗𝗕): a NoSQL database fits like a glove on our unstructured text data

𝟰. 𝗔𝗻 𝗢𝗗𝗠:  a technique that maps between an object model in an application and a document database

𝟱. 𝗗𝗼𝗰𝗸𝗲𝗿 & 𝗔𝗪𝗦 𝗘𝗖𝗥: to deploy our code, we have to containerize it, build an image for every change of the main branch, and push it to AWS ECR

𝟲. 𝗔𝗪𝗦 𝗟𝗮𝗺𝗯𝗱𝗮: we will deploy our Docker image to AWS Lambda - a serverless computing service that allows you to run code without provisioning or managing servers. It executes your code only when needed and scales automatically, from a few daily requests to thousands per second

𝟳. 𝗣𝘂𝗹𝘂𝗺𝗻𝗶: IaC tool used to programmatically create the AWS infrastructure: MongoDB instance, ECR, Lambdas and the VPC

𝟴. 𝗚𝗶𝘁𝗛𝘂𝗯 𝗔𝗰𝘁𝗶𝗼𝗻𝘀: used to build our CI/CD pipeline - on any merged PR to the main branch, it will build & push a new Docker image and deploy it to the AWS Lambda service

.

𝘾𝙪𝙧𝙞𝙤𝙪𝙨 𝙝𝙤𝙬 𝙩𝙝𝙚𝙨𝙚 𝙩𝙤𝙤𝙡𝙨 𝙬𝙤𝙧𝙠 𝙩𝙤𝙜𝙚𝙩𝙝𝙚𝙧?

Then...

↓↓↓

Check out 𝗟𝗲𝘀𝘀𝗼𝗻 𝟮 from the FREE 𝗟𝗟𝗠 𝗧𝘄𝗶𝗻 𝗖𝗼𝘂𝗿𝘀𝗲 created by Decoding ML

...where we will walk you 𝘀𝘁𝗲𝗽-𝗯𝘆-𝘀𝘁𝗲𝗽 through the 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 and 𝗰𝗼𝗱𝗲 of the 𝗱𝗮𝘁𝗮 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲:

🔗 𝘛𝘩𝘦 𝘐𝘮𝘱𝘰𝘳𝘵𝘢𝘯𝘤𝘦 𝘰𝘧 𝘋𝘢𝘵𝘢 𝘗𝘪𝘱𝘦𝘭𝘪𝘯𝘦𝘴 𝘪𝘯 𝘵𝘩𝘦 𝘌𝘳𝘢 𝘰𝘧 𝘎𝘦𝘯𝘦𝘳𝘢𝘵𝘪𝘷𝘦 𝘈𝘐: https://lnkd.in/e4ssuhnM

#machinelearning #mlops #datascience



Exciting news 🔥  I was invited by Maven to speak in their Lighting Lesson series about how to 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁 𝗬𝗼𝘂𝗿 𝗟𝗟𝗠 𝗧𝘄𝗶𝗻. This 30-min session is for ML & MLOps engineers who want to learn:

𝗟𝗟𝗠 𝗦𝘆𝘀𝘁𝗲𝗺 𝗱𝗲𝘀𝗶𝗴𝗻 𝗼𝗳 𝘆𝗼𝘂𝗿 𝗟𝗟𝗠 𝗧𝘄𝗶𝗻
→ Using the 3-pipeline architecture & MLOps good practices

𝗗𝗲𝘀𝗶𝗴𝗻 𝗮 𝗱𝗮𝘁𝗮 𝗰𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲
→ data crawling, ETLs, CDC, AWS

𝗗𝗲𝘀𝗶𝗴𝗻 𝗮 𝗳𝗲𝗮𝘁𝘂𝗿𝗲 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲
→ streaming engine in Python, data ingestion for fine-tuning & RAG, vector DBs

𝗗𝗲𝘀𝗶𝗴𝗻 𝗮 𝘁𝗿𝗮𝗶𝗻𝗶𝗻𝗴 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲
→ create a custom dataset, fine-tuning, model registries, experiment trackers, LLM evaluation

𝗗𝗲𝘀𝗶𝗴𝗻 𝗮𝗻 𝗶𝗻𝗳𝗲𝗿𝗲𝗻𝗰𝗲 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲
→ real-time deployment, REST API, RAG, LLM monitoring

↓↓↓

Join LIVE on 𝘍𝘳𝘪, 𝘔𝘢𝘺 3! 

Register here (it’s free) → https://bit.ly/3PZGV0S

#machinelearning #mlops #datascience

.

💡 Follow me for daily content on production ML and MLOps engineering.

Open article: Architect Your LLM Twin by maven.com • 1 min read

The 𝗗𝗲𝗰𝗼𝗱𝗶𝗻𝗴 𝗠𝗟 𝗡𝗲𝘄𝘀𝗹𝗲𝘁𝘁𝗲𝗿 is 𝗴𝗿𝗼𝘄𝗶𝗻𝗴 𝗳𝗮𝘀𝘁! We passed 𝟱.𝟳𝗸+ 𝘀𝘂𝗯𝘀𝗰𝗿𝗶𝗯𝗲𝗿𝘀, with a 𝗺𝗼𝗻𝘁𝗵𝗹𝘆 𝗿𝗮𝘁𝗲 of ~𝟭𝗸 𝘀𝘂𝗯𝘀𝗰𝗿𝗶𝗯𝗲𝗿𝘀/𝗺𝗼𝗻𝘁𝗵 (in the last 3 months)

~ One year ago, I started the newsletter as an experiment. I redirect the best of my LinkedIn content, packed nicely, straight to people's inboxes.

→ I wrote a lot of content on LinkedIn about 𝗠𝗟 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴, 𝗠𝗟𝗢𝗽𝘀, and 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗠𝗟, so I had a lot of good stuff to share.

.

Initially, I was excited about my first 100 subscribers.

I told myself, "Wow, people are curious about my content."

In the first 9 months, I spent ~30-60 minutes weekly to sustain it.

.

🍾 After it grew to 2.5k followers with an opening ratio of >50% I realized it's true potential and started to grant it more attention.

So, I wanted to scale: 

1. Brough 2 co-founders with 10+ years of experience in building AI systems in the Decoding ML team: Alex Vesa , Alexandru Razvant

2. Started posting x2 a week: on Thursday, a hands-on article, and on Saturday, an article packed with ML insights

3. ...and, of course, we continually improved our craft!

I am excited it worked out.

But this is just the beginning 🔥

.


🙏🏻 Thank you to all the people who are subscribing to Decoding ML and making this possible.

We promise we will 𝗼𝗻𝗹𝘆 𝗴𝗲𝘁 𝗯𝗲𝘁𝘁𝗲𝗿 and 𝗰𝗿𝗲𝗮𝘁𝗲 𝗯𝗲𝘁𝘁𝗲𝗿 𝗰𝗼𝗻𝘁𝗲𝗻𝘁 𝗳𝗼𝗿 𝘆𝗼𝘂 on 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗠𝗟 & 𝗠𝗟𝗢𝗽𝘀.

.

In case you are looking for...

...𝗯𝗮𝘁𝘁𝗹𝗲-𝘁𝗲𝘀𝘁𝗲𝗱 𝗰𝗼𝗻𝘁𝗲𝗻𝘁 on 𝗱𝗲𝘀𝗶𝗴𝗻𝗶𝗻𝗴, 𝗰𝗼𝗱𝗶𝗻𝗴, and 𝗱𝗲𝗽𝗹𝗼𝘆𝗶𝗻𝗴 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻-𝗴𝗿𝗮𝗱𝗲 𝗠𝗟 & 𝗠𝗟𝗢𝗽𝘀 𝘀𝘆𝘀𝘁𝗲𝗺𝘀. Every week. For FREE.

𝗝𝗼𝗶𝗻 𝘁𝗵𝗲 𝗗𝗲𝗰𝗼𝗱𝗶𝗻𝗴 𝗠𝗟 𝗡𝗲𝘄𝘀𝗹𝗲𝘁𝘁𝗲𝗿

↓↓↓

🔗 𝘋𝘦𝘤𝘰𝘥𝘪𝘯𝘨 𝘔𝘓 𝘕𝘦𝘸𝘴𝘭𝘦𝘵𝘵𝘦𝘳: https://lnkd.in/dQpjSXKc

#machinelearning #mlops #datascience

.

💡 Follow me for daily content on production ML and MLOps engineering.



𝗖𝗼𝗺𝗽𝘂𝘁𝗲𝗿 𝘀𝗰𝗶𝗲𝗻𝗰𝗲 𝗶𝘀 𝗱𝗲𝗮𝗱. Do this instead. 
 
In a recent talk, Jensen Huang, CEO of Nvidia, said that kids shouldn't learn programming anymore. 
 
He said that until now, most of us thought that everyone should learn to program at some point. 
 
But the actual opposite is the truth. 
 
With the rise of AI, nobody should have or need to learn to program anymore. 
 
He highlights that with AI tools, the technology divide between non-programmers and engineers is closing. 
 
. 
 
𝗔𝘀 𝗮𝗻 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿, 𝗺𝘆 𝗲𝗴𝗼 𝗶𝘀 𝗵𝘂𝗿𝘁; 𝗺𝘆 𝗳𝗶𝗿𝘀𝘁 𝗿𝗲𝗮𝗰𝘁𝗶𝗼𝗻 𝗶𝘀 𝘁𝗼 𝘀𝗮𝘆 𝗶𝘁 𝗶𝘀 𝘀𝘁𝘂𝗽𝗶𝗱. 
 
But after thinking about it more thoroughly, I tend to agree with him. 
 
After all, even now, almost anybody can work with AI. 
 
This probably won't happen in the next 10 years, but at some point, 100% will do. 
 
At some point, we will ask our AI companion to write a program that does X for us or whatever. 
 
But, I think this is a great thing, as it will give us more time & energy to focus on what matters, such as: 
 
- solving real-world problems (not just tech problems) 
- moving to the next level of technology (Bioengineering, interplanetary colonization, etc.)  
- think about the grand scheme of things 
- be more creative  
- more time to connect with our family 
- more time to take care of our   
 
I personally think it is a significant step for humanity. 
 
. 
 
What do you think? 
 
As an engineer, do you see your job still present in the next 10+ years? 
 
Here is the full talk 
 
↓↓↓ 
 
🔗 A Conversation with the Founder of NVIDIA: Who Will Shape the Future of AI? https://lnkd.in/duxK_t2C 
 
#machinelearning #mlops #datascience

Open video: A Conversation with the Founder of NVIDIA: Who Will Shape the Future of AI? on youtube.com

A Conversation with the Founder of NVIDIA: Who Will Shape the Future of AI?

Today, I asked my girlfriend: “How old am I? 24?” She answered: “No boy... You are 27.”

Where did the 3 years go? I guess that is what happens when you are working in AI 😂

Anyhow, I am happy that I still feel like I am in my early 20s 🔥

P.S. I always forget how old I am. With the latest research on aging, I hope soon we can genuinely say that when we are 452 years old, that age is just a number. 

#life #worklifebalance #machinelearning

Taplio

Paul Iusztin's Linkedin Analytics

Paul Iusztin

What is Paul talking about?

Who is engaging with Paul

Paul Iusztin's Best Posts (last 30 days)

Want to drive more opportunities from LinkedIn?

Taplio

.css-1jgreyo{background-image:linear-gradient(284deg, rgba(39,43,72,1) 0%, rgba(33,47,183,1) 100%);color:transparent;-webkit-background-clip:text;background-clip:text;}Paul Iusztin's Linkedin Analytics

Paul Iusztin

What is Paul talking about?

Who is engaging with Paul

Paul Iusztin's Best Posts .css-qqfgvy{font-size:var(--chakra-fontSizes-md);}(last 30 days)

Want to drive more opportunities from LinkedIn?

Paul Iusztin's Linkedin Analytics

Paul Iusztin's Best Posts (last 30 days)