{"id":7346,"date":"2023-08-29T13:50:38","date_gmt":"2023-08-29T21:50:38","guid":{"rendered":"https:\/\/live-cometml.pantheonsite.io\/?p=7346"},"modified":"2025-04-24T17:14:27","modified_gmt":"2025-04-24T17:14:27","slug":"introduction-to-text-wrangling-techniques-for-natural-language-processing","status":"publish","type":"post","link":"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/","title":{"rendered":"Introduction to Text Wrangling Techniques for Natural Language Processing"},"content":{"rendered":"\n\n\n\n\n
\n
\"\"<\/figure>
\n
<\/picture><\/figure>\n<\/div>\n
\n
\n

What is Text Wrangling?<\/h1>\n

Although is has many forms, text wrangling is basically the pre-processing work that\u2019s done to prepare raw text data ready for training. Simply put, it\u2019s the process of cleaning your data to make it readable by your program, and then formatting it as such.<\/p>\n

Many of you may be wrangling text without knowing it yourself. In this tutorial, I will teach you how to clean up your text in Python. I will show you to perform the most common forms of text wrangling: sentence splitting, tokenization, stemming, lemmatization, and stop word removal.<\/p>\n

Prerequisites<\/strong><\/h1>\n

Obviously, you\u2019ll need a little bit of Python know-how in order to run the code I\u2019ll show below. I\u2019ll be using a Google Colab notebook to host all my code. I\u2019ll share the link at the end so you can see how your code compares. To create a new notebook, click here<\/a>.<\/p>\n

If you\u2019ve worked with Natural Language code before in Python, you\u2019re probably familiar with the Python package nltk<\/code> or the Natural Language Toolkit.<\/a> It\u2019s an amazing library with many functions for building Python programs to work with human language data. Let\u2019s begin by typing the following code:<\/p>\n

import nltk\nnltk.download(\u2018punkt\u2019)<\/span><\/pre>\n
In this cell, we are importing the library and asking our notebook to download punkt<\/code>. This is a tokenizer that divides a text into a list of sentences. This brings us to our first example of text wrangling\u2014Sentence Splitting.<\/p>\n<\/div>\n<\/div>\n<\/div>\n\n\n\n
\n
\n
\n
Sentence Splitting<\/h1>\n
If you\u2019ve ever been given a large paragraph of text, you know that the best way to analyze it is by splitting the text into sentences. In real life conversations, we also compute information at the sentence level by analyzing conjoined words. However, trying to split paragraphs of text into sentences can be difficult in raw code. Luckily, with nltk<\/code>, we can do this quite easily. Type the following code:<\/p>\n
sampleString = \u201cLet\u2019s make this our sample paragraph. It will split at the end of a sentence marker, like a period. It even knows that the period in Mr. Jones is not the end. Try it out!\u201d<\/span>from<\/strong> nltk.tokenize import<\/strong> sent_tokenize\ntokenized_sent = sent_tokenize(sampleString)\nprint(tokenized_sent)<\/span><\/pre>\n
This code might be self-explanatory, but it\u2019s okay if this is your first time. Here is what we typed line by line:<\/p>\n
    \n
  1. First, we define a variable called sampleString<\/code> that contains a couple of sentences. You can change the text in this variable to whatever you wish.<\/li>\n
  2. Next, we import sent_tokenize<\/code>, which is the sentence tokenization function from the nltk<\/code> library.<\/li>\n
  3. We call the sent_tokenize<\/code> function on our sampleString<\/code>. This runs the tokenization function over our string and saves the results to a new variable called tokenized_sent<\/code>.<\/li>\n
  4. Finally, we print tokenized_sent<\/code> to the log. You should receive an output that looks like this:<\/li>\n<\/ol>\n
    [\u201cLet\u2019s make this our sample paragraph.\u201d, \u2018It will split at the end of a sentence marker, like a period.\u2019, \u2018It even knows that the period in Mr. Jones is not the end.\u2019, \u2018Try it out!\u2019]<\/span><\/pre>\n
    As you can see, we were able to split up the paragraph into exact sentences. What\u2019s even more fascinating is that the code knows the difference between a period used to end a sentence versus a period used in the name Mr. Jones<\/strong>.<\/p>\n
    Tokenization<\/h1>\n
    By now, you\u2019re probably wondering what tokenization is. Well a token<\/strong> is the smallest text unit a machine can process. Therefore, every chunk of text needs to be tokenized before you can run natural language programs on it. Sometimes, it makes sense for the smallest unit to be either a word or a letter. In the previous section, we tokenized the paragraph into sentences.<\/p>\n
    For a language like English, it can be easy to tokenize text, especially with nltk<\/code> to guide us. Here\u2019s how we can tokenize text using just a few lines of code:<\/p>\n
    msg<\/strong> = \u201cHey everyone! The party starts in 10mins. Be there ASAP!\u201d\nprint(msg.split())<\/span><\/pre>\n
    Like before, we define a variable called msg<\/code> (short for message). Then, we run a function called split<\/code> over this chunk of text and print the results to the console. You should receive an output like this:<\/p>\n
    [\u2018Hey\u2019, \u2018everyone!\u2019, \u2018The\u2019, \u2018party\u2019, \u2018starts\u2019, \u2018in\u2019, \u201810mins.\u2019, \u2018Be\u2019, \u2018there\u2019, \u2018ASAP!\u2019]<\/span><\/pre>\n
    The split()<\/code> function is one of the simplest tokenizers. It looks for whitespace as the delimiter (the limit or boundary) and takes the words around it. However, we can take this to the next level with more functions. Type the following:<\/p>\n
    from<\/strong> nltk.tokenize import<\/strong> word_tokenize, regexp_tokenize\nword_tokenize(msg)<\/span><\/pre>\n
      \n
    1. We import 2 functions from the nltk.tokenize<\/code> list of functions.<\/li>\n
    2. First, let\u2019s look at the word_tokenize()<\/code> function. This is very similar to the split()<\/code> function with one key difference. Instead of looking for the whitespace as the delimiter, it even splits the punctuation, as it considers exclamation points and periods as their own tokens.<\/li>\n<\/ol>\n
      This is what your output should look like:<\/p>\n
      [\u2018Hey\u2019,\n \u2018everyone\u2019,\n \u2018!\u2019,\n \u2018The\u2019,\n \u2018party\u2019,\n \u2018starts\u2019,\n \u2018in\u2019,\n \u201810mins\u2019,\n \u2018.\u2019,\n \u2018Be\u2019,\n \u2018there\u2019,\n \u2018ASAP\u2019,\n \u2018!\u2019]<\/span><\/pre>\n
      Finally, let\u2019s take a look at the regex_tokenize<\/code> function. This is an even more advanced tokenizer that can be customized to fit your needs. Let\u2019s take a look at an example:<\/p>\n
      regexp_tokenize(msg, pattern=\u201d\\w+\u201d)<\/span><\/pre>\n
      You might notice that we have an extra parameter in this function called pattern<\/code>. This is where developers can choose how they want to tokenize the text. \\w+<\/code> means that we want all words and digits to be in our token, but symbols like punctuation can be ignored. This is why our output looks like this:<\/p>\n
      [\u2018Hey\u2019,\n \u2018everyone\u2019,\n \u2018The\u2019,\n \u2018party\u2019,\n \u2018starts\u2019,\n \u2018in\u2019,\n \u201810mins\u2019,\n \u2018Be\u2019,\n \u2018there\u2019,\n \u2018ASAP\u2019]<\/span><\/pre>\n
      Now, let\u2019s try a different pattern:<\/p>\n
      regexp_tokenize(msg, pattern=\u201d\\d+\u201d)<\/span><\/pre>\n
      Just like before, we have the same function, but with a different pattern: \\d+<\/code>. This asks the text to print only the digits. That\u2019s why our output only contains the number 10.<\/p>\n
      [\u201810\u2019]<\/span><\/pre>\n
      These are the two most common tokenizers you\u2019ll need to clean up your text. Next, let\u2019s move over to stemming, another crucial step in text wrangling.<\/p>\n
      Stemming<\/h1>\n
      Stemming is exactly what it sounds like\u2014cutting down a token to its root stem. For instance, take the word \u201crunning\u201d. It can be broken down to its root: \u201crun\u201d. However, \u201crun\u201d itself has many variation: runs, ran, etc. With stemming, we can club all the variations of the word into a single root. Let\u2019s look at the code to do this:<\/p>\n
      from<\/strong> nltk.stem import<\/strong> PorterStemmer\nporter = PorterStemmer()\nporter.stem(\u201crunning\u201d)<\/span><\/pre>\n
        \n
      1. First, we import the PorterStemmer<\/code> from the toolkit. There are many algorithms to stem words, and PorterStemmer<\/code> uses just one of the many. However, I\u2019ve found it to be the most precise since it uses a lot of rules.<\/li>\n
      2. Next, we define a variable called porter<\/code> and set it equal to the PorterStemmer()<\/code>.<\/li>\n
      3. Finally, we ask the stemmer to stem the word \u201crunning\u201d. You should receive the following output:<\/li>\n<\/ol>\n
        \u2018run\u2019<\/span><\/pre>\n
        Now, you could skip to the next section, but I\u2019d like to take a moment and show you two more stemmers that use different algorithms. The first is Lancaster stemming<\/a>. It\u2019s very easy to implement and the results are close to that of Porter stemming<\/a>. Here\u2019s a look:<\/p>\n
        from<\/strong> nltk.stem import<\/strong> LancasterStemmer\nlancaster = LancasterStemmer()\nlancaster.stem(\u201ceating\u201d)<\/span><\/pre>\n
        You should recognize this code by now. It\u2019s the same as the previous example, only this time we import LancasterStemmer<\/code>. Running the stemmer on the word \u201ceating\u201d gives us an output of:<\/p>\n
        \u2018eat\u2019<\/span><\/pre>\n
        Now, the last stemmer I want to show you is the SnowballStemmer<\/a><\/code>. What makes this stemmer unique is that it\u2019s been trained on many languages and works well for English, German, French, Russian, and many others. Here\u2019s how you implement it. It\u2019s a little different from the previous two stemmers:<\/p>\n
        from<\/strong> nltk.stem.snowball import<\/strong> SnowballStemmer\nsnowball = SnowballStemmer(\u201cenglish\u201d)\nsnowball.stem(\u201chaving\u201d)<\/span><\/pre>\n
          \n
        1. Instead of nltk.stem<\/code>, we import SnowballStemmer<\/code> from nltk.stem.snowball<\/code> since it is another major subsection.<\/li>\n
        2. We define snowball<\/code> as our stemmer. However, when we do so, we define which language the stemmer should detect.<\/li>\n
        3. Finally, we stem the word using our newly-created stemmer.<\/li>\n<\/ol>\n
          \u2018have\u2019<\/span><\/pre>\n
          Stemming is great for its simplicity in NLP-related tasks. However, if we want to get more complex, stemming won\u2019t be the best technique to use. Instead, this is where lemmatization<\/strong> shines.<\/p>\n
          Lemmatization<\/h1>\n
          Lemmatization is much more advanced than stemming because rather than just following rules, this process also takes into account context and part of speech to determine the lemma<\/em>, or the root form of the word. Here\u2019s a perfect example to show the difference between lemmatization and stemming:<\/p>\n
          nltk.download(\u2018wordnet\u2019)\nfrom<\/strong> nltk.stem import<\/strong> WordNetLemmatizer\nlem = WordNetLemmatizer()\nprint(lem.lemmatize(\u201cate\u201d))\nprint(porter.stem(\u201cate\u201d))<\/span><\/pre>\n
            \n
          1. First we download wordnet<\/code> from the toolkit. Wordnet<\/code> is a massive semantic dictionary that\u2019s used for search-specific lemmas <\/em>of words.<\/li>\n
          2. Next, we import the WordNetLemmatizer<\/code> from nltk.stem<\/code><\/li>\n
          3. We define our variable lem<\/code> to be the lemmatization function.<\/li>\n
          4. Finally, we lemmatize the word \u201cate\u201d and ask the results to be printed to the console.<\/li>\n
          5. For comparison, we use our previously created PorterStemmer<\/code> to stem the same word and print the result to the console.<\/li>\n<\/ol>\n
            WordNet is constantly updating, but at the time of writing, this is what my console displayed:<\/p>\n
            eat\nate<\/span><\/pre>\n
            So we can see that through lemmatization, we can even detect the tenses of the word and present the simplest form of the word in the present tense, all with a few lines of code. Lemmatization is one of the many powerful techniques in text wrangling.<\/p>\n
            Stop Word removal<\/h1>\n
            Finally, we come to the last section of this tutorial\u2014stop word removal. Stop words are commonly-used word that are usually ignored because of their many occurrences. Most of these words are articles and prepositions, such as \u201cthe\u201d, \u201ca\u201d, \u201cin\u201d, etc.<\/p>\n
            These words can either end up taking too much space or eating up too much time. Luckily, nltk<\/code> has a list of stop words in 16 different languages. We can use this list to parse paragraphs of text and remove the stop words from them. Here\u2019s how to do it:<\/p>\n
            nltk.download(\u2018stopwords\u2019)\nfrom<\/strong> nltk.corpus import<\/strong> stopwords\nlist = stopwords.words(\u2018english\u2019)\nparagraph = \u201cThis is a long paragraph of text. Somtimes important words like Apple and Machine Learning show up. Other words that are not important get removed.\u201d\npostPara = [word for word in paragraph.split() if word not in list]\nprint(postPara)<\/span><\/pre>\n
            This is perhaps the most complex code in this tutorial, so I\u2019ll run through it piece-by-piece:<\/p>\n
              \n
            1. First, we download the stopwords<\/code> from the toolkit.<\/li>\n
            2. Next, we import all the stop words from nltk.corpus<\/code>. A corpus<\/strong> is a large dataset of texts.<\/li>\n
            3. Next, we define a variable list<\/code> and set this to contain all the English stop words.<\/li>\n
            4. As with any text wrangling technique, we need a sample text, so we type up a short paragraph and define it as the variable paragraph<\/code>.<\/li>\n
            5. We create a new variable called postPara<\/code>, which is an array of all the words in paragraph<\/code> split up and not including the words in list<\/code>.<\/li>\n
            6. Finally, we print postPara<\/code> to our console:<\/li>\n<\/ol>\n
              [\u2018This\u2019, \u2018long\u2019, \u2018paragraph\u2019, \u2018text.\u2019, \u2018Somtimes\u2019, \u2018important\u2019, \u2018words\u2019, \u2018like\u2019, \u2018Apple\u2019, \u2018Machine\u2019, \u2018Learning\u2019, \u2018show\u2019, \u2018up.\u2019, \u2018Other\u2019, \u2018words\u2019, \u2018important\u2019, \u2018get\u2019, \u2018removed.\u2019]<\/span><\/pre>\n
              As you can see, our text is split up into different words, but the stop words are removed, showing you only the words deemed important. Most articles and prepositions are gone!<\/p>\n
              Conclusion<\/h1>\n
              As you can see, text wrangling can be essential in making sure you have the best data to work with. With NLTK, it\u2019s easier than ever to run complex algorithms on your text using only a few lines of code. You can split up your text however you want, weed out the unnecessary parts, and even reduce it to make it the most logical form for your computations.<\/p>\n
              We\u2019ve barely scratched the surface in terms of what can be done with NLTK. I\u2019d suggest taking a look at the official NLTK website<\/a>. Feel free to leave me a message in the comments if you\u2019ve got a question or need some help! For reference, here is the link to the complete Colab notebook<\/a>.<\/p>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
              What is Text Wrangling? Although is has many forms, text wrangling is basically the pre-processing work that\u2019s done to prepare raw text data ready for training. Simply put, it\u2019s the process of cleaning your data to make it readable by your program, and then formatting it as such. Many of you may be wrangling text […]<\/p>\n","protected":false},"author":83,"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":"","footnotes":""},"categories":[6],"tags":[],"coauthors":[180],"class_list":["post-7346","post","type-post","status-publish","format-standard","hentry","category-machine-learning"],"yoast_head":"\nIntroduction to Text Wrangling Techniques for Natural Language Processing - Comet<\/title>\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\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Introduction to Text Wrangling Techniques for Natural Language Processing\" \/>\n<meta property=\"og:description\" content=\"What is Text Wrangling? Although is has many forms, text wrangling is basically the pre-processing work that\u2019s done to prepare raw text data ready for training. Simply put, it\u2019s the process of cleaning your data to make it readable by your program, and then formatting it as such. Many of you may be wrangling text […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/\" \/>\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-08-29T21:50:38+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-04-24T17:14:27+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/miro.medium.com\/v2\/resize:fit:2000\/1*GyAwrqkCetMRkGWGibdgOA.jpeg\" \/>\n<meta name=\"author\" content=\"Sai Kambampati\" \/>\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=\"Sai Kambampati\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minutes\" \/>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Introduction to Text Wrangling Techniques for Natural Language Processing - Comet","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\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/","og_locale":"en_US","og_type":"article","og_title":"Introduction to Text Wrangling Techniques for Natural Language Processing","og_description":"What is Text Wrangling? Although is has many forms, text wrangling is basically the pre-processing work that\u2019s done to prepare raw text data ready for training. Simply put, it\u2019s the process of cleaning your data to make it readable by your program, and then formatting it as such. Many of you may be wrangling text […]","og_url":"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/","og_site_name":"Comet","article_publisher":"https:\/\/www.facebook.com\/cometdotml","article_published_time":"2023-08-29T21:50:38+00:00","article_modified_time":"2025-04-24T17:14:27+00:00","og_image":[{"url":"https:\/\/miro.medium.com\/v2\/resize:fit:2000\/1*GyAwrqkCetMRkGWGibdgOA.jpeg","type":"","width":"","height":""}],"author":"Sai Kambampati","twitter_card":"summary_large_image","twitter_creator":"@Cometml","twitter_site":"@Cometml","twitter_misc":{"Written by":"Sai Kambampati","Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/#article","isPartOf":{"@id":"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/"},"author":{"name":"Sai Kambampati","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/687f104c400b25f91a596170b5f4af9d"},"headline":"Introduction to Text Wrangling Techniques for Natural Language Processing","datePublished":"2023-08-29T21:50:38+00:00","dateModified":"2025-04-24T17:14:27+00:00","mainEntityOfPage":{"@id":"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/"},"wordCount":1722,"publisher":{"@id":"https:\/\/www.comet.com\/site\/#organization"},"image":{"@id":"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/#primaryimage"},"thumbnailUrl":"https:\/\/miro.medium.com\/v2\/resize:fit:2000\/1*GyAwrqkCetMRkGWGibdgOA.jpeg","articleSection":["Machine Learning"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/","url":"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/","name":"Introduction to Text Wrangling Techniques for Natural Language Processing - Comet","isPartOf":{"@id":"https:\/\/www.comet.com\/site\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/#primaryimage"},"image":{"@id":"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/#primaryimage"},"thumbnailUrl":"https:\/\/miro.medium.com\/v2\/resize:fit:2000\/1*GyAwrqkCetMRkGWGibdgOA.jpeg","datePublished":"2023-08-29T21:50:38+00:00","dateModified":"2025-04-24T17:14:27+00:00","breadcrumb":{"@id":"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/#primaryimage","url":"https:\/\/miro.medium.com\/v2\/resize:fit:2000\/1*GyAwrqkCetMRkGWGibdgOA.jpeg","contentUrl":"https:\/\/miro.medium.com\/v2\/resize:fit:2000\/1*GyAwrqkCetMRkGWGibdgOA.jpeg"},{"@type":"BreadcrumbList","@id":"https:\/\/www.comet.com\/site\/blog\/introduction-to-text-wrangling-techniques-for-natural-language-processing\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.comet.com\/site\/"},{"@type":"ListItem","position":2,"name":"Introduction to Text Wrangling Techniques for Natural Language Processing"}]},{"@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\/687f104c400b25f91a596170b5f4af9d","name":"Sai Kambampati","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.comet.com\/site\/#\/schema\/person\/image\/e37628a7389669a684002af46e2c007b","url":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2023\/08\/9nO1Y5uI_400x400-96x96.jpg","contentUrl":"https:\/\/www.comet.com\/site\/wp-content\/uploads\/2023\/08\/9nO1Y5uI_400x400-96x96.jpg","caption":"Sai Kambampati"},"url":"https:\/\/www.comet.com\/site\/blog\/author\/saikambampatigmail-com\/"}]}},"_links":{"self":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/7346","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\/83"}],"replies":[{"embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/comments?post=7346"}],"version-history":[{"count":1,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/7346\/revisions"}],"predecessor-version":[{"id":15563,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/posts\/7346\/revisions\/15563"}],"wp:attachment":[{"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/media?parent=7346"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/categories?post=7346"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/tags?post=7346"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.comet.com\/site\/wp-json\/wp\/v2\/coauthors?post=7346"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}