Jeffrey Monsalve Cardenas

As many go down the "agentic path", we're choosing a different path.....graph path traversals! 🔵->🟨->🟢 Graph path traversals use vector similarity and/or relationships of your choosing to walk a graph and enable LLMs to explain complex concepts and relationships. This example walks a path and automatically generates an explanation of the network in the form of a short article. Paths can be set directly (i.e. Roman Empire -> Reasons for collapse) or inferred from a query (Tell me the reasons why the Roman Empire collapsed). Learn more here: https://lnkd.in/evdB5HgN

8

Connecting datasets and models in machine learning can feel like trying to fit mismatched puzzle pieces together. Watch this lightning talk with Jacob Marks where he dives into how the seamless integration between Hugging Face and FiftyOne makes data-model co-development a breeze. 🚀 You'll learn how to: ⚡ Download and visualize datasets from the Hugging Face hub with FiftyOne ⚡ Apply state-of-the-art transformer models directly to your data ⚡ Effortlessly share your datasets with others Watch now to see how to simplify and supercharge your machine learning workflows! https://hubs.ly/Q02GnJ5K0 #MachineLearning #DataScience #ComputerVision #VisualAI #AI

6

Stuck in A/B testing purgatory? ⏰ There's a better way. Reinforcement learning (RL) personalizes user experiences in real-time, ditching the wait for statistical significance. RL handles complex interactions & learns from smaller data sets, leading to faster results & higher conversions. #CRO #MachineLearning #ExperienceOptimization #UX https://lnkd.in/g4iY6AGS

2

Let's evaluate Llama3's RAG performance on an arXiv paper (about RAG evaluation, this is a very meta notebook, puns intended)! In this tutorial, we build on our work earlier this week in combining Unstructured's API for pdf document preprocessing with OpenAI's GPT-4o + ragas for evaluation, Hugging Face for Llama3, and LangChain to integrate all of these systems to evaluate Llama3. Llama3's metrics on RAG for our quick example: context precision: 0.9867, faithfulness: 0.8297, answer relevancy: 0.8643, context_recall: 0.9733 Try this out with your favorite unstructured data by swapping the arXiv pdf URL in the notebook! Colab Notebook: https://lnkd.in/gSndzTuC

26

1 Comment

Check out this week's episode of #AdventuresinMachineLearning #ML: Adaptive Industry ML: Challenges, Automation, and Model Applications https://lnkd.in/g4K62N6J

1

Stop putting LLMs into everything and hoping it works. Learn how to properly integrate genuine Machine Learning techniques into your reversing with Hahna Latonick's Machine Learning for Reverse Engineers virtual course July 20 - 26: https://buff.ly/3Wh8G8V Learn supervised and unsupervised ML algorithms, how to build neural works and how to automate ML learning workflow. Most importantly, learn *how* to evaluate, measure and optimize ML systems' effectiveness in your reverse engineering.

8

Curious about how AI is disrupting your industry? 🤔 Check out this exclusive interview with Dr. Ryan Ries, Chief AI & Data Scientist at Mission Cloud, as he shares his expertise on navigating AI disruption and seizing opportunities in this transformative landscape. https://ow.ly/AMFh50RJE2l

4

Alexandre Andorra, co-founder of PyMC Labs, joins Jon Krohn for an in-depth look at Bayesian statistics. Learn how Bayesian methods tackle complex problems, leverage prior knowledge, and optimize limited data using tools like PyMC, PyTensor, ArviZ, and Gaussian Processes. Don’t miss this in-depth episode! Watch here: https://bit.ly/sds793 Thank you to Crawlbase for supporting this episode of SuperDataScience, enabling the show to be freely available on all major podcasting platforms and on YouTube. #datascience #bayesian #pymc

7

🧠 Exploring Efficiency in ML: DVC & LLMs 🤖 In the realm of Machine Learning, Large Language Models (LLMs) have been living in our heads rent-free over the last year. But how can you make your LLM applications more efficient and organized? This recent blog post from Ryan Turner dives into this question, focusing on the role of Data Version Control (DVC). No hype, just practical insights for ML engineers: 🛠️ Learn how DVC can optimize your LLM applications. 🔄 Manage your development pipeline more efficiently. 🔍 Achieve reproducibility without breaking the bank. 📊 Visualize your project structure with Directed Acyclic Graphs. 🔙 Seamlessly roll back to previous versions. Our RAG chatbot case study demonstrates the real-world benefits, from sourcing cited answers to streamlining community insights. For ML engineers looking to enhance their toolkit, it's worth exploring how DVC can make your projects more efficient, organized and fully reproducible. Check out the full blog post for actionable insights. Look for the link in the comments and follow DVC.ai for solutions to your MLOps challenges! #MachineLearning #MLEngineers #LLMs #GenerativeAI

16

3 Comments

Learn to optimize RAG for cost and performance in our new short course, Prompt Compression and Query Optimization, created with MongoDB and taught by Richmond Alake. This course teaches you to combine traditional database capabilities with vector search using MongoDB for RAG. You'll learn these techniques: - Vector search: For semantic matching of user queries - Filtering using metadata: Pre- and post-filtering to narrow search results - Projections: Selecting only necessary fields to minimize data returned - Boosting: Reranking results to improve relevance - Prompt compression: Using a small LLM to compress context, significantly reducing token count and processing costs These methods address scaling, performance, and security challenges in large-scale RAG applications. You can sign up here: https://lnkd.in/gMVN3hzM

5,387

96 Comments

🚀 Check out the latest Medium post by our student Tianyunxi Yin: "Quantization Fundamentals for Model Compression". Explore the essentials of quantization and learn how it helps in compressing machine learning models for better efficiency without compromising performance. Read more here: https://lnkd.in/gHbbR_J4 #USFMDS #DataScience #MachineLearning #ModelCompression #Quantization

16

We’ve recently contributed FP8 support to vLLM in collaboration with Neural Magic -- with this feature, you can see up to a 1.8x reduction in inter-token latency, with >99% accuracy preservation! A common concern with FP8 is whether users will experience accuracy degradation. To address this, Neural Magic has produced many checkpoints for key models with >99% accuracy preservation across a wide range of benchmarks (https://lnkd.in/gTimN5dZ), including: - Llama3-70b - Mixtral 8x7b - Llama3-8b You can easily try this out on vLLM, and read more about the feature here -- https://lnkd.in/gzKJqerB

144

3 Comments

FP8 quantization is now available in vLLM - check it out! Quantized inference is one of the best ways to reduce the costs of LLM deployments.

5

🚀 GENAI RAG Workflow: Integrating BERT Embeddings with FAISS for Efficient Text Retrieval 🔍 As the next step in our RAG workflow, we need to convert our JSONL into vectors. We’ve implemented a robust solution that leverages BERT embeddings to create a highly efficient FAISS index for text retrieval. # FAISS Load import os import json import torch import faiss from transformers import DistilBertTokenizer, DistilBertModel import numpy as np import gc import logging # Setup logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') def load_jsonl_items(file_path):   with open(file_path, 'r') as f:     for line in f:       item = json.loads(line)       if isinstance(item, dict):         yield item def process_batch(texts, ids, model, tokenizer, index, id_map, device):   try:     inputs = tokenizer(texts, return_tensors='pt', padding=True, truncation=True, max_length=128)     with torch.no_grad():       outputs = model(**inputs.to(device))     embeddings = outputs.last_hidden_state.mean(dim=1).cpu().numpy()     faiss.normalize_L2(embeddings)     index.add(embeddings)     id_map.update(dict(zip(ids, ids)))     gc.collect()   except Exception as e:     logging.error(f"Error processing batch: {e}") def get_device():   return torch.device("cuda" if torch.cuda.is_available() else "cpu") def main():   directory = 'Training/Data/jsonl_chunks/'   device = get_device()   model_name = 'distilbert-base-uncased' # Using DistilBERT model   tokenizer = DistilBertTokenizer.from_pretrained(model_name)   model = DistilBertModel.from_pretrained(model_name).to(device)       index = faiss.IndexFlatL2(768) # 768 is the dimension of DistilBERT base model embeddings   batch_size, texts, ids, id_map, total_processed = 16, [], [], {}, 0   for filename in os.listdir(directory):     if filename.endswith('.jsonl'):       jsonl_file_path = os.path.join(directory, filename)       for item in load_jsonl_items(jsonl_file_path):         texts.append(item.get('text', ''))         ids.append(item.get('id', str(total_processed)))         if len(texts) >= batch_size:           process_batch(texts, ids, model, tokenizer, index, id_map, device)           total_processed += len(texts)           texts, ids = [], []   if texts:     process_batch(texts, ids, model, tokenizer, index, id_map, device)   faiss.write_index(index, 'faiss_index.idx')   with open('id_map.json', 'w') as f:     json.dump(id_map, f)   print("FAISS index and ID map saved.")   print(f"Total documents processed: {total_processed}") if __name__ == "__main__":   main()

3

If you're new to FL, we've got you covered! 📚 These tutorials will guide you quickly through transitioning from centralized machine learning to federated learning using Flower with PyTorch or TensorFlow. 🚀 ➡️ Quickstart TensorFlow: https://buff.ly/3WV2XWL ➡️ Quickstart Pytorch: https://buff.ly/3yyoMRS #federatedlearning #ai

10

We're having some fun at KeyQ, Inc. and Cytogence, Inc. and are excited to share our latest project: the Contextual Graph Database (CGDB)! 🎉 CGDB is still in its pre-pre-pre-alpha stage, but we’re thrilled about its potential to revolutionize bioinformatics and big data analysis. Why CGDB is Cool?🌟 Imagine you're a biologist trying to understand how genes interact under different conditions, like healthy vs. diseased tissue. Traditional databases struggle to keep up with the complex, evolving nature of this data. CGDB makes it easy to: - Context-Aware Querying: Easily compare gene interactions across different tissue samples. - Dynamic Schema Evolution: Adapt to new data without downtime or complex migrations. We can't wait to see where this takes us. Check out our progress and give us your thoughts! 🔗 https://lnkd.in/e-na9r23 Stay tuned for more updates! #KeyQ #Cytogence #Bioinformatics #BigData #CGDB #Innovation #TechNews #Rust #Database #Graph #ComputerScience #Biology #Informatics #DataAnalysis #SmallBusiness #Alabama #HooverAL #SmallBusinessInnovation #SmallBusinessTech #Biotech

3

Exploring Multilayer Perceptrons (MLPs): The Building Blocks of Deep Learning MLPs are essential components in the field of deep learning. Here's a concise overview of MLPs, their workings, applications, and valuable resources for further learning. What is a MLP? A MLP is a deep, feedforward artificial neural network. It consists of at least three layers: an input layer, one or more hidden layers, and an output layer. Each neuron in one layer is connected to all neurons in the next layer, making the network fully connected. • How Does an MLP Work? •• Input Layer: Receives the input features (data points) which are then passed to the hidden layers. •• Hidden Layers: Apply weights to the inputs and pass them through activation functions to learn complex patterns. Common activation functions include ReLU (Rectified Linear Unit), Sigmoid, and Tanh. •• Output Layer: Produces the final prediction or classification based on the transformations from the hidden layers. •• Training: Uses backpropagation to adjust weights based on the error of predictions, minimizing the difference between actual and predicted outputs. Employs gradient descent optimization to iteratively reduce the error function. • Example Application: Handwriting Recognition MLPs are widely used in classification problems where the input data is labeled and the output is a discrete class label. For instance, in a handwriting recognition task, the input could be pixel data from images of handwritten digits, and the output would be which digit the image represents (0 through 9). The MLP learns to recognize patterns in the pixel data corresponding to each digit and accurately classify the images. • Key Techniques in MLPs •• Backpropagation: Updates the network’s weights by propagating the error backward from the output layer to the input layer. •• Gradient Descent: An optimization algorithm that minimizes the error function by adjusting weights iteratively. • Applications of MLPs •• Image Recognition: Identifying objects or patterns within images. •• Speech Recognition: Converting spoken language into text. •• Financial Forecasting: Predicting stock prices or market trends. •• Medical Diagnosis: Assisting in identifying diseases based on medical data. •• Natural Language Processing: Understanding and generating human language. • Why MLPs Matter MLPs form the backbone of deep learning, providing a foundational architecture for more complex neural network models. Their ability to model complex patterns makes them crucial for a variety of AI applications. Helpful Resources: https://lnkd.in/dTH65mXU https://lnkd.in/dCrf7yMN https://lnkd.in/dwxRyEq6 #MLP #BeingDataScientist #Innovation #MultiLayerPerceptron #AI #BDS For more insights and discussions on data science and machine learning, join "Being Data Scientist." Let's explore the future together! 🚀

9