{"id":8176,"date":"2023-11-15T17:57:46","date_gmt":"2023-11-16T01:57:46","guid":{"rendered":"https:\/\/live-cometml.pantheonsite.io\/?p=8176"},"modified":"2025-04-24T17:04:24","modified_gmt":"2025-04-24T17:04:24","slug":"langchain-evaluators-for-language-model-validation","status":"publish","type":"post","link":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/","title":{"rendered":"LangChain Evaluators for Language Model Validation"},"content":{"rendered":"\n
\n
<\/div>\n
\n
\n

Exploring Exact Matches, Embedding Distances, and More: A Deep Dive into Advanced String Evaluation Methods for AI Applications<\/h3>\n
\n<\/figure><\/div><\/div><\/section>\n\n\n\n
\"langchain
Photo by Florian Schmetz<\/a> on\u00a0Unsplash<\/a><\/figcaption><\/figure>\n\n\n\n

Introduction<\/h3>\n\n\n\n

While string evaluators provide a robust way to measure a model\u2019s accuracy, myriad other methods offer nuanced and targeted approaches to evaluation.<\/p>\n\n\n\n

For developers and data scientists venturing into building applications with language models, ensuring the reliability of the model\u2019s output becomes paramount. From the simplicity of an exact match to the depth of embedding distances, each evaluation method serves a unique purpose in the grand tapestry of language model validation.<\/p>\n\n\n\n

Delving deeper, this guide explores various string evaluation techniques\u200a\u2014\u200aeach with its strengths, intricacies, and use cases. <\/strong><\/p>\n\n\n\n

Whether you\u2019re looking to validate a specific format using regex or measure semantic similarity through embeddings, understanding these evaluation methods is key to creating AI-driven applications that are both accurate and effective.<\/p>\n\n\n\n

Evaluation<\/h3>\n\n\n\n

When building apps with language models, it\u2019s crucial to ensure your models produce reliable and valuable results for various inputs and integrate seamlessly with other software components. This often requires a mix of intelligent application design, thorough testing, and runtime checks.<\/p>\n\n\n\n

Exact Match Evaluators<\/h3>\n\n\n\n

Probably the simplest ways to evaluate an LLM or runnable\u2019s string output against a reference label is by a simple string equivalence.<\/p>\n\n\n\n

The ExactMatchStringEvaluator<\/code> simply checks if the prediction string exactly matches the reference string.<\/p>\n\n\n\n

It is case-sensitive by default.<\/p>\n\n\n\n

from<\/span> langchain.evaluation import<\/span> ExactMatchStringEvaluator\n\nevaluator = ExactMatchStringEvaluator()\n\nevaluator.evaluate_strings(\n    prediction=\"My name is Harpreet, and I love to learn LangChain\"<\/span>,\n    reference=\"Harpreet loves learning langchain\"<\/span>,\n                           )<\/span><\/pre>\n\n\n\n
{'score'<\/span>: 0<\/span>}<\/span><\/pre>\n\n\n\n
evaluator.evaluate_strings(prediction=\"My name is Harpreet, and I love to learn LangChain\"<\/span>,\n                           reference=\"My name is Harpreet, and I love to learn LangChain\"<\/span>,\n                           )<\/span><\/pre>\n\n\n\n
{'score'<\/span>: 1<\/span>}<\/span><\/pre>\n\n\n\n
Configure the ExactMatchStringEvaluator<\/code><\/h3>\n\n\n\n
You can relax the \u201cexactness\u201d when comparing strings.<\/p>\n\n\n\n
evaluator = ExactMatchStringEvaluator(\n    ignore_case=True<\/span>,\n    ignore_numbers=True<\/span>,\n    ignore_punctuation=True<\/span>,\n)<\/span><\/pre>\n\n\n\n
evaluator.evaluate_strings(\n    prediction=\"My name is Harpreet, and I love to learn LangChain\"<\/span>,\n    reference=\"my name is harpreet, and I love to learn langchain!\"<\/span>\n    )\n\n# will output {'score': 1}<\/span><\/span><\/pre>\n\n\n\n
String Distance<\/h3>\n\n\n\n
String distance is a measure of the difference between two strings.<\/p>\n\n\n\n
The smaller the distance, the more similar the two strings are. Different algorithms provide different ways of calculating this distance.<\/p>\n\n\n\n
Under the hood, LangChain uses the RapidFuzz<\/code> library to perform several calculations.<\/p>\n\n\n\n
This can be used alongside approximate\/fuzzy matching criteria for fundamental unit testing.<\/p>\n\n\n\n
The StringDistanceStringEvaluator<\/code> measures the similarity between two strings using a string distance algorithm like Levenshtein distance.<\/p>\n\n\n\n
It returns a score between 0 and 1, with 1 indicating an exact match.<\/p>\n\n\n\n
\n
\n
\n<\/div>\n
\n
\n
Want to learn how to build modern software with LLMs using the newest tools and techniques in the field? Check out this free LLMOps course<\/a> from industry expert Elvis Saravia of DAIR.AI.<\/p><\/blockquote>\n<\/div>\n<\/div>\n<\/section>\n\n\n\n
\n
\n
\n<\/div>\n
\n
\n
Supported Evaluator metrics<\/h3>\n
This enumeration defines the types of string distance metrics supported:<\/p>\n
    \n
  • Damerau-Levenshtein<\/code>: Considers insertions, deletions, substitutions, and the transposition of two adjacent characters.<\/li>\n
  • Levenshtein<\/code>: Considers insertions, deletions, and substitutions.<\/li>\n
  • Jaro<\/code>: Measures the similarity between two strings.<\/li>\n
  • Jaro-Winkler<\/code>: A modification of Jaro’s similarity to give more weight to the prefix.<\/li>\n
  • Hamming<\/code>: Measures the difference between two strings of equal length.<\/li>\n
  • Indel<\/code>: Considers only insertions and deletions.<\/li>\n<\/ul>\n
    from<\/span> langchain.evaluation import<\/span> load_evaluator, StringDistance\n\nevaluator = load_evaluator(\"string_distance\"<\/span>)\n\nevaluator.evaluate_strings(\n    prediction=\"My name is Harpreet, and I love to learn LangChain\"<\/span>,\n    reference=\"Harpreet loves learning langchain\"<\/span>,\n)\n\n# will output {'score': 0.31919191919191914}<\/span><\/span><\/pre>\n
    You can change the metric like so:<\/p>\n
    levenshtein_evaluator = load_evaluator(\n    \"string_distance\"<\/span>,\n    distance='levenshtein'<\/span>\n)\n\nlevenshtein_evaluator.evaluate_strings(\n    prediction=\"My name is Harpreet, and I love to learn LangChain\"<\/span>,\n    reference=\"Harpreet loves learning langchain\"<\/span>,\n)\n\n# {'score': 0.52}<\/span><\/span><\/pre>\n
    For some metrics, you need to instantiate the StringDistanceEvalChain:<\/p>\n
    from<\/span> langchain.evaluation import<\/span> StringDistanceEvalChain\n\nevaluator = StringDistanceEvalChain(value='indel'<\/span>)\n\nevaluator.evaluate_strings(\n    prediction=\"My name is Harpreet, and I love to learn LangChain\"<\/span>,\n    reference=\"Harpreet loves learning langchain\"<\/span>,\n)\n\n# {'score': 0.31919191919191914}<\/span><\/span><\/pre>\n
    Embedding Distance Evaluator<\/h3>\n
    To measure semantic similarity (or dissimilarity) between a prediction and a reference label string, you could use a vector vector distance metric the two embedded representations using the embedding_distance<\/code> evaluator.<\/p>\n
    Note: This returns a distance score, meaning that the lower the number, the more similar the prediction is to the reference, according to their embedded representation.<\/p>\n
    These distance measures you can choose from are:<\/p>\n
      \n
    1. Cosine Distance(<\/strong>\"cosine\"<\/strong><\/code>)<\/strong>: This is computed as (1\u200a\u2014\u200a{cosine similarity}). The cosine similarity measures the cosine of the angle between two vectors. A cosine similarity of 1 means the vectors are identical, while a value of 0 means they are orthogonal (entirely dissimilar). Therefore, a cosine distance of 0 indicates that the embeddings are identical, and a value of 1 indicates they are entirely dissimilar.<\/li>\n
    2. Euclidean Distance (<\/strong>\"euclidean\"<\/strong><\/code>)<\/strong>: It is the straight-line distance between two points in Euclidean space.<\/li>\n
    3. Manhattan Distance (or L1 Distance) (<\/strong>\"manhattan\"<\/strong><\/code>)<\/strong>: It is the sum of the absolute differences of their coordinates. In a 2D space, it represents the distance between two points measured along the axes at right angles.<\/li>\n
    4. Chebyshev Distance (<\/strong>\"chebyshev\"<\/strong><\/code>)<\/strong>: It is the maximum absolute difference between elements of the vectors. It\u2019s essentially the infinity norm of the difference between the vectors.<\/li>\n
    5. Hamming Distance (<\/strong>\"hamming\"<\/strong><\/code>)<\/strong>: It measures the minimum number of substitutions required to change one string into the other or the minimum number of errors that could have transformed one string into the other. In the context of this code, it seems to be applied to vectors by determining the proportion of differing vector elements.<\/li>\n<\/ol>\n
      Considerations for Choosing a Distance Metric for Text Embeddings:<\/h3>\n
        \n
      1. Scale or Magnitude<\/strong>: Embeddings from models like Word2Vec, FastText, BERT, and GPT are often normalized to unit length. In such cases, cosine distance<\/strong> is suitable as it focuses on the angle (direction) between vectors and ignores uniform magnitude.<\/li>\n
      2. Distribution of Embeddings<\/strong>: Understand the distribution of your embeddings. For densely packed vectors, minor changes in direction can be significant, making cosine distance a good choice.<\/li>\n
      3. High Dimensionality<\/strong>: Text embeddings are often high-dimensional. The \u201ccurse of dimensionality\u201d can make the distinction between points appear more pronounced with Euclidean distance. Cosine distance might be more reliable in such situations.<\/li>\n
      4. Nature of Textual Data<\/strong>: For longer documents, cosine similarity can capture nuanced semantic information. For shorter texts, like phrases, the absolute position of embeddings can be important, making Euclidean or Manhattan distances more informative.<\/li>\n
      5. Use Case<\/strong>: Your specific application (e.g., clustering, matching) can dictate the best metric.<\/li>\n
      6. Interpretability<\/strong>: Cosine distance values are bounded between 0 (identical) and 1 (opposite), offering more interpretability than unbounded metrics like Euclidean or Manhattan.<\/li>\n
      7. Performance<\/strong>: Computationally, cosine distance can be more efficient for normalized vectors.<\/li>\n<\/ol>\n
        In general, cosine distance is a common choice for text embeddings. However, it\u2019s beneficial to experiment with different metrics based on your specific needs and validate them against a known benchmark or application outcome.<\/p>\n
        from<\/span> langchain.evaluation import<\/span> load_evaluator\n\nevaluator = load_evaluator(\"embedding_distance\"<\/span>)\n\nevaluator.evaluate_strings(\n    prediction=\"My name is Harpreet, and I love to learn LangChain\"<\/span>,\n    reference=\"Harpreet loves learning langchain\"<\/span>\n    )\n\n# {'score': 0.0404781648420105}<\/span><\/span><\/pre>\n
        evaluator = load_evaluator(\n    \"embedding_distance\"<\/span>,\n    distance_metric=\"euclidean\"<\/span>\n)\n\nevaluator.evaluate_strings(\n    prediction=\"My name is Harpreet, and I love to learn LangChain\"<\/span>,\n    reference=\"Harpreet loves learning langchain\"<\/span>\n    )\n\n# {'score': 0.2844376766821911}<\/span><\/span><\/pre>\n
        Select the embeddings you want to use<\/h3>\n
        The constructor uses OpenAI embeddings by default, but you can configure this however you want. Below, use HuggingFace local embeddings:<\/p>\n
        from langchain.embeddings import HuggingFaceEmbeddings\n\nembedding_model = HuggingFaceEmbeddings()\nhf_evaluator = load_evaluator(\"embedding_distance\"<\/span>,\n                              embeddings=embedding_model)\n\nhf_evaluator.evaluate_strings(\n    prediction=\"My name is Harpreet, and I love to learn LangChain\"<\/span>,\n    reference=\"Harpreet loves learning langchain\"<\/span>\n    )\n\n# {'score': 0.2803533789378635}<\/span><\/span><\/pre>\n
        Regex Matching Evaluator<\/h3>\n
        The RegexMatchStringEvaluator checks if a regex pattern matches the prediction string. This is useful for validating outputs.<\/p>\n
        from<\/span> langchain.evaluation import<\/span> RegexMatchStringEvaluator\n\nevaluator = RegexMatchStringEvaluator()\n\nevaluator.evaluate_strings(\n    prediction=\"The date is 2022-01-01\"<\/span>,\n    reference=\"The date is 2022-01-01\"<\/span>\n  )\n\n#  {'score': 1}<\/span>\n\n# Check for the presence of a MM-DD-YYYY string.<\/span>\nevaluator.evaluate_strings(\n    prediction=\"The delivery will be made on 2024-01-05\"<\/span>,\n    reference=\".*\\\\b\\\\d{2}-\\\\d{2}-\\\\d{4}\\\\b.*\"<\/span>\n)\n\n# {'score': 0}<\/span>\n\nevaluator.evaluate_strings(\n    prediction=\"The delivery will be made on 01-05-2024\"<\/span>,\n    reference=\".*\\\\b\\\\d{2}-\\\\d{2}-\\\\d{4}\\\\b.*\"<\/span>\n)\n\n# {'score': 1}<\/span><\/span><\/pre>\n
        Match against multiple patterns<\/h3>\n
        To match against multiple patterns, use a regex union \u201c|\u201d.<\/p>\n
        # Check for the presence of a MM-DD-YYYY string or YYYY-MM-DD<\/span>\nevaluator.evaluate_strings(\n    prediction=\"The delivery will be made on 01-05-2024\"<\/span>,\n    reference=\"|\"<\/span>.join([\".*\\\\b\\\\d{4}-\\\\d{2}-\\\\d{2}\\\\b.*\"<\/span>, \".*\\\\b\\\\d{2}-\\\\d{2}-\\\\d{4}\\\\b.*\"<\/span>])\n)\n\n# {'score': 1}<\/span><\/span><\/pre>\n
        Configure the RegexMatchStringEvaluator<\/code><\/h3>\n
        You can specify any regex flags to use when matching.<\/p>\n
        import<\/span> re\n\nevaluator = RegexMatchStringEvaluator(\n    flags=re.IGNORECASE\n)\n\nevaluator.evaluate_strings(\n    prediction=\"My name is Harpreet, and I love to learn LangChain\"<\/span>,\n    reference=\"Harpreet loves learning langchain\"<\/span>\n    )\n\n# {'score': 0}<\/span><\/span><\/pre>\n
        So, in summary:<\/h4>\n
          \n
        • Exact Match does literal string comparison<\/li>\n
        • String Distance measures similarity using algorithms like Levenshtein distance<\/li>\n
        • Embedding Distance measures semantic similarity using embeddings<\/li>\n
        • Regex Match validates string formats using regular expressions<\/li>\n<\/ul>\n
          Conclusion<\/h3>\n
          As we journey through the multifaceted landscape of language model evaluation, it becomes evident that more than a one-size-fits-all approach is required.<\/p>\n
          From the precision of exact matches to the interpretive power of embedding distances, each evaluation technique offers a unique lens through which we can scrutinize our models. The role of regex in format validation and the nuanced ways string distance algorithms operate underscore the richness and diversity of tools at our disposal.<\/p>\n
          For developers and AI enthusiasts, understanding and leveraging these evaluation methods are crucial steps toward building applications that not only function seamlessly but also uphold the standards of reliability and accuracy.<\/p>\n
          A comprehensive toolkit like this ensures we remain equipped to meet challenges, validate outputs, and drive innovation. As you conclude this guide, I hope you\u2019re better prepared and inspired to harness the power of these evaluative techniques, ensuring that your AI applications are always a cut above the rest.<\/p>\n<\/div>\n<\/div>\n<\/section>\n","protected":false},"excerpt":{"rendered":"
          Exploring Exact Matches, Embedding Distances, and More: A Deep Dive into Advanced String Evaluation Methods for AI Applications Introduction While string evaluators provide a robust way to measure a model\u2019s accuracy, myriad other methods offer nuanced and targeted approaches to evaluation. For developers and data scientists venturing into building applications with language models, ensuring the […]<\/p>\n","protected":false},"author":68,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"customer_name":"","customer_description":"","customer_industry":"","customer_technologies":"","customer_logo":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[65,6,7],"tags":[70,71,52,31,34],"coauthors":[166],"class_list":["post-8176","post","type-post","status-publish","format-standard","hentry","category-llmops","category-machine-learning","category-tutorials","tag-langchain","tag-language-models","tag-llm","tag-llmops","tag-prompt-engineering"],"yoast_head":"\nLangChain Evaluators for Language Model Validation - Comet<\/title>\n<meta name=\"description\" content=\"This guide explores various string evaluation techniques\u200a and LangChai Evaluators, \u200aeach with its strengths, intricacies, and use cases.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"LangChain Evaluators for Language Model Validation\" \/>\n<meta property=\"og:description\" content=\"This guide explores various string evaluation techniques\u200a and LangChai Evaluators, \u200aeach with its strengths, intricacies, and use cases.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/\" \/>\n<meta property=\"og:site_name\" content=\"Comet\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/cometdotml\" \/>\n<meta property=\"article:published_time\" content=\"2023-11-16T01:57:46+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-04-24T17:04:24+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/cdn-images-1.medium.com\/max\/1600\/0*C8FXr7IuaDQRpfUg\" \/>\n<meta name=\"author\" content=\"Harpreet Sahota\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@Cometml\" \/>\n<meta name=\"twitter:site\" content=\"@Cometml\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Harpreet Sahota\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"8 minutes\" \/>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"LangChain Evaluators for Language Model Validation - Comet","description":"This guide explores various string evaluation techniques\u200a and LangChai Evaluators, \u200aeach with its strengths, intricacies, and use cases.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/","og_locale":"en_US","og_type":"article","og_title":"LangChain Evaluators for Language Model Validation","og_description":"This guide explores various string evaluation techniques\u200a and LangChai Evaluators, \u200aeach with its strengths, intricacies, and use cases.","og_url":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/","og_site_name":"Comet","article_publisher":"https:\/\/www.facebook.com\/cometdotml","article_published_time":"2023-11-16T01:57:46+00:00","article_modified_time":"2025-04-24T17:04:24+00:00","og_image":[{"url":"https:\/\/cdn-images-1.medium.com\/max\/1600\/0*C8FXr7IuaDQRpfUg","type":"","width":"","height":""}],"author":"Harpreet Sahota","twitter_card":"summary_large_image","twitter_creator":"@Cometml","twitter_site":"@Cometml","twitter_misc":{"Written by":"Harpreet Sahota","Est. reading time":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/#article","isPartOf":{"@id":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/"},"author":{"name":"Harpreet Sahota","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/46036ab474aa916e2873daece26a28d6"},"headline":"LangChain Evaluators for Language Model Validation","datePublished":"2023-11-16T01:57:46+00:00","dateModified":"2025-04-24T17:04:24+00:00","mainEntityOfPage":{"@id":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/"},"wordCount":1180,"publisher":{"@id":"https:\/\/www.comet.com\/site\/#organization"},"image":{"@id":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/#primaryimage"},"thumbnailUrl":"https:\/\/cdn-images-1.medium.com\/max\/1600\/0*C8FXr7IuaDQRpfUg","keywords":["LangChain","Language Models","LLM","LLMOps","Prompt Engineering"],"articleSection":["LLMOps","Machine Learning","Tutorials"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/","url":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/","name":"LangChain Evaluators for Language Model Validation - Comet","isPartOf":{"@id":"https:\/\/www.comet.com\/site\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/#primaryimage"},"image":{"@id":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/#primaryimage"},"thumbnailUrl":"https:\/\/cdn-images-1.medium.com\/max\/1600\/0*C8FXr7IuaDQRpfUg","datePublished":"2023-11-16T01:57:46+00:00","dateModified":"2025-04-24T17:04:24+00:00","description":"This guide explores various string evaluation techniques\u200a and LangChai Evaluators, \u200aeach with its strengths, intricacies, and use cases.","breadcrumb":{"@id":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/#primaryimage","url":"https:\/\/cdn-images-1.medium.com\/max\/1600\/0*C8FXr7IuaDQRpfUg","contentUrl":"https:\/\/cdn-images-1.medium.com\/max\/1600\/0*C8FXr7IuaDQRpfUg"},{"@type":"BreadcrumbList","@id":"https:\/\/www.comet.com\/site\/blog\/langchain-evaluators-for-language-model-validation\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.comet.com\/site\/"},{"@type":"ListItem","position":2,"name":"LangChain Evaluators for Language Model Validation"}]},{"@type":"WebSite","@id":"https:\/\/www.comet.com\/site\/#website","url":"https:\/\/www.comet.com\/site\/","name":"Comet","description":"Build Better Models Faster","publisher":{"@id":"https:\/\/www.comet.com\/site\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.comet.com\/site\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.comet.com\/site\/#organization","name":"Comet ML, Inc.","alternateName":"Comet","url":"https:\/\/www.comet.com\/site\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/#\/schema\/logo\/image\/","url":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2025\/01\/logo_comet_square.png","contentUrl":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2025\/01\/logo_comet_square.png","width":310,"height":310,"caption":"Comet ML, Inc."},"image":{"@id":"https:\/\/www.comet.com\/site\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/cometdotml","https:\/\/x.com\/Cometml","https:\/\/www.youtube.com\/channel\/UCmN63HKvfXSCS-UwVwmK8Hw"]},{"@type":"Person","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/46036ab474aa916e2873daece26a28d6","name":"Harpreet Sahota","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/image\/2d21512be19ba7e19a71a803309e2a88","url":"https:\/\/secure.gravatar.com\/avatar\/a6ca5a533fc9f143a0a7428037ff652aa0633d66bf27e76ae89b955ae72a0f2d?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/a6ca5a533fc9f143a0a7428037ff652aa0633d66bf27e76ae89b955ae72a0f2d?s=96&d=mm&r=g","caption":"Harpreet Sahota"},"url":"https:\/\/www.comet.com\/site\/blog\/author\/theartistsofdatasciencegmail-com\/"}]}},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/8176","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/users\/68"}],"replies":[{"embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/comments?post=8176"}],"version-history":[{"count":1,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/8176\/revisions"}],"predecessor-version":[{"id":15448,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/8176\/revisions\/15448"}],"wp:attachment":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/media?parent=8176"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/categories?post=8176"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/tags?post=8176"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/coauthors?post=8176"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}