uptrain

fs b. Filtering redundant evals: Running the evals on sample data to filter out cases where the false failure rates exceed a certain threshold or the evaluation is trivial and always passes. c. Subsumes checks: Check for subsumes, i.e. if two or more evals effectively do the same check. They check this by prompting LLM to construct a case where function one can return True and function two will return False. If such a case can't be built, functions one and 2 are identical, and one can be dropped. d. Using an integer programming optimizer to find the optimal evaluation set with maximum coverage and respect failure, accuracy, and subsumption constraints Their results are impressive. You can look at the SPADE paper for more details: https://arxiv.org/pdf/2401.03038.pdf 2. Running these evaluations reliably is tricky: Recently, using LLMs as evaluators has emerged as a promising alternative to human evaluations and has proven quite effective in improving the accuracy of LLM applications. However, difficulties still exist when running these evals reliably, i.e. high correlation with human judgments and stability across multiple runs. UpTrain is an open-source framework for evaluating LLM applications that provide high-quality scores. It allows one to define custom evaluations via GuidelineAdherence check, where one can determine any custom guideline in plain English and check if the LLM follows it. Additionally, it provides an easy interface to run these evaluations on production responses with a single API call. This allows one to systematically leverage frameworks like UpTrain to check for wrong LLM outputs. I am one of the maintainers of UpTrain, and we recently integrated the SPADE framework into our open-source repo (https://github.com/uptrain-ai/uptrain/). The idea is simple: 1. Provide your prompt template 2. We use the SPADE framework to identify which evaluations to run 3. We configure UpTrain to run these evaluations on any provided data or monitor these scores in production. All done seamlessly I would love for you to check it out and provide feedback. Link for the integration tutorial: https://github.com/uptrain-ai/uptrain/blob/main/examples/int...

o a word-to-word comparison against. There could be 100s of different email copies and all of them could be equally correct for the task. When traditional NLP metrics fail, novel techniques have emerged to use LLMs as evaluators. But how can one expect for GPT to reliably score its own response - too self-consumed? The trick is to simplify the evaluation task. Instead of directly asking whether the response is correct or not, ask the LLM to evaluate the response only along a certain dimension - is it grounded by the context, is it too verbose, is it answering all aspects of the question, is the tone correct, etc. Now, the dimensions one should care about depend upon the use case. For applications generating marketing copies, tonality, interestingness, etc. would matter more while for RAG and chatbots, factual accuracy, retrieval quality, and response relevance would be better to look at. Dimensions of LLM Evaluations Taking our learnings while building UpTrain - an open-source LLM evaluation tool, we have divided these dimensions into 4 categories: 1.Checks for evaluating Task Understanding and Context Awareness: Check to evaluate if your LLM + prompt configuration can comprehend the task at hand and fully utilize the provided context to provide an appropriate response. This category is further divided into 2 sub-categories: a. Response Appropriateness: Intent understanding, Response Completeness, Response Relevancy, Output Structure Integrity, etc. b. Context Awareness and Grounding: Hallucinations, Retrieved-context quality, context utilization, etc. 2. Checks for evaluating Language Quality: Dimensions that help to evaluate the quality of the response from a language perspective. We further divide this into two subcategories: a. Task Independent: Dimensions like grammar correctness, fluency, coherence, toxicity, fairness towards all sectors of society, etc. We generally see high scores for these, especially for RLHFed LLMs b. Task Dependent: Tonality match with the given persona, creativity, interestingness, etc. Your prompt can play a big role here 3. Evaluating Reasoning Capabilities: Includes dimensions like logical correctness (right conclusions), logical robustness (consistent with minor input changes), logical efficiency (shortest solution path), and common sense understanding (grasping common concepts). One can’t do much beyond prompting techniques like CoT and primarily depends upon the LLM chosen. 4. Custom Evaluations: Many applications require customized metrics tailored to their specific needs. You want adherence to custom guidelines, check for certain keywords, etc. You can read the full blog here (https://uptrain.ai/blog/how-to-evaluate-your-llm-applications). Hope you find it useful. I am one of the developer of UpTrain - it is an open-source package to evaluate LLM applications (https://github.com/uptrain-ai/uptrain). Would love to get feedback from the HN community.

le of model responses, you want to run them through hundreds of test cases, aggregate their scores, and make an informed decision. Additionally, as your application generates responses for real user queries, you don’t want to wait for them to complain about the model inaccuracy, instead, you want to monitor the model’s performance over time and get alerted in case of any drifts. Again, at the core of it, you want a tool to evaluate the quality of your LLM response and assign quantitative scores. The Solution: To solve this, we are building UpTrain which has a set of evaluation metrics so that you can know when your application is going wrong. These metrics include traditional NLP metrics like Rogue, Bleu, etc., embeddings similarity metrics as well as model grading scores i.e. where we use LLMs to evaluate different aspects of your response. A few of these evaluation metrics include: 1. Response Relevancy: Measures if the response contains any irrelevant information 2. Response Completeness: Measures if the response answers all aspects of the given question 3. Factual Accuracy: Measures hallucinations i.e. if the response has any made-up information or not with respect to the provided context 4. Retrieved Context Quality: Measures if the retrieved context has sufficient information to answer the given question 5. Response Tonality: Measures if the response aligns with a specific persona or desired tone etc. We have designed workflows so that you can easily add your testing dataset, configure which checks you want to run (you can also define custom checks suitable for your use case) and conveniently access the results via Streamlit dashboards. UpTrain also has experimentation capabilities where you can specify different prompt variations and models to test across and use these quantitative checks to find the best configuration for your application. You can also use UpTrain to monitor your application’s performance and find avenues for improvement. We integrate directly with your databases (BigQuery, Postgres, MongoDB, etc.) and can run daily evaluations. We’ve launched the tool under an Apache 2.0 license to make it easy for everyone to integrate it into their LLM workflows. Additionally, we also provide managed service (with a free trial) where you can run LLM evaluations via an API request or through UpTrain testing console. We would love for you to try it out and give your feedback. Links: Demo: https://demo.uptrain.ai/evals_demo/ Github repo: https://github.com/uptrain-ai/uptrain Create an account (free): https://uptrain.ai/dashboard UpTrain testing console (need an account): https://demo.uptrain.ai/dashboard Website: https://uptrain.ai/

.com/uptrain-ai/uptrain), an open-source project which helps you collect that high quality fine-tuning dataset

o identify them proactively. UpTrain monitors the difference between the dataset the model was trained on and the real-world data it encounters during production (the wild!). This "difference" can be custom statistical measures designed by ML practitioners based on their use case. That last point regarding customization is important because, in most cases, there’s no “ground truth” to check if a model’s output is correct or not. Instead, you need to use statistical measures to figure out drift or performance degradation issues, and those require domain expertise and differ from case to case. For example, in a text summarization model, you want to monitor drift in the input text sentiment, but for a human pose estimation model, you want to add integrity checks on the predicted body length. Additionally, we monitor for edge cases defined as rule-based smart signals on the model input. Whenever UpTrain sees a distribution shift or an increased frequency of edge cases, it raises an alert while identifying the subset of data that experienced these issues. Finally, it retrains the model on that data, improving its performance in the wild. Before UpTrain, we explored many observability tools at previous companies (Bytedance, Meta, and Bosch), but always got stuck figuring out what issues our models were facing in production. We used to go through user reviews, find patterns around model failures and manually retrain our models. This was time-consuming and opaque. Customizing our monitoring metrics and having a solution built specifically for ML models was a big need that wasn’t fulfilled. Additionally, many ML models operate on user-sensitive data, and we didn’t want to send users’ private data to third parties. From a privacy perspective, relying on third-party hosted solutions just felt wrong, and motivated us to create an open-source self-hosted alternative for the same. We are building UpTrain to make model monitoring effortless. With a single-line integration, our toolkit allows you to detect dips in model performance using real-time dashboards, sends you Slack alerts, helps to pinpoint poor-performing cohorts, and many more. UpTrain is built specifically for ML use cases, providing tools to monitor data distribution shifts, identify production data points with low representation in training data, and visualization/drift detection for embeddings. For more about our key features, see https://docs.uptrain.ai/docs/key-features Our tool is available as a Python package that can be installed on top of your deployment infrastructure (AWS, GCP, Azure). Since ML models operate on user-sensitive data, and sharing it with external servers is often a barrier to using third-party tools, we focus on deploying to your own cloud. We’ve launched this repo under an Apache 2.0 license to make it easy for individual developers to integrate it into their production app. For monetization, we plan to build enterprise-level integrations that will include managed service and support. In the next few months, we plan to add more advanced observability measures for large language models and generative AI, as well as make UpTrain easier to integrate with other tools like Weights and Biases, Databricks, Kubernetes, and Airflow. We would love for you to try out our GitHub repo and give your feedback, and we look forward to all of your comments!

some enterprise features, a hosted version, and support that we charge for. Give it a try and let us know what you think!