QuiqQuiq

Tag: data

AI Model Evaluation: 2026 Guide

Posted on J.R. Rettenmeyer

Key takeaways

  • AI performance starts with evaluation. Metrics and human insight work together to keep models accurate, reliable, and bias-free.
  • Use the right tools for the job. Regression relies on MSE or RMSE; classification leans on accuracy, precision, and recall.
  • Generative AI needs extra care. Scores like BLEU and BERT help, but human review ensures outputs sound natural and on-brand.
  • Trust is built through testing. Continuous evaluation keeps AI aligned with real-world performance and customer expectations.

Machine learning is an incredibly powerful technology. That’s why it’s being used in everything from autonomous vehicles to medical diagnoses to the sophisticated, dynamic AI Assistants that are handling customer interactions in modern contact centers.

But for all this, it isn’t magic. The engineers who build these systems must know a great deal about how to evaluate them. How do you know when a model is performing as expected, or when it has begun to overfit the data? How can you tell when one of the multiple models is better than another?

That’s where AI model evaluation comes in. At its core, AI model evaluation is the process of systematically measuring and assessing an AI system’s performance, accuracy, reliability, and fairness. This includes using quantitative metrics (like accuracy or BLEU), testing with unseen data, and incorporating human review to check for issues such as biased outcomes or coherence.

It’s a critical step for determining a model’s readiness for real-world deployment, ensuring trustworthiness, and guiding continuous improvement.

This subject will be our focus today. We’ll cover the basics of evaluating a machine learning model with metrics like mean squared error and accuracy, then turn our attention to the more specialized task of evaluating the generated text of a large language model like ChatGPT.

How to evaluate model performance

A machine learning model is always aimed at some task. It might be predicting sales, grouping topics, generating text, or some other type of model performance.

How does the model know when it’s gotten the optimal line or discovered the best way to cluster documents?

In the next few sections, we’ll talk about a few common evaluation methods for a machine-learning model. If you’re an engineer, this will help you create better models yourself, and if you’re a layperson, it’ll help you better understand how the machine-learning pipeline works and you’ll get the baseline of how the evaluation process looks like.

To answer that, the evaluation must assess multiple dimensions:

  1. performance (are the predicted values accurate?)
  2. weaknesses (does it generalize to unseen data or overfit?)
  3. trustworthiness (can it be explained and trusted?)
  4. fairness (is it biased toward certain groups?).

Together, these components give a complete picture of model quality.

Model evaluation metrics for regression models

Regression is one of the two big types of basic machine learning, with the other being classification.

In tech-speak, we say that the purpose of a regression model is to learn a function that maps a set of input features to a real value (where “real” just means “real numbers”).

This is not as scary as it sounds; you might try to create a regression model that predicts the number of sales you can expect given that you’ve spent a certain amount on advertising, or you might try to predict how long a person will live on the basis of their daily exercise, water intake, and diet.

In each case, you’ve got a set of input features (advertising spend or daily habits), and you’re trying to predict a target variable (sales, life expectancy).

The relationship between the two is captured by a model, and a model’s quality is evaluated with a metric. Popular metrics for regression models include:

  • mean squared error (MSE)
  • root mean squared error (RMSE)
  • mean absolute error (MAE)

However, there are plenty of others if you feel like going down a nerdy rabbit hole.

Model evaluation metrics for classification models

People tend to struggle less with understanding classification models because it’s more intuitive: you’re building something that can take a data point (the price of an item) and sort it into one of a number of different categories (i.e., “cheap”, “somewhat expensive”, “expensive”, “very expensive”).

Regardless, it’s just as essential to evaluate the performance of a classification model as it is to evaluate the performance of a regression model. Some common evaluation metrics for classification models are accuracy, precision, and recall.

Accuracy is simple, and it’s exactly what it sounds like. You find the accuracy of a classification model by dividing the number of correct predictions it made by the total number of predictions it made altogether. If your classification model made 1,000 predictions and got 941 of them right, that’s an accuracy rate of 94.1% (not bad!)

Both precision and recall are subtler variants of this same idea. The precision is the number of true positives (correct classifications) divided by the sum of true positives and false positives (incorrect positive classifications). It says, in effect, “When your model thought it had identified a needle in a haystack, this is how often it was correct.”

The recall is the number of true positives divided by the sum of true positives and false negatives (incorrect negative classifications). It says, in effect, “There were 200 needles in this haystack, and your model found 72% of them.”

Accuracy tells you how well your model performed overall, precision tells you how confident you can be in its positive classifications, and recall tells you how often it found the positive classifications.

Contact Us

How do I start with evaluating AI models and their performance?

Now, we arrive at the center of this article. Everything up to now has been background context that hopefully has given you a feel for how models are evaluated, because from here on out, it’s a bit more abstract.

Using reference text for evaluating generative models against training data

When we wanted to evaluate a regression model, we started by looking at how far its predictions were from actual data points.

Well, we do essentially the same thing with generative language models. To assess the quality of text generated by a model, we’ll compare it against high-quality text that’s been selected by domain experts.

The bilingual evaluation understudy (BLEU) score

The BLEU score can be used to actually quantify the distance between the generated and reference text. It does this by comparing the amount of overlap in the n-grams [1] between the two using a series of weighted precision scores.

The BLEU score varies from 0 to 1. A score of “0” indicates that there is no n-gram overlap between the generated and reference text, and the model’s output is considered to be of low quality. A score of “1”, conversely, indicates that there is total overlap between the generated and reference text, and the model’s output is considered to be of high quality.

Comparing BLEU scores across different sets of reference texts or different natural languages is so tricky that it’s considered best to avoid it altogether.

Also, be aware that the BLEU score contains a “brevity penalty” which discourages the model from being too concise. If the model’s output is too much shorter than the reference text, this counts as a strike against it.

The Recall-Oriented Understudy for Gisting Evaluation (ROGUE) Score

Like the BLEU score, the ROGUE score examines the n-gram overlap between an output text and a reference text. Unlike the BLEU score, however, it uses recall instead of precision.

There are three types of ROGUE scores:

  • rogue-n: Rogue-n is the most common type of ROGUE score, and it simply looks at n-gram overlap, as described above.
  • rogue-l: Rogue-l looks at the “Longest Common Subsequence” (LCS), or the longest chain of tokens that the reference and output text share. The longer the LCS, of course, the more the two have in common.
  • rogue-s: This is the least commonly-used variant of the ROGUE score, but it’s worth hearing about. Rogue-s concentrates on the “skip-grams” [2] that the two texts have in common. Rogue-s would count “He bought the house” and “He bought the blue house” as overlapping because they have the same words in the same order, despite the fact that the second sentence does have an additional adjective.

The Metric for Evaluation of Translation with Explicit Ordering (METEOR) Score

The METEOR Score takes the harmonic mean of the precision and recall scores for 1-gram overlap between the output and reference text. It puts more weight on recall than on precision, and it’s intended to address some of the deficiencies of the BLEU and ROGUE scores while maintaining a pretty close match to how expert humans assess the quality of model-generated output.

BERT Score

At this point, it may have occurred to you to wonder whether the BLEU and ROGUE scores are actually doing a good job of evaluating the performance of a generative language model. They look at exact n-gram overlaps, and most of the time, we don’t really care that the model’s output is exactly the same as the reference text – it needs to be at least as good, without having to be the same.

The BERT score is meant to address this concern through contextual embeddings. By looking at the embeddings behind the sentences and comparing those, the BERT score is able to see that “He quickly ate the treats” and “He rapidly consumed the goodies” are expressing basically the same idea, while both the BLEU and ROGUE scores would completely miss this.

How to choose the right evaluation metrics for your use case

Choosing the right evaluation metrics starts with understanding what your model is supposed to do and how its outputs will be used in practice. A model that predicts numerical values, such as sales forecasts, should be evaluated differently from one that classifies categories or generates text.

First, align metrics with your objective. For regression tasks, focus on how close your predicted and actual values are using metrics like MAE or RMSE. For classification, look at accuracy, average precision, and recall depending on whether false positives or false negatives matter more. For generative systems, combine automated scores with human review to judge quality and relevance.

Next, consider the quality and structure of your test data. Your evaluation results are only as reliable as the data you test on. Make sure it reflects real-world scenarios, edge cases, and variations your model will face after deployment.

You should also evaluate across multiple dimensions, not just a single score. A model may show strong model performance on average but fail in specific segments or edge cases. Looking at different metrics together gives a more balanced view of model predictions.

Finally, aim for a robust evaluation process that evolves over time. As your data changes and your model is updated, your evaluation approach should adapt as well. Regularly reviewing evaluation results helps catch performance drops early and ensures your model continues to meet expectations in real-world conditions.

Why AI Model Evaluation is Critical

Agentic AI is redefining how businesses operate – automating reasoning, decision-making, and task execution across fields like engineering and CX. But with that autonomy comes risk. Every AI agent must be carefully evaluated, monitored, and fine-tuned to ensure it performs reliably and aligns with your brand’s goals. Otherwise, even a small model error can compound into major consequences for your brand

If you’re enchanted by the potential of using agentic AI in your contact center but are daunted by the challenge of putting together an engineering team, reach out to us for a demo of the Quiq agentic AI platform. We can help you put this cutting-edge technology to work without having to worry about all the finer details and resourcing issues.

***

Footnotes

[1] An n-gram is just a sequence of characters, words, or entire sentences. A 1-gram is usually single words, a 2-gram is usually two words, etc. [2] Skip-grams are a rather involved subdomain of natural language processing. You can read more about them in this article, but frankly, most of it is irrelevant to this article. All you need to know is that the rogue-s score is set up to be less concerned with exact n-gram overlaps than the alternatives.

Frequently Asked Questions (FAQs)

What does AI model evaluation mean?

It’s how teams measure whether an AI system is performing as intended, accurate, fair, and ready for real-world use.

Why does AI model evaluation matter?

Evaluation exposes blind spots early and helps build confidence that the model can be trusted with customer-facing tasks.

How are generative models evaluated?

Metrics like BLEU, ROUGE, and BERT gauge quality, while human reviewers check tone, clarity, and usefulness.

Can metrics replace human judgment?

Not yet. Automated scores quantify performance, but humans still define what “good” sounds like.

How do I know if my model is ready?

When it performs consistently across test data, aligns with business goals, and earns trust through transparent evaluation.

AI Data Preparation: The Hidden Step Between Your Data and Your AI Success

Posted on Greg Dreyfus

Key Takeaways

  • Data Preparation is the Foundation: The success of AI in customer experience depends more on the quality of the “fuel” (your data) than the specific AI model you choose. Poor data quality and inadequate data preparation are leading reasons why AI projects fail, often resulting in unreliable or biased outcomes.
  • Digital Transformation Doesn’t Equal AI Readiness: Simply having data in the cloud isn’t enough. AI requires context and retrieval, meaning documents must be “chunked,” de-duplicated, and stripped of outdated “noise.”
  • Avoid the “Data Dump”: Quality beats quantity. Feeding an AI outdated or conflicting documents leads to hallucinations and poor customer trust.
  • Always Be Optimizing: Data prep is not a “one-and-done” task. It requires a human-in-the-loop workflow to flag errors and update the knowledge base as policies evolve.

Every customer experience leader wants to deploy AI that feels natural, helpful, and brand-aligned. We all want the “magic” outcome: an AI agent that knows your return policy by heart, checks order status in seconds, and speaks with the same empathy as your best human agent.

But often, when leaders plug their existing data into a new AI model, the magic doesn’t happen. Instead, the AI hallucinates, gives outdated answers, or gets stuck in a loop.

The problem usually isn’t the AI model itself. It’s the fuel you’re putting in the tank.

Most enterprise data — scattered across PDFs, legacy CRMs, and dusty knowledge bases — isn’t ready for generative or agentic AI. It needs to be refined first. 

In the CX world, data preparation isn’t just a technical hurdle; it’s the bridge between a generic chatbot and a brand-aligned AI agent. It involves the intentional collection, cleaning, and structuring of your enterprise knowledge to ensure the model produces reliable outcomes rather than creative fiction. This process is called AI data preparation, and it is the single most critical factor in whether your AI project succeeds or stalls. Inadequate data preparation and poor data quality are primary reasons why AI projects fail, leading to unreliable models and flawed predictions.

Here is what it actually takes to get your data ready for prime time, and why it matters more than the model you choose.

What is AI Data Preparation?

In simple terms, AI data preparation is the process of collecting, cleaning, labeling, and structuring your raw data (these are key data preparation steps) so an AI model can actually understand and use it. Data cleaning and maintaining data consistency are crucial during this process to ensure the data is accurate, reliable, and ready for AI modeling.

Think of your current data like a library, where all the books have been thrown onto the floor in a pile. The information is there, but if you ask someone to “find the answer to X,” they will spend hours searching. Effective AI data preparation requires gathering data from multiple sources, converting data into standardized formats, and combining it into a unified dataset with a consistent data structure.

AI data preparation is the act of picking up those books, dusting them off, organizing them by topic, and indexing them. It transforms raw information into a structured resource that an AI can retrieve instantly.

For a customer experience leader, this usually involves three specific types of data work:

  1. Refining Knowledge: Taking human-readable documents (FAQs, PDFs, manuals) and turning them into machine-readable chunks.
  2. Structuring Customer History: Ensuring your CRM data (past orders, loyalty status) is clean and accessible via API.
  3. Sanitizing Logs: Cleaning up past conversation transcripts to remove Personally Identifiable Information (PII) before using them for training.

Why “General” Data Transformation Isn’t Enough

You might be thinking, “We already did a digital transformation project three years ago. Our data is in the cloud. We’re good.”

Unfortunately, digital readiness is not the same as AI readiness.

General data transformation usually focuses on storage and analytics — moving data from on-premise servers to the cloud so humans can look at dashboards. AI readiness focuses on context and retrieval.

For example, a PDF of your 2023 Holiday Return Policy might be stored safely in the cloud. But if that PDF also contains the 2022 and 2021 policies in the appendix, a generative AI model might get confused and quote the wrong year. During AI data preparation, it is crucial to standardize data formats and address inconsistent data through careful data processing. This ensures that information is consistent, accurate, and ready for effective AI analysis.

Preparing data for AI means stripping away the noise, ensuring accuracy, and formatting it so the AI knows exactly what piece of information applies to which customer question.

Get 3 Simple Steps to Prepare Your Data for Agentic AI here.

Data Collection: Laying the Groundwork for AI

Every successful AI project starts with one essential step: data collection. This is where the data preparation process truly begins, as you gather raw data from a variety of sources—databases, APIs, third-party providers, and even legacy systems. 

The quality and diversity of this initial data set the stage for everything that follows, directly influencing how well your AI systems will perform.

Effective data collection means more than just amassing large volumes of information. It means ensuring that the data is relevant, accurate, and representative of the real-world scenarios your AI model will encounter. 

Data engineers play a pivotal role here, carefully navigating challenges like missing values, inconsistent formats, and the need for data cleansing. They transform raw data into a usable format, addressing gaps and errors before the data ever reaches your AI model.

The 3 Pillars of Data Preparation for AI 

To move from “we have data” to “we have AI-ready data,” you must focus on these three foundational pillars. Think of these not just as technical tasks, but as the guardrails for your brand’s reputation.

1. Curating Your Knowledge: Defining the “Source of Truth”

Your AI agent is only as smart as the documents you feed it. In the CX world, the greatest risk isn’t a lack of information; it’s conflicting information. If your public-facing website says “Free Returns within 30 days,” but an internal PDF manual from 2022 still says “14 days,” your AI will eventually hallucinate a contradiction. When an AI is forced to choose between two “truths,” it fails, and so does your customer’s trust.

The Cleanup Process:

  • Audit: Identify where your “truth” lives. Is it on the website? In a Google Drive folder? In a legacy knowledge base?
  • Consolidate: Bring these sources together. Using a data warehouse can help you efficiently consolidate and manage large volumes of structured data from multiple sources.
  • De-duplicate: If you have three versions of a “How to reset password” guide, delete the two old ones.
  • Chunking: This is a technical step where long documents are broken down into smaller, bite-sized pieces (chunks) that an LLM can digest easily.

Why it matters: When a customer asks, “Can I bring my dog to the hotel?”, the AI shouldn’t have to read a 50-page employee handbook to find the answer. It needs a clean, single paragraph stating the pet policy.

2. Connecting the Pipes: Closing the “Actionability Gap”

There is a massive difference between a Chatbot and an AI Agent. A chatbot can tell you your policy; an agent can actually execute it.

Without API connectivity, you are left with the “Actionability Gap”, the frustrating moment where an AI can identify a customer’s problem but has to hand them off to a human to actually fix it. To close this gap, your data must be “transactional.”

The Connection Process:

  • Identify Systems: Which tools hold the data the customer cares about? Usually, this is your CRM (Salesforce, Zendesk), your Order Management System (OMS), and your Booking Engine.
  • API Health Check: Do these systems have open APIs? Can they “talk” to external tools safely?
  • Field Mapping: For example, ensuring that “Customer_ID” in your chat system matches “Cust_Ref_No” in your shipping system. This mapping is crucial for transferring structured data accurately between systems, as APIs typically handle organized, well-defined data formats.

Why it matters: Without this step, your AI is just a conversational FAQ bot. With this step, it becomes an agent capable of resolving complex issues.

3. Sanitizing Raw Data for Safety: Preventing “LLM Leakage”

This is the step that keeps CX leaders awake at night. You cannot feed raw customer data into a public LLM without creating major privacy risks.

The Safety Process:

  • PII Redaction: Automatically detecting and scrubbing names, credit card numbers, and addresses from training data, with special attention to identifying and protecting sensitive data to ensure compliance with privacy laws and safeguard user information.
  • Bias Detection: Reviewing historical data to ensure the AI doesn’t learn bad habits from past human interactions.
  • Access Control: ensuring the AI only accesses the data it is authorized to see.

From Raw Documents to AI-ready Assets: The Power of AI Resources

Once you’ve collected your data, you must give it meaning. In traditional data science, this involves manual data labeling and numerical encoding. In the modern CX stack, Quiq’s AI Studio streamlines this through an integrated ETL (Extract, Transform, Load) engine within AI Resources.

Instead of manual annotation, you can import knowledge bases, product catalogs, or manuals and run them through a series of specialized LLM prompts to make them “AI-ready”. This engine automates the heavy lifting, for example:

  • Extracting Helpful Links: Identifying and surfacing relevant URLs within the content.
  • Clarification: Removing unnecessary HTML formatting or outdated instructions like “contact us” to reduce noise.
  • Contextual Questioning: Automatically generating a set of potential customer questions that each specific article is designed to answer.

These types of transformations ensure your data isn’t just understandable to humans, but highly searchable and “digestible” for advanced AI agents.

Common Pitfalls in the Data Preparation Process (And How to Avoid Them)

We see many brands try to rush the data preparation process. Inaccurate data can undermine model performance, making it essential to address data quality issues early. Here are the traps to watch out for.

The “Dump Everything” Approach

  • The Mistake: Uploading every document the company has ever produced into the AI model, hoping it will figure it out. This often results in a mix of unstructured data, making AI data preparation more complex and error-prone because AI Agents can’t tell you which answer is right without a clear distinction if you have two conflicting sources of information.
  • The Consequence: The AI gets confused by outdated info (like that Return Policy from 2019) and hallucinates answers.
  • The Fix: Be selective. It is better to have a small, 100% accurate knowledge base than large and diverse datasets that are messy.

The “Perfect Data” Paralysis

  • The Mistake: Waiting until every single data point in the company is perfect before launching an AI pilot.
  • The Consequence: You never launch. Competitors pass you by.
  • The Fix: Use a “Crawl, Walk, Run” approach. Start with proper data preparation for one specific use case — like “Order Status” or “Password Reset” — to ensure data quality and improve model accuracy, then expand from there.

Ignoring the Human Loop

  • The Mistake: Assuming the data preparation is a one-time setup.
  • The Consequence: Your products change, your policies update, but your AI stays stuck in the past.
  • The Fix: Build a workflow where human agents can flag incorrect AI answers, which then triggers an update to the source data. Incorporate strong data governance practices to ensure ongoing updates are tracked, data remains accurate, and compliance with regulations like GDPR and HIPAA is maintained.

Your Next Step: The Data Audit

You probably don’t need to hire a team of data scientists to get started. You just need to look at your current CX operations with an AI lens.

Start with a simple audit of your top 10 call drivers. For each topic (e.g., “Where is my order?”), ask three questions:

  1. Is the answer written down clearly somewhere? (Knowledge)
  2. Is it accurate and up to date? (Quality)
  3. Does the answer require checking a system? (Connectivity)

If you can answer “Yes” to these, you are closer to AI readiness than you think. Ensuring your data is high-quality and relevant directly leads to more accurate and reliable outcomes.

Quiq’s Approach to AI Data Preparation

Getting your data AI-ready isn’t a fast project—most organizations underestimate just how time-consuming and complex it can be. That’s why we built AI-powered data restructuring directly into our process at Quiq. 

We handle the heavy lifting behind the scenes, so you can move from raw data to real results without sacrificing speed or confidence. Compared to other vendors, Quiq can host multiple datasets (e.g., 10 separate FAQs for 10 different markets, with 10 different product catalogs). This means you don’t have conflicting data co-mingled, and your AI Agent can select the right sources based on the conversation context.

But don’t just take our word for it: Read our case study with A Closer Look to learn how we unified their huge data volume of existing records for more efficient AI outcomes and success.

Frequently Asked Questions (FAQs)

What is AI data preparation in customer experience?

AI data preparation is the critical process of collecting, cleaning, and structuring raw enterprise data—such as FAQs, PDFs, and CRM logs—so generative AI models can understand and use it accurately. It transforms scattered information into a machine-readable format to prevent hallucinations and ensure brand-aligned responses.

Why does my AI agent give incorrect or outdated answers?

High quality data matters. Usually, the problem is not the AI model, but the data source. If your AI has access to poor quality data or conflicting documents (e.g., a 2022 return policy and a 2024 update), it may retrieve the wrong information. Proper AI data preparation involves de-duplicating files and ensuring only the “current truth” is accessible.

What is the difference between digital transformation and AI readiness?

Digital transformation focuses on storage and analytics (data movement to the cloud for humans to see). AI readiness focuses on context and retrieval (organizing data so a machine can find a specific answer in seconds). AI-ready data is “chunked” into small pieces that LLMs can digest easily.

How do I make my AI agent perform actions like processing refunds?

To move beyond a simple chatbot, you need to connect your AI to internal systems via APIs. This allows the AI to “talk” to your CRM (like Salesforce or Zendesk) and Order Management Systems, enabling it to perform transactional tasks like checking order status or updating a booking based on your business data.

Is it safe to use customer data with generative AI?

Safety requires a strict sanitization process. Before using customer logs for training, you must redact PII (names, addresses, and credit cards) and implement access controls. This ensures the AI only accesses authorized data and protects your organization from privacy risks.

What is NLP Preprocessing? Top 12 Techniques

Posted on The Quiq Team

Along with computer vision, natural language processing (NLP) is one of the great triumphs of modern machine learning. While ChatGPT is all the rage and large language models (LLMs) are drawing everyone’s attention, that doesn’t mean that the rest of the NLP field just goes away.

NLP endeavors to apply computation to human-generated language, whether that be the spoken word or text existing in places like Wikipedia. There are a number of ways in which this would be relevant to customer experience and service leaders, including:

  • Using it to power customer-facing AI agents
  • Creating question-answering systems
  • Classifying sentiment from e.g., customer reviews
  • Automatically transcribing client calls

Today, we’re going to briefly touch on what NLP is, but we’ll spend the bulk of our time discussing how textual training data can be preprocessed to get the most out of an NLP system. There are a few branches of NLP, like speech synthesis and text-to-speech recognition, which we’ll be omitting.

Armed with this context, you’ll be better prepared to evaluate using NLP in your business (though if you’re building customer-facing AI agents, you can also let the Quiq platform do the heavy lifting for you).

What is Natural Language Processing (NLP)?

In the past, we’ve jokingly referred to NLP as “doing computer stuff with words after you’ve tricked them into being math.” This is meant to be humorous, but it does capture the basic essence.

Remember, your computer doesn’t know what words are; all it does is move 1’s and 0’s around. A crucial step in most NLP applications, therefore, is creating a numerical representation out of the words in your training corpus.

There are many ways of doing this, but today, a popular method is using word vector embeddings. Also known simply as “embeddings”, these are vectors of real numbers. They come from a neural network or a statistical algorithm like word2vec and stand in for particular words.

The technical details of this process don’t concern us in this post, what’s important is that you end up with vectors that capture a remarkable amount of semantic meaning. Words with similar meanings also have similar vectors, for example, so you can do things like find synonyms for a word by finding vectors that are mathematically close to it.

These embeddings are the basic data structures used across most of NLP. They power sentiment analysis, topic modeling, and many other applications.

For most projects, it’s enough to use pre-existing word vector embeddings without going through the trouble of generating them yourself.

Are large language models natural language processing?

Large language models (LLMs) are a subset of natural language processing. Training an LLM draws on many of the same techniques and best practices as the rest of NLP, but NLP also addresses a wide variety of other language-based tasks.

Conversational AI is a great case in point. One way of building a conversational agent is by hooking your application up to an LLM like ChatGPT, but you can also do it with a rules-based approach, through grounded learning, or with an ensemble that weaves together several methods.

Data preprocessing for NLP

If you’ve ever sent a well-meaning text that was misinterpreted, you know that language is messy. For this reason, NLP places special demands on the data engineers and data scientists who must transform text in various ways before machine learning models can be trained on it. With higher data quality comes improved model performance.

In the next few sections, we’ll offer a fairly comprehensive overview of data preprocessing for NLP. This will not cover everything you might encounter in the course of preparing data for your NLP application, but it should be more than enough to get started.

Why is text data preprocessing important?

They say that data is the new oil, and just as you can’t put oil directly in your gas tank and expect your car to run, you can’t plow a bunch of garbled, poorly-formatted language data into your algorithms and expect magic to come out the other side.

But what, precisely, counts as text preprocessing will depend on your goals. You might choose to omit or include emojis, for example, depending on whether you’re training a model to summarize academic papers or write tweets for you.

That having been said, there are certain steps you can almost always expect to take, including standardizing the case of your language data, removing punctuation, white spaces, and stop words, segmenting and tokenizing, etc.

Top text preprocessing techniques to make unstructured text data usable

NLP preprocessing techniques are the steps used to clean and prepare raw text before it is analyzed by a Natural Language Processing model. Raw text data contains noise such as punctuation, inconsistent casing, spelling variations, and irrelevant information. Preprocessing transforms that text into a structured format that machines can understand, analyze and finally generate human language themselves.

Here are the most common NLP preprocessing steps and techniques.

1. Segmentation and tokenization

An NLP model is always trained on some consistent chunk of the full data. When ChatGPT was trained, for example, they didn’t put the entire internet in a big truck and back it up to a server farm, they used self-supervised learning.

Simplifying greatly, this means that the underlying algorithm would take, say, the first few sentences of a paragraph and then try to predict the remaining sentence on the basis of the text that came before. Over time it sees enough language to guess that “to be or not to be, that is ___ ________” ends with “the question.”

But how was ChatGPT shown the first three sentences? How does that process even work?

A big part of the answer is segmentation and tokenization.

With segmentation, we’re breaking a full corpus of training text – which might contain hundreds of books and millions of words – down into units like words or sentences.

This is far from trivial. In the English language, sentences end with a period, but words like “Mr.” and “etc.” also contain them. It can be a real challenge to divide text into sentences without also breaking “Mr. Smith is cooking the steak” into “Mr.” and “Smith is cooking the steak.”

Tokenization is a related process of breaking a corpus down into tokens. Tokens are sometimes described as words, but in truth, they can be words, short clusters of a few words, sub-words, or even individual characters.

This matters a lot to the training of your NLP model. You could train a generative language model to predict the next sentence based on the preceding sentences, the next word based on the preceding words, or the next character based on the preceding characters.

Regardless, in both segmentation and tokenization, you’re decomposing a whole bunch of text down into individual units that your algorithm can work with.

2. Lowercasing

Lowercasing is the text preprocessing technique of converting all text to lowercase before it is processed by an NLP model.

Human language is not consistent about capitalization. The same word may appear as “Apple,” “APPLE,” or “apple,” depending on whether it starts a sentence, refers to a company, or is simply written in a different style.

For an NLP model, these variations can create unnecessary complexity. If capitalization is left untouched, the model may treat each version as a completely different token. That means “Apple,” “apple,” and “APPLE” could all end up as separate entries in the vocabulary.

Lowercasing reduces this variation. Instead of learning three separate representations for “Apple,” “apple,” and “APPLE,” the model only needs to learn one.

There is a tradeoff here. In some cases, capitalization carries meaning. “Apple” might refer to the company, while “apple” refers to the fruit. If everything is converted to lowercase, that distinction disappears.

Because of that, some NLP systems keep capitalization intact when the task requires it, such as named entity recognition. But for many applications, especially those focused on general language patterns, lowercasing is a useful step that reduces noise and helps the model learn more efficiently.

3. Stop word removal

Stop word removal is the preprocessing technique of removing very common words that appear frequently in language but often contribute little meaning to the text.

Words such as “the,” “is,” “and,” “of,” and “in” appear extremely often in English. These are known as stop words.

Imagine a sentence like this:

“The product is available in the store and on the website.”

If the goal is to understand the main topic of the sentence, the most important words are probably “product,” “available,” “store,” and “website.” The rest mainly help the grammar of the sentence.

Removing stop words reduces noise in the dataset. If every document contains the same handful of extremely common words, those words do not help much in distinguishing one piece of text from another.

For some tasks, such as search engines or topic modeling, removing stop words helps models focus on the words that actually describe the subject of a document.

However, stop word removal is not always appropriate. In tasks such as sentiment analysis or conversational AI, even small words can carry meaning. The difference between “I like this” and “I do not like this” depends on a single word.

Because of that, whether stop words should be removed depends heavily on the goal of the NLP system.

4. Stemming

Stemming is the preprocessing technique of reducing words to a simplified root form by removing prefixes or suffixes.

Human language often expresses the same concept through multiple word forms. Words such as “run,” “running,” “runs,” and “ran” all refer to the same basic action, but they appear differently in text.

Without preprocessing, an NLP model may treat each of these forms as completely separate tokens.

Stemming attempts to solve this by trimming words down to a shared base or root form.

For example:

running → run
played → play
studies → studi

That final example of a base form or stem word shows an important limitation. The resulting word is not always a real dictionary term. Stemming relies on simple rules that remove common endings rather than a deep understanding of language, and it may not always lead to improving data quality.

Even with that limitation, stemming can be useful because it reduces vocabulary size and helps the model connect related words during training.

For applications such as search engines or document retrieval systems, this kind of simplification is often good enough.

5. Lemmatization

Lemmatization is the preprocessing technique of reducing words to their true base or dictionary form, known as the lemma.

Like stemming, lemmatization attempts to connect different word forms that share the same meaning. However, instead of simply trimming suffixes, it relies on vocabulary resources and grammatical analysis.

For example:

running → run
better → good
studies → study

Unlike stemming, the result is usually a valid word found in a dictionary.

To determine the correct lemma, the system often needs to understand the grammatical role of the word in a sentence. For instance, the word “saw” could be the past tense of “see,” or it could refer to a cutting tool. The correct interpretation depends on context.

Because this process requires linguistic knowledge and sometimes part-of-speech tagging, lemmatization is typically more computationally expensive than stemming.

However, it also produces cleaner and more accurate representations of language, which makes it useful in applications where preserving meaning is important.

6. Removing punctuation and special characters

Removing punctuation and special characters is the preprocessing technique of eliminating symbols such as commas, quotation marks, parentheses, and other non-alphabetic characters from text.

Natural text contains many formatting elements that help human readers understand structure or tone. Punctuation marks, emojis, and special symbols all play a role in written communication.

However, in many NLP tasks, these characters do not contribute much to the core meaning of the text.

For example:

“Hello!!! How are you?”

A preprocessing pipeline might convert this to something simpler:

“Hello how are you”

Removing punctuation helps standardize the input data and reduces noise in the training corpus.

That said, punctuation can sometimes carry useful signals. In sentiment text analysis, repeated exclamation marks may indicate excitement or emphasis.

Because of this, some NLP systems remove punctuation entirely, while others keep specific characters that might contain meaningful information.

The goal is always the same. Clean the text enough that the model can focus on meaningful patterns instead of being distracted by formatting variations.

7. Text normalization

Text normalization is the preprocessing technique of converting text into a consistent and standardized form before it is analyzed by an NLP model.

Natural language contains many variations that refer to the same thing. People use abbreviations, contractions, spelling variants, and informal expressions all the time. If these differences are left untouched, the model may treat them as unrelated tokens.

Normalization reduces this variation by converting different forms into a common representation.

For example:

don’t → do not
can’t → cannot
USA → United States

Normalization may also include spelling corrections, standardizing numbers, or expanding abbreviations.

Consider a dataset containing the words “color” and “colour.” Without normalization, the model treats them as separate tokens even though they represent the same concept.

By standardizing these variations, normalization makes the training data more consistent and easier for the model to learn from. Proper text preprocessing can mean eliminating misspelled words, but also deciding on which version of a spelling is correct for your use case.

The exact normalization rules depend heavily on the application. Informal chat messages, for example, may require normalization of slang and abbreviations that would never appear in formal documents. In those cases, preparing text data is crucial as it impacts data quality.

8. Removing numbers

Removing numbers is the preprocessing technique of eliminating numeric values from text when they do not contribute meaningful information to the task.

Many text datasets contain numbers that may not help the model understand the underlying meaning of the text.

For example:

“The product costs $49 and was released in 2024.”

If the goal is topic classification or general language modeling, the numbers themselves may not add much value. In such cases, they can simply be removed.

After preprocessing, the sentence might look like this:

“The product costs and was released in”

Of course, this technique must be used carefully. In some applications, numbers carry extremely important information. Financial analysis, medical data, and scientific documents often rely heavily on numerical values.

Because of this, many NLP pipelines only remove numbers when they are clearly irrelevant to the problem being solved.

The general idea is to simplify the dataset and reduce unnecessary variation in the vocabulary.

9. Part of speech tagging

Part-of-speech tagging (also called grammatical tagging) is the preprocessing technique of assigning grammatical labels to each word in a sentence.

In English, words can function as nouns, verbs, adjectives, adverbs, and other grammatical categories. Identifying these roles helps an NLP system understand how words relate to each other.

For example:

“The dog runs quickly.”

A part-of-speech tagger might label the words like this:

The → determiner
dog → noun
runs → verb
quickly → adverb

These tags give the model information about the structure of the sentence.

Part-of-speech tagging is often used as an intermediate step in more advanced NLP tasks. Named entity recognition, dependency parsing, and information extraction all rely on grammatical structure to interpret meaning.

Although modern deep learning models sometimes learn this structure automatically, explicit POS tagging is still widely used in traditional NLP pipelines.

10. Named entity recognition preprocessing

Named entity recognition, often abbreviated as NER, is the preprocessing technique of identifying and labeling specific real-world entities within text.

Human language frequently refers to people, organizations, locations, dates, and other identifiable entities. Recognizing these elements helps NLP solutions extract useful information from text.

For example:

“Apple released a new iPhone in California in 2023.”

An NER system might identify the entities as:

Apple → organization
iPhone → product
California → location
2023 → date

This allows the model to distinguish between general words and references to real-world objects or institutions.

Named entity recognition is widely used in applications such as news analysis, text classification, knowledge extraction, and search engines.

By identifying these entities early in the preprocessing pipeline, NLP systems can build richer representations of the information contained in text.

11. Noise removal

Noise removal is the text preprocessing technique of eliminating irrelevant or distracting elements from text that do not contribute to the meaning of the content.

Real-world text data rarely comes in a clean form. It may contain HTML tags, URLs, emojis, repeated characters, formatting artifacts, or other elements that are useful for humans but confusing for NLP models.

For example, a sentence taken from a webpage might look like this:

“Check out our new product!!! 👉 https://example.com <br> Limited time offer!!!”

Before an NLP model processes the text, a preprocessing pipeline might remove the URL, HTML tags, and extra punctuation so that the remaining text is easier to analyze.

After removing HTML tags and other noise, the sentence might look like this:

“Check out our new product limited time offer”

Removing this kind of noise helps reduce unnecessary variation in the dataset and makes it easier for the model to identify meaningful patterns in the language.

The exact definition of “noise” depends on the application. In social media posts, for example, emojis may actually carry useful sentiment information and might be preserved rather than removed because they contribute as much value as individual words.

The goal of noise removal is simply to eliminate elements that distract from the linguistic structure of the text.

12. Vectorization and feature extraction

Vectorization and feature extraction are text preprocessing techniques that convert text into numerical representations that machine learning models can process.

Computers cannot directly understand words or sentences. Instead, text must be translated into numbers that represent patterns in the language.

One of the simplest approaches is the bag of words model, where a document is represented by counting how often each word appears.

For example, consider two short sentences:

“I like coffee”
“I like tea”

A bag-of-words representation might convert these into numerical vectors based on the frequency of each word in the vocabulary.

Another widely used technique is TF IDF, which stands for term frequency inverse document frequency. Instead of simply counting words, TF IDF gives higher importance to words that appear frequently in a document but not across every document in the dataset.

More advanced NLP systems use word embeddings, which represent words as vectors in a high-dimensional space. In this space, words with similar meanings appear closer together.

For instance, the vectors representing “king” and “queen” would be closer to each other than the vectors for “king” and “table.”

These numerical representations allow machine learning models to analyze patterns, relationships, and meaning within large collections of text.

Vectorization is often the final step of text preprocessing before the text is fed into an NLP algorithm or neural network.

Supercharging your NLP applications

Natural language processing is an enormously powerful constellation of techniques that allow computers to do worthwhile work on textual data. It can be used to build question-answering systems, tutors, chatbots, and much more.

But to get the most out of it, you’ll need to preprocess the data. No matter how much computing you have access to, machine learning isn’t of much use with bad data. Techniques like removing stopwords, expanding contractions, and lemmatization create a corpora of text that can then be fed to NLP algorithms. Of course, there’s always an easier way. If you’d rather skip straight to the part where cutting-edge conversational AI directly adds value to your business, you can also reach out to see what the Quiq platform can do.

AI Studio Live: Real Customer Questions, Real Solutions by Quiq Experts (Webinar Recap)

Posted on Max Fortis

At Quiq, we understand that implementing AI in your customer experience strategy can sometimes feel like navigating uncharted waters. To help our customers overcome these challenges, we hosted an AI Studio Live webinar—a hands-on session designed to address real customer questions about using AI in business. This interactive session was led by Quiq experts Mark Kowal (Senior Director of Product Marketing), John Anderson (Conversational Architect), and myself—Max Fortis (Product Manager).

During the webinar, we tackled the most common and pressing questions directly from our customer community. We grouped these questions into four key areas and offered practical advice, demos, and solutions in Quiq’s AI builder platform, AI Studio.

Want complete answers to each question with the in-depth product demos John provided during the session? You can watch the replay on demand here. Otherwise, here are the highlights of what we covered.

Questions that shape the future of AI integration

The questions we received from participants in this webinar reflect deep-seated challenges businesses face when building and deploying AI solutions. During the session, we grouped the questions into three key categories:

  1. Preparing Data – How do we ensure data readiness for AI?
  2. Building with Data – Once data is ready, how do we leverage it effectively in AI agents?
  3. Building with Large Language Models (LLMs) – What are the best practices for navigating the rapidly evolving landscape of LLMs?

These categories encapsulate key building blocks of any AI deployment strategy. Below, we’ll break down the key topics and solutions covered during each section.

1. Preparing data for AI success

When it comes to AI, one thing is certain—your model is only as good as the data it has access to. To ensure your AI agent performs at the highest level, data must be transformed, enriched, and synchronized with precision.

Common questions about data preparation

Here are some examples of critical questions we tackled within this category:

  • “How can I remove unwanted JSON or HTML tags from my dataset?”

Understanding what data to exclude can significantly impact performance. For instance, removing excessive metadata such as phone numbers or “contact us” labels from help articles improves how your agent retrieves relevant answers.

  • “What are best practices for improving search results?”

Creating augmented datasets, assigning topic tags, and adding metadata like summaries or descriptions can amplify the effectiveness of your knowledge pool.

  • “How can I transform my data while keeping it synchronized?”

When data transformations create multiple sources of truth, it introduces inefficiencies. Applying rules-based synchronization on Quiq’s AI Studio ensures no data is decoupled during updates.

Highlighted solution demonstrations

John Anderson showcased the flexibility of Quiq’s AI Studio for addressing these issues.

  • Leveraging transformations, he demonstrated stripping out unnecessary elements like embedded HTML or links while enhancing datasets with topic-based metadata.
  • With automatic synchronization, data can be updated and transformed on an ongoing basis, resulting in consistent, high-quality information that agents could rely on.

Pro Tip: Sync datasets regularly and build robust rules to preserve accuracy over time.

2. Building with data in AI Studio

Once your data is prepared, the next challenge is to figure out how to use it effectively. Different user needs, markets, and data sources require careful planning to guarantee relevant and accurate results from agents.

Common challenges for data utilization

Webinar attendees were particularly curious about these scenarios:

  • “We have users from multiple markets. How do we ensure the agent uses market-relevant knowledge sources?”

The solution lies in conditionally segmenting datasets. For example, a single agent can serve Australian and US customers using conditional logic, which ensures that region-specific knowledge is applied based on the user’s locale.

  • “Can two datasets be used together, like a core product catalog supplemented by promotional content?”

Yes—Quiq’s AI Studio quickly combines multiple datasets for dynamic applications. Supplemental knowledge bases, such as blog content or seasonal catalogs, can be accessed opportunistically depending on the interaction context.

Demonstrated use cases

John highlighted how search behaviors can incorporate multiple datasets. During one demo, he adjusted search logic to demonstrate the differences between pooled vs. isolated queries.

  • Scenario 1: Combining a product catalog with a promotional dataset allowed the AI to deliver direct responses on availability with added context about special offers.
  • Scenario 2: Isolating each dataset showcased accurate queries tailored to specific needs (e.g., products vs. how-to articles).

Pro Tip: Use dynamic search behaviors for scenario-specific queries without cluttering your AI workflows.

3. Building with large language models (LLMs)

The excitement surrounding LLMs like GPT-4o, Gemini—and most recently as of the time of writing this article, DeepSeek—comes with an undeniable amount of complexity and questions. How do you make the right choices for modeling, scaling, and updates in such a fast-moving environment?

Key questions tackled

These were some of the most common LLM dilemmas posed by attendees:

  • “How do I decide what model is best for a specific use case?”

The appropriate model depends on factors like performance needs, accuracy, and cost-efficiency. Balancing these trade-offs is essential. That said, it’s a process of trial and error to really cue in on the best model for the job.

  • “What is atomic prompting, and when should I use it?”

Atomic prompting involves breaking prompts into individual parts to resolve multiple queries efficiently. This can reduce computational strain,improve precision, and increase traceability.

  • “How can I test updates without disrupting live agents?”

Testing updates in isolation with tools like Quiq’s Debug Workbench allows businesses to debug prompts, assess new models, and replicate conditions—all without publishing in-progress changes.

Demonstrated solutions

John dove into prompt engineering to showcase techniques such as atomic prompting (decomposing tasks into manageable chunks) and model selection through Quiq platforms. He underscored testing’s critical role by showcasing before-and-after scenarios of prompt changes, confidently ensuring accuracy and compliance.

Importantly, we built AI Studio to be model agnostic to accommodate innovative advancements in this space (see this LinkedIn post from our CEO Mike Myer about this in the context of DeepSeek’s release).

Pro Tip: Create tests using both real and simulated conversations to ensure you’re capturing the full range of scenarios necessary..

Taking AI beyond the traditional use case

While most of the webinar focused on the above categories, we also fielded additional questions, such as:

  • “How do we deploy AI agents across platforms with varying capabilities?”

The advice? Build once, ensuring functionality across all platforms (e.g., SMS, voice, web chat). Tailoring formats for channel-specific features (e.g., carousel cards for chat) ensures consistency in user experience.

  • “What is Retrieval Augmented Generation (RAG) with customer data?”

John clarified how RAG applies beyond knowledge bases to dynamic APIs—e.g., personalized product recommendations.

Next steps for your AI journey

Harnessing the full power of AI starts with asking the right questions—and our webinar made it clear that the Quiq community is full of thoughtful, innovative inquiry. With robust tools like AI Studio and guidance from our expert team, businesses can prepare their data, leverage LLMs effectively, and scale AI to meet growing demands.

Looking to bring these strategies to life? Test drive Quiq’s AI Studio for free, and see how you can elevate your customer experience. Our platform allows you to build smarter, more contextual AI agents—all while simplifying the complexities of AI for your team.

Does Quiq Train Models on Your Data? No (And Here’s Why.)

Posted on Lauren Winder

Customer experience directors tend to have a lot of questions about AI, especially as it becomes more and more important to the way modern contact centers function.

These can range from “Will generative AI’s well-known tendency to hallucinate eventually hurt my brand?” to “How are large language models trained in the first place?” along with many others.

Speaking of training, one question that’s often top of mind for prospective users of Quiq’s conversational AI platform is whether we train the LLMs we use with your data. This is a perfectly reasonable question, especially given famous examples of LLMs exposing proprietary data, such as happened at Samsung. Needless to say, if you have sensitive customer information, you absolutely don’t want it getting leaked – and if you’re not clear on what is going on with an LLM, you might not have the confidence you need to use one in your contact center.

The purpose of this piece is to assure you that no, we do not train LLMs with your data. To hammer that point home, we’ll briefly cover how models are trained, then discuss the two ways that Quiq optimizes model behavior: prompt engineering and retrieval augmented generation.

How are Large Language Models Trained?

Part of the confusion stems from the fact that the term ‘training’ means different things to different people. Let’s start by clarifying what this term means, but don’t worry–we’ll go very light on technical details!

First, generative language models work with tokens, which are units of language such as a part of a word (“kitch”), a whole word (“kitchen”), or sometimes small clusters of words (“kitchen sink”). When a model is trained, it’s learning to predict the token that’s most likely to follow a string of prior tokens.

Once a model has seen a great deal of text, for example, it learns that “Mary had a little ____” probably ends with the token “lamb” rather than the token “lightbulb.”

Crucially, this process involves changing the model’s internal weights, i.e. its internal structure. Quiq has various ways of optimizing a model to perform in settings such as contact centers (discussed in the next section), but we do not change any model’s weights.

How Does Quiq Optimize Model Behavior?

There are a few basic ways to influence a model’s output. The two used by Quiq are prompt engineering and retrieval augmented generation (RAG), neither of which does anything whatsoever to modify a model’s weights or its structure.

In the next two sections, we’ll briefly cover each so that you have a bit more context on what’s going on under the hood.

Prompt Engineering

Prompt engineering involves changing how you format the query you feed the model to elicit a slightly different response. Rather than saying, “Write me some social media copy,” for example, you might also include an example outline you want the model to follow.

Quiq uses an approach to prompt engineering called “atomic prompting,” wherein the process of generating an answer to a question is broken down into multiple subtasks. This ensures you’re instructing a Large Language Model in a smaller context with specific, relevant task information, which can help the model perform better.

This is not the same thing as training. If you were to train or fine-tune a model on company-specific data, then the model’s internal structure would change to represent that data, and it might inadvertently reveal it in a future reply. However, including the data in a prompt doesn’t carry that risk because prompt engineering doesn’t change a model’s weights.

Retrieval Augmented Generation (RAG)

RAG refers to giving a language model an information source – such as a database or the Internet – that it can use to improve its output. It has emerged as the most popular technique to control the information the model needs to know when generating answers.

As before, that is not the same thing as training because it does not change the model’s weights.

RAG doesn’t modify the underlying model, but if you connect it to sensitive information and then ask it a question, it may very well reveal something sensitive. RAG is very powerful, but you need to use it with caution. Your AI development platform should provide ways to securely connect to APIs that can help authenticate and retrieve account information, thus allowing you to provide customers with personalized responses.

This is why you still need to think about security when using RAG. Whatever tools or information sources you give your model must meet the strictest security standards and be certified, as appropriate.

Quiq is one such platform, built from the ground-up with data security (encryption in transit) and compliance (SOC 2 certified) in mind. We never store or use data without permission, and we’ve crafted our tools so it’s as easy as possible to utilize RAG on just the information stores you want to plug a model into. Being a security-first company, this extends to our utilization of Large Language Models and agreements with AI providers like Microsoft Open AI.

Wrapping Up on How Quiq Trains LLMs

Hopefully, you now have a much clearer picture of what Quiq does to ensure the models we use are as performant and useful as possible. With them, you can make your customers happier, improve your agents’ performance, and reduce turnover at your contact center.

Is Your CX Data Good Enough for GenAI? Exposing Common AI Misconceptions (Part One)

Posted on Lauren Winder

If you’re feeling unprepared for the impact of generative artificial intelligence (GenAI), you’re not alone. In fact, nearly 85% of CX leaders feel the same way. But the truth is that the transformative nature of this technology simply can’t be ignored — and neither can your boss, who asked you to look into it.

We’ve all heard horror stories of racist chatbots and massive data leaks ruining brands’ reputations. But we’ve also seen statistics around the massive time and cost savings brands can achieve by offloading customers’ frequently asked questions to AI Assistants. So which is it?

This is the first post in a three-part series clarifying the biggest misconceptions holding CX leaders like you back from integrating GenAI into their CX strategies. Our goal? To assuage your fears and help you start getting real about adding an AI Assistant to your contact center — all in a fun “two truths and a lie” format. Prepare to have your most common AI misconceptions debunked!

Misconception #1: “My data isn’t good enough for GenAI.”

Answering customer inquiries usually requires two types of data:

  1. Knowledge (e.g. an order return policy) and
  2. Information from internal systems (e.g. the specific details of an order).

It’s easy to get caught up in overthinking the impact of data quality on AI performance and wondering whether or not your knowledge is even good enough to make an AI Assistant useful for your customers.

Updating hundreds of help desk articles is no small task, let alone building an entire knowledge base from scratch. Many CX leaders are worried about the amount of work it will require to clean up their data and whether their team has enough resources to support a GenAI initiative. In order for GenAI to be as effective as a human agent, it needs the same level of access to internal systems as human agents.

Truth #1: You have to have some amount of data.

Data is necessary to make AI work — there’s no way around it. You must provide some data for the model to access in order to generate answers. This is one of the most basic AI performance factors.

But we have good news: You need a lot less data than you think.

One of the most common myths about AI and data in CX is that it’s necessary to answer every possible customer question. Instead, focus on ensuring you have the knowledge necessary to answer your most frequently asked questions. This small step forward will have a major impact for your team without requiring a ton of time and resources to get started

Truth #2: Quality matters more than quantity.

Given the importance of relevant data in AI, a few succinct paragraphs of accurate information is better than volumes of outdated or conflicting documentation. But even then, don’t sweat the small stuff.

For example, did a product name change fail to make its way through half of your help desk articles? Are there unnecessary hyperlinks scattered throughout? Was it written for live agents versus customers?

No problem — the right Conversational CX Platform can easily address these AI data dependency concerns without requiring additional support from your team.

The Lie: Your data has to be perfectly unified and specifically formatted to train an AI Assistant.

Don’t worry if your data isn’t well-organized or perfectly formatted. The reality is that most companies have services and support materials scattered across websites, knowledge bases, PDFs, .csvs, and dozens of other places — and that’s okay!

Today, the tools and technology exist to make aggregating this fragmented data a breeze. They’re then able to cleanse and format it in a way that makes sense for a large language model (LLM) to use.

For example if you have an agent training manual in Google Docs and a product manual in PDF, this information can be disassembled, reformatted, and rewritten by an AI-powered transformation that makes it subsequently usable.

What’s more, the data used by your AI Assistant should be consistent with the data you use to train your human agents. This means that not only is it not required to build a special repository of information for your AI Assistant to learn from, but it’s not recommended. The very best AI platforms take on the work of maintaining this continuity by automatically processing and formatting new information for your Assistant as it’s published, as well as removing any information that’s been deleted.

Put Those Data Doubts to Bed

Now you know that your data is definitely good enough for GenAI to work for your business. Yes, quality matters more than quantity, but it doesn’t have to be perfect.

The technology exists to unify and format your data so that it’s usable by an LLM. And providing knowledge around even a handful of frequently asked questions can give your team a major lift right out the gate.

Exploring Cutting-Edge Research in Large Language Models and Generative AI

Posted on The Quiq Team

By the calendar, ChatGPT was released just a few months ago. But subjectively, it feels as though 600 years have passed since we all read “as a large language model…” for the first time.

The pace of new innovations is staggering, but we at Quiq like to help our audience in the customer experience and contact center industries stay ahead of the curve (even when that requires faster-than-light travel).

Today, we will look at what’s new in generative AI, and what will be coming down the line in the months ahead.

Where will Generative AI be applied?

First, let’s start with industries that will be strongly impacted by generative AI. As we noted in an earlier article, training a large language model (LLM) like ChatGPT mostly boils down to showing it tons of examples of text until it learns a statistical representation of human language well enough to generate sonnets, email copy, and many other linguistic artifacts.

There’s no reason the same basic process (have it learn it from many examples and then create its own) couldn’t be used elsewhere, and in the next few sections, we’re going to look at how generative AI is being used in a variety of different industries to brainstorm structures, new materials, and a billion other things.

Generative AI in Building and Product Design

If you’ve had a chance to play around with DALL-E, Midjourney, or Stable Diffusion, you know that the results can be simply remarkable.

It’s not a far leap to imagine that it might be useful for quickly generating ideas for buildings and products.

The emerging field of AI-generated product design is doing exactly this. With generative image models, designers can use text prompts to rough out ideas and see them brought to life. This allows for faster iteration and quicker turnaround, especially given that creating a proof of concept is one of the slower, more tedious parts of product design.

Image source: Board of Innovation

 

For the same reason, these tools are finding use among architects who are able to quickly transpose between different periods and styles, see how better lighting impacts a room’s aesthetic, and plan around themes like building with eco-friendly materials.

There are two things worth pointing out about this process. First, there’s often a learning curve because it can take a while to figure out prompt engineering well enough to get a compelling image. Second, there’s a hearty dose of serendipity. Often the resulting image will not be quite what the designer had in mind, but it’ll be different in new and productive ways, pushing the artist along fresh trajectories that might never have occurred to them otherwise.

Generative AI in Discovering New Materials

To quote one of America’s most renowned philosophers (Madonna), we’re living in a material world. Humans have been augmenting their surroundings since we first started chipping flint axes back in the Stone Age; today, the field of materials science continues the long tradition of finding new stuff that expands our capabilities and makes our lives better.

This can take the form of something (relatively) simple like researching a better steel alloy, or something incredibly novel like designing a programmable nanomaterial.

There’s just one issue: it’s really, really difficult to do this. It takes a great deal of time, energy, and effort to even identify plausible new materials, to say nothing of the extensive testing and experimenting that must then follow.

Materials scientists have been using machine learning (ML) in their process for some time, but the recent boom in generative AI is driving renewed interest. There are now a number of projects aimed at e.g. using variational autoencoders, recurrent neural networks, and generative adversarial networks to learn a mapping between information about a material’s underlying structure and its final properties, then using this information to create plausible new materials.

It would be hard to overstate how important the use of generative AI in materials science could be. If you imagine the space of possible molecules as being like its own universe, we’ve explored basically none of it. What new fabrics, medicines, fuels, fertilizers, conductors, insulators, and chemicals are waiting out there? With generative AI, we’ve got a better chance than ever of finding out.

Generative AI in Gaming

Gaming is often an obvious place to use new technology, and that’s true for generative AI as well. The principles of generative design we discussed two sections ago could be used in this context to flesh out worlds, costumes, weapons, and more, but it can also be used to make character interactions more dynamic.

From Navi trying to get our attention in Ocarina of Time to GlaDOS’s continual reminders that “the cake is a lie” in Portal, non-playable characters (NPCs) have always added texture and context to our favorite games.

Powered by LLMs, these characters may soon be able to have open-ended conversations with players, adding more immersive realism to the gameplay. Rather than pulling from a limited set of responses, they’d be able to query LLMs to provide advice, answer questions, and shoot the breeze.

What’s Next in Generative AI?

As impressive as technologies like ChatGPT are, people are already looking for ways to extend their capabilities. Now that we’ve covered some of the major applications of generative AI, let’s look at some of the exciting applications people are building on top of it.

What is AutoGPT and how Does it Work?

ChatGPT can already do things like generate API calls and build simple apps, but as long as a human has to actually copy and paste the code somewhere useful, its capacities are limited.

But what if that weren’t an issue? What if it were possible to spin ChatGPT up into something more like an agent, capable of semi-autonomously interacting with software or online services to complete strings of tasks?

This is exactly what Auto-GPT is intended to accomplish. Auto-GPT is an application built by developer Toran Bruce Richards, and it is comprised of two parts: an LLM (either GPT-3.5 or GPT-4), and a separate “bot” that works with the LLM.

By repeatedly querying the LLM, the bot is able to take a relatively high-level task like “help me set up an online business with a blog and a website” or “find me all the latest research on quantum computing”, decompose it into discrete, achievable steps, then iteratively execute them until the overall objective is achieved.

At present, Auto-GPT remains fairly primitive. Just as ChatGPT can get stuck in repetitive and unhelpful loops, so too can Auto-GPT. Still, it’s a remarkable advance, and it’s spawned a series of other projects attempting to do the same thing in a more consistent way.

The creators of AssistGPT bill it as a “General Multi-modal Assistant that can Plan, Execute, Inspect, and Learn”. It handles multi-modal tasks (i.e. tasks that rely on vision or sound and not just text) better than Auto-GPT, and by integrating with a suite of tools it is able to achieve objectives that involve many intermediate steps and sub-tasks.

SuperAGI, in turn, is just as ambitious. It’s a platform that offers a way to quickly create, deploy, manage, and update autonomous agents. You can integrate them into applications like Slack or vector databases, and it’ll even ping you if an agent gets stuck somewhere and starts looping unproductively.

Finally, there’s LangChain, which is a similar idea. LangChain is a framework that is geared towards making it easier to build on top of LLMs. It features a set of primitives that can be stitched into more robust functionality (not unlike “for” and “while” loops in programming languages), and it’s even possible to build your own version of AutoGPT using LangChain.

What is Chain-of-Thought Prompting and How Does it Work?

In the misty, forgotten past (i.e. 5 months ago), LLMs were famously bad at simple arithmetic. They might be able to construct elegant mathematical proofs, but if you asked them what 7 + 4 is, there was a decent chance they’d get it wrong.

Chain-of-thought (COT) prompting refers to a few-shot learning method of eliciting output from an LLM that compels it to reason in a step-by-step way, and it was developed in part to help with this issue. This image from the original Wei et al. (2022) paper illustrates how:

Input and output examples for Standard and Chain-of-thought Prompting.
Source: ARXIV.org

As you can see, the model’s performance is improved because it’s being shown a chain of different thoughts, hence chain-of-thought.

This technique isn’t just useful for arithmetic, it can be utilized to get better output from a model in a variety of different tasks, including commonsense and symbolic reasoning.

In a way, humans can be prompt engineered in the same fashion. You can often get better answers out of yourself or others through a deliberate attempt to reason slowly, step-by-step, so it’s not a terrible shock that a large model trained on human text would benefit from the same procedure.

The Ecosystem Around Generative AI

Though cutting-edge models are usually the stars of the show, the truth is advanced technologies aren’t worth much if you have to be deeply into the weeds to use them. Machine learning, for example, would surely be much less prevalent if tools like sklearn, Tensorflow, and Keras didn’t exist.

Though we’re still in the early days of LLMs, AutoGPT, and everything else we’ve discussed, we suspect the same basic dynamic will play out. Since it’s now clear that these models aren’t toys, people will begin building infrastructure around them that streamlines the process of training them for specific use cases, integrating them into existing applications, etc.

Let’s discuss a few efforts in this direction that are already underway.

Training and Education

Among the simplest parts of the emerging generative AI value chain is exactly what we’re doing now: talking about it in an informed way. Non-specialists will often lack the time, context, and patience required to sort the real breakthroughs from the hype, so putting together blog posts, tutorials, and reports that make this easier is a real service.

Making Foundation Models Available

“Foundation models” is a new term that refers to the actual algorithms that underlie LLMs. ChatGPT, for example, is not a foundation model. GPT-4 is the foundation model, and ChatGPT is a specialized application of it (more on this shortly).

Companies like Anthropic, Google, and OpenAI can train these gargantuan models and then make them available through an API. From there, developers are able to access their preferred foundation model over an API.

This means that we can move quickly to utilize their remarkable functionality, which wouldn’t be the case if every company had to train their own from scratch.

Building Applications Around Specific Use Cases

One of the most striking properties of ChatGPT is how amazingly general they are. They are capable of “…generating functioning web apps with just a few prompts, writing Spanish-language children’s stories about the blockchain in the style of Dr. Suess, [and] opining on the virtues and vices of major political figures”, to name but a few examples.

General-purpose models often have to be fine-tuned to perform better on a specific task, especially if they’re doing something tricky like summarizing medical documents with lots of obscure vocabulary. Alas, there is a tradeoff here, because in most cases these fine-tuned models will afterward not be as useful for generic tasks.

The issue, however, is that you need a fair bit of technical skill to set up a fine-tuning pipeline, and you need a fair bit of elbow grease to assemble the few hundred examples a model needs in order to be fine-tuned. Though this is much simpler than training a model in the first place it is still far from trivial, and we expect that there will soon be services aimed at making it much more straightforward.

LLMOps and Model Hubs

We’d venture to guess you’ve heard of machine learning, but you might not be familiar with the term “MLOps”. “Ops” means “operations”, and it refers to all the things you have to do to use a machine learning model besides just training it. Once a model has been trained it has to be monitored, for example, because sometimes its performance will begin to inexplicably degrade.

The same will be true of LLMs. You’ll need to make sure that the chatbot you’ve deployed hasn’t begun abusing customers and damaging your brand, or that the deep learning tool you’re using to explore new materials hasn’t begun to spit out gibberish.

Another phenomenon from machine learning we think will be echoed in LLMs is the existence of “model hubs”, which are places where you can find pre-trained or fine-tuned models to use. There certainly are carefully guarded secrets among technologists, but on the whole, we’re a community that believes in sharing. The same ethos that powers the open-source movement will be found among the teams building LLMs, and indeed there are already open-sourced alternatives to ChatGPT that are highly performant.

Looking Ahead

As they’re so fond of saying on Twitter, “ChatGPT is just the tip of the iceberg.” It’s already begun transforming contact centers, boosting productivity among lower-skilled workers while reducing employee turnover, but research into even better tools is screaming ahead.

Frankly, it can be enough to make your head spin. If LLMs and generative AI are things you want to incorporate into your own product offering, you can skip the heady technical stuff and skip straight to letting Quiq do it for you. The Quiq conversational AI platform is a best-in-class product suite that makes it much easier to utilize these technologies. Schedule a demo to see how we can help you get in on the AI revolution.

What Is Transfer Learning? – The Role of Transfer Learning in Building Powerful Generative AI Models

Posted on J.R. Rettenmeyer

Machine learning is hard work. Sure, it only takes a few minutes to knock out a simple tutorial where you’re training an image classifier on the famous iris dataset, but training a big model to do something truly valuable – like interacting with customers over a chat interface – is a much greater challenge.

Transfer learning offers one possible solution to this problem. By making it possible to train a model in one domain and reuse it in another, transfer learning can reduce demands on your engineering team by a substantial amount.

Today, we’re going to get into transfer learning, defining what it is, how it works, where it can be applied, and the advantages it offers.

Let’s get going!

What is Transfer Learning in AI?

In the abstract, transfer learning refers to any situation in which knowledge from one task, problem, or domain is transferred to another. If you learn how to play the guitar well and then successfully use those same skills to pick up a mandolin, that’s an example of transfer learning.

Speaking specifically about machine learning and artificial intelligence, the idea is very similar. Transfer learning is when you pre-train a model on one task or dataset and then figure out a way to reuse it for another (we’ll talk about methods later).

If you train an image model, for example, it will tend to learn certain low-level features (like curves, edges, and lines) that show up in pretty much all images. This means you could fine-tune the pre-trained model to do something more specialized, like recognizing faces.

Why Transfer Learning is Important in Deep Learning Models

Building a deep neural network requires serious expertise, especially if you’re doing something truly novel or untried.

Transfer learning, while far from trivial, is simply not as taxing. GPT-4 is the kind of project that could only have been tackled by some of Earth’s best engineers, but setting up a fine-tuning pipeline to get it to do good sentiment analysis is a much simpler job.

By lowering the barrier to entry, transfer learning brings advanced AI into reach for a much broader swath of people. For this reason alone, it’s an important development.

Transfer Learning vs. Fine-Tuning

And speaking of fine-tuning, it’s natural to wonder how it’s different from transfer learning.

The simple answer is that fine-tuning is a kind of transfer learning. Transfer learning is a broader concept, and there are other ways to approach it besides fine-tuning.

What are the 5 Types of Transfer Learning?

Broadly speaking, there are five major types of transfer learning, which we’ll discuss in the following sections.

Domain Adaptation

Under the hood, most modern machine learning is really just an application of statistics to particular datasets.

The distribution of the data a particular model sees, therefore, matters a lot. Domain adaptation refers to a family of transfer learning techniques in which a model is (hopefully) trained such that it’s able to handle a shift in distributions from one domain to another (see section 5 of this paper for more technical details).

Domain Confusion

Earlier, we referenced the fact that the layers of a neural network can learn representations of particular features – one layer might be good at detecting curves in images, for example.

It’s possible to structure our training such that a model learns more domain invariant features, i.e. features that are likely to show up across multiple domains of interest. This is known as domain confusion because, in effect, we’re making the domains as similar as possible.

Multitask Learning

Multitask learning is arguably not even a type of transfer learning, but it came up repeatedly in our research, so we’re adding a section about it here.

Multitask learning is what it sounds like; rather than simply training a model on a single task (i.e. detecting humans in images), you attempt to train it to do several things at once.

The debate about whether multitask learning is really transfer learning stems from the fact that transfer learning generally revolves around adapting a pre-trained model to a new task, rather than having it learn to do more than one thing at a time.

One-Shot Learning

One thing that distinguishes machine learning from human learning is that the former requires much more data. A human child will probably only need to see two or three apples before they learn to tell apples from oranges, but an ML model might need to see thousands of examples of each.

But what if that weren’t necessary? The field of one-shot learning addresses itself to the task of learning e.g. object categories from either one example or a small number of them. This idea was pioneered in “One-Shot Learning of Object Categories”, a watershed paper co-authored by Fei-Fei Li and her collaborators. Their Bayesian one-shot learner was able to “…to incorporate prior knowledge of the object world into the learning scheme”, and it outperformed a variety of other models in object recognition tasks.

Zero-Shot Learning

Of course, there might be other tasks (like translating a rare or endangered language), for which it is effectively impossible to have any labeled data for a model to train on. In such a case, you’d want to use zero-shot learning, which is a type of transfer learning.

With zero-shot learning, the basic idea is to learn features in one data set (like images of cats) that allow successful performance on a different data set (like images of dogs). Humans have little problem with this, because we’re able to rapidly learn similarities between types of entities. We can see that dogs and cats both have tails, both have fur, etc. Machines can perform the same feat if the data is structured correctly.

How Does Transfer Learning Work?

There are a few different ways you can go about utilizing transfer learning processes in your own projects.

Perhaps the most basic is to use a good pre-trained model off the shelf as a feature extractor. This would mean keeping the pre-trained model in place, but then replacing its final layer with a layer custom-built for your purposes. You could take the famous AlexNet image classifier, remove its last classification layer, and replace it with your own, for example.

Or, you could fine-tune the pre-trained model instead. This is a more involved engineering task and requires that the pre-trained model be modified internally to be better suited to a narrower application. This will often mean that you have to freeze certain layers in your model so that the weights don’t change, while simultaneously allowing the weights in other layers to change.

What are the Applications of Transfer Learning?

As machine learning and deep learning have grown in importance, so too has transfer learning become more crucial. It now shows up in a variety of different industries. The following are some high-level indications of where you might see transfer learning being applied.

Speech recognition across languages: Teaching machines to recognize and process spoken language is an important area of AI research and will be of special interest to those who operate contact centers. Transfer learning can be used to take a model trained in a language like French and repurpose it for Spanish.

Training general-purpose game engines: If you’ve spent any time playing games like chess or go, you know that they’re fairly different. But, at a high enough level of abstraction, they still share many features in common. That’s why transfer learning can be used to train up a model on one game and, under certain conditions, use it in another.

Object recognition and segmentation: Our Jetsons-like future will take a lot longer to get here if our robots can’t learn to distinguish between basic objects. This is why object recognition and object segmentation are both such important areas of research. Transfer learning is one way of speeding up this process. If models can learn to recognize dogs and then quickly be re-purposed for recognizing muffins, then we’ll soon be able to outsource both pet care and cooking breakfast.

transfer_learning_chihuahua
In fairness to the AI, it’s not like we can really tell them apart!

Applying Natural Language Processing: For a long time, computer vision was the major use case of high-end, high-performance AI. But with the release of ChatGPT and other large language models, NLP has taken center stage. Because much of the modern NLP pipeline involves word vector embeddings, it’s often possible to use a baseline, pre-trained NLP model in applications like topic modeling, document classification, or spicing up your chatbot so it doesn’t sound so much like a machine.

What are the Benefits of Transfer Learning?

Transfer learning has become so popular precisely because it offers so many advantages.

For one thing, it can dramatically reduce the amount of time it takes to train a new model. Because you’re using a pre-trained model as the foundation for a new, task-specific model, far fewer engineering hours have to be spent to get good results.

There are also a variety of situations in which transfer learning can actually improve performance. If you’re using a good pre-trained model that was trained on a general enough dataset, many of the features it learned will carry over to the new task.

This is especially true if you’re working in a domain where there is relatively little data to work with. It might simply not be possible to train a big, cutting-edge model on a limited dataset, but it will often be possible to use a pre-trained model that is fine-tuned on that limited dataset.

What’s more, transfer learning can work to prevent the ever-present problem of overfitting. Overfitting has several definitions depending on what resource you consult, but a common way of thinking about it is when the model is complex enough relative to the data that it begins learning noise instead of just signal.

That means that it may do spectacularly well in training only to generalize poorly when it’s shown fresh data. Transfer learning doesn’t completely rule out this possibility, but it makes it less likely to happen.

Transfer learning also has the advantage of being quite flexible. You can use transfer learning for everything from computer vision to natural language processing, and many domains besides.

Relatedly, transfer learning makes it possible for your model to expand into new frontiers. When done correctly, a pre-trained model can be deployed to solve an entirely new problem, even when the underlying data is very different from what it was shown before.

When To Use Transfer Learning

The list of benefits we just enumerated also offers a clue as to when it makes sense to use transfer learning.

Basically, you should consider using transfer learning whenever you have limited data, limited computing resources, or limited engineering brain cycles you can throw at a problem. This will often wind up being the case, so whenever you’re setting your sights on a new goal, it can make sense to spend some time seeing if you can’t get there more quickly by simply using transfer learning instead of training a bespoke model from scratch.

Check out the second video in Quiq’s LLM Intuitions series—created by our Head of AI, Kyle McIntyre—to learn about one of the oldest forms of transfer learning: Word embeddings.

Transfer Learning and You

In the contact center space, we understand how difficult it can be to effectively apply new technologies to solve our problems. It’s one thing to put together a model for a school project, and quite another to have it tactfully respond to customers who might be frustrated or confused.

Transfer learning is one way that you can get more bang for your engineering buck. By training a model on one task or dataset and using it on another, you can reduce your technical budget while still getting great results.

You could also just rely on us to transfer our decades of learning on your behalf (see what we did there). We’ve built an industry-leading conversational AI chat platform that is changing the game in contact centers. Reach out today to see how Quiq can help you leverage the latest advances in AI, without the hassle.

How Generative AI is Supercharging Contact Center Agents

Posted on The Quiq Team

If you’re reading this, you’ve probably had a chance to play around with ChatGPT or one of the other large language models (LLMs) that have been making waves and headlines in recent months.

Concerns around automation go back a long way, but there’s long been extra worry about the possibility that machines will make human labor redundant. If you’ve used generative AI to draft blog posts or answer technical questions, it’s natural to wonder if perhaps algorithms will soon be poised to replace humans in places like contact centers.

Given how new these LLMs are there has been little scholarship on how they’ve changed the way contact centers function. But “Generative AI at Work” by Erik Brynjolfsson, Danielle Li, and Lindsey R. Raymond took aim at exactly this question.

The results are remarkable. They found that access to tools like ChatGPT not only led to a marked increase in productivity among the lowest-skilled workers, it also had positive impacts on other organizational metrics, like reducing turnover.

Today, we’re going to break this economic study down, examining its methods, its conclusions, and what they mean for the contact centers of the future.

Let’s dig in!

A Look At “Generative AI At Work”

The paper studies data from the use of a conversational AI assistant by a little over 5,000 agents working in customer support.

It contains several major sections, beginning with a technical primer on what generative AI is and how it works before moving on to a discussion of the study’s methods and results.

What is Generative AI?

Covering the technical fundamentals of generative AI will inform our efforts to understand the ways in which this AI technology affected work in the study, as well as how it is likely to do so in future deployments.

A good way to do this is to first grasp how traditional, rules-based programming works, then contrast this with generative AI.

When you write a computer program, you’re essentially creating a logical structure that furnishes instructions the computer can execute.

To take a simple case, you might try to reverse a string such as “Hello world”. One way to do this explicitly is to write code in a language like Python which essentially says:

“Create a new, empty list, then start at the end of the string we gave you and work forward, successively adding each character you encounter to that list before joining all the characters into a reversed string”:

Python code demonstrating a reverse string.

Despite the fact that these are fairly basic instructions, it’s possible to weave them into software that can steer satellites and run banking infrastructure.

But this approach is not suitable for every kind of problem. If you’re trying to programmatically identify pictures of roses, for example, it’s effectively impossible to do this with rules like the ones we used to reverse the string.

Machine learning, however, doesn’t even try to explicitly define any such rules. It works instead by feeding a model many pictures of roses, and “training” it to learn a function that lets it identify new pictures of roses it has never seen before.

Generative AI is a kind of machine learning in which gargantuan models are trained on mind-boggling amounts of text data until they’re able to produce their own, new text. Generative AI is a distinct sub-branch of ML because its purpose is generation, while other kinds of models might be aimed at tasks like classification and prediction.

Is Generative AI The Same Thing As Large Language Models?

At this point, you might be wondering how whether generative AI is the same thing as LLMs. With all the hype and movement in the space, it’s easy to lose track of the terminology.

LLMs are a subset of the broader category of generative AI. All LLMs are generative AI, but there are generative algorithms that work with images, music, chess moves, and other things besides natural language.

How Did The Researchers Study the Effects of Generative AI on Work?

Now we understand that ML learns to recognize patterns, how this is different from classical computer programming, and how generative AI fits into the whole picture.

We can now get to the meat of the study, beginning with how Brynjolfsson, Li, and Raymond actually studied the use of generative AI by workers at a contact center.

The firm from which they drew their data is a Fortune 500 company that creates enterprise software. Its support agents are located mainly in the Phillippines (with a smaller number in the U.S.) to resolve customer issues via a chat interface.

Most of the agent’s job boils down to answering questions from the owners of small businesses that use the firm’s software. Their productivity is assessed via how long it takes them to resolve a given issue (“average handle time”), the fraction of total issues a given agent is able to resolve to the customer’s satisfaction (“resolution rate”), and the net number of customers who would recommend the agent (“net promoter score.”)

Line graphs showing handle time, resolution rate and customer satisfaction using AI.

The AI used by the firm is a version of GPT which has received additional training on conversations between customers and agents. It is mostly used for two things: generating appropriate responses to customers in real-time and surfacing links to the firm’s technical documentation to help answer specific questions about the software.

Bear in mind that this generative AI system is meant to help the agents in performing their jobs. It is not intended to – and is not being trained to – completely replace them. They maintain autonomy in deciding whether and how much of the AI’s suggestions to take.

How Did Generative AI Change Work?

Next, we’ll look at what the study actually uncovered.

There were four main findings, touching on how total worker productivity was impacted, whether productivity gains accrued mainly to low-skill or high-skill workers, how access to an AI tool changed learning on the job, and how the organization changed as a result.

1. Access to Generative AI Boosted Worker Productivity

First, being able to use the firm’s AI tool increased worker productivity by almost 14%. This came from three sources: a reduction in how long it took any given agent to resolve a particular issue, an expansion in the total number of resolutions an agent was able to work on in an hour, and a small jump in the fraction of chats that were completed successfully.

The firm's AI tool increased worker productivity by almost 14%

This boost happened very quickly, showing up in the first month after deployment, growing a little in the second month, and then remaining at roughly that level for the duration of the study.

2. Access to Generative AI Was Most Helpful for Lower-Skilled Agents

Intriguingly, the greatest productivity gains were seen among agents that were relatively low-skill, such as those that were new to the job, with longer-serving, higher-skilled agents seeing virtually none.

The agents in the very bottom quintile for skill level, in fact, were able to resolve 35% more calls per hour—a substantial jump.

The agents in the very bottom quintile for skill level were able to resolve more calls per hour 35%.

With the benefit of hindsight it’s tempting to see these results as obvious, but they’re not. Earlier studies have usually found that the benefits of new computing technologies accrued to the ablest workers, or led firms to raise the bar on skill requirements for different positions.

If it’s true that generative AI is primarily going to benefit less able employees, this fact alone will distinguish it from prior waves of innovation. [1]

3. Access To Generative AI Helps New Workers “Move Down the Learning Curve”

Perhaps the most philosophically interesting conclusion drawn by the study’s authors relates to how generative AI is able to partially learn the tacit knowledge of more skilled workers.

The term “tacit knowledge” refers to the hard-to-articulate behaviors you pick up as you get good at something.

Imagine trying to teach a person how to ride a bike. It’s easy enough to give broad instructions (“check your shoelaces”, “don’t brake too hard”), but there ends up being a billion little subtleties related to foot placement, posture, etc. that are difficult to get into words.

This is true for everything, and it’s part of what distinguishes masters from novices. It’s also a major reason for the fact that many professions have been resistant to full automation.

Remember our discussion of how rule-based programming is poorly suited to tasks where the rules are hard to state? Well, that applies to tasks involving a lot of tacit knowledge. If no one, not even an expert, can tell you precisely what steps to take to replicate their results, then no one is going to be able to program a computer to do it either.

But ML and generative AI don’t face this restriction. With data sets that are big enough and rich enough, the algorithms might be able to capture some of the tacit knowledge expert contact center agents have, e.g. how they phrase replies to customers.

This is suggested by the study’s results. By analyzing the text of customer-agent interactions, the authors found that novice agents using generative AI were able to sound more like experienced agents, which contributed to their success.

4. Access to Generative AI Changed the Way the Organization Functioned

Organizations are profoundly shaped by their workers, and we should expect to see organization-level changes when a new technology dramatically changes how employees operate.

Two major findings from the study were that employee turnover was markedly reduced and there were far fewer customers “escalating” an issue by asking to speak to a supervisor. This could be because agents using generative AI were overall treated much better by customers (who have been known to become frustrated and irate), leading to less stress.

The Contact Center of the Future

Generative AI has already impacted many domains, and this trend will likely only continue going forward. “Generative AI At Work” provides a fascinating glimpse into the way that this technology changed a large contact center by boosting productivity among the least-skilled agents, helping disseminate the hard-won experience of the most-skilled agents, and overall reducing turnover and dissatisfaction.

If this piece has piqued your curiosity about how you can use advanced AI tools for customer-facing applications, schedule a demo of the Quiq conversational CX platform today.

From resolving customer complaints with chatbots to automated text-message follow-ups, we’ve worked hard to build a best-in-class solution for businesses that want to scale with AI.

Let’s see what we can do for you!

[1] See e.g. this quote: “Our paper is related to a large literature on the impact of various forms of technological adoption on worker productivity and the organization of work (e.g. Rosen, 1981; Autor et al., 1998; Athey and Stern, 2002; Bresnahan et al., 2002; Bartel et al., 2007; Acemoglu et al., 2007; Hoffman et al., 2017; Bloom et al., 2014; Michaels et al., 2014; Garicano and Rossi-Hansberg, 2015; Acemoglu and Restrepo, 2020). Many of these studies, particularly those focused on information technologies, find evidence that IT complements higher-skill workers (Akerman et al., 2015; Taniguchi and Yamada, 2022). Bartel et al. (2007) shows that firms that adopt IT tend to use more skilled labor and increase skill requirements for their workers. Acemoglu and Restrepo (2020) study the diffusion of robots and find that the negative employment effects of robots are most pronounced for workers in blue-collar occupations and those with less than a college education. In contrast, we study a different type of technology—generative AI—and find evidence that it most effectively augments lower-skill workers.”

A Guide to Fine-Tuning Pretrained Language Models for Specific Use Cases

Posted on The Quiq Team

Over the past half-year, large language models (LLMs) like ChatGPT have proven remarkably useful for a wide range of tasks, including machine translation, code analysis, and customer interactions in places like contact centers.

For all this power and flexibility, however, it is often still necessary to use fine-tuning to get an LLM to generate high-quality output for specific use cases.

Today, we’re going to do a deep dive into this process, understanding how these models work, what fine-tuning is, and how you can leverage it for your business.

What is a Pretrained Language Model?

First, let’s establish some background context by tackling the question of what pretrained models are and how they work.

The “GPT” in ChatGPT stands for “generative pretrained transformer”, and this gives us a clue as to what’s going on under the hood. ChatGPT is a generative model, meaning its purpose is to create new output; it’s pretrained, meaning that it has already seen a vast amount of text data by the time end users like us get our hands on it; and it’s a transformer, which refers to the fact that it’s built out of billions of transformer modules stacked into layers.

If you’re not conversant in the history of machine learning it can be difficult to see what the big deal is, but pretrained models are a relatively new development. Once upon a time in the ancient past (i.e. 15 or 20 years ago), it was an open question as to whether engineers would be able to pretrain a single model on a dataset and then fine-tune its performance, or whether they would need to approach each new problem by training a model from scratch.

This question was largely resolved around 2013, when image models trained on the ImageNet dataset began sweeping competitions left and right. Since then it has become more common to use pretrained models as a starting point, but we want to emphasize that this approach does not always work. There remain a vast number of important projects for which building a bespoke model is the only way to go.

What is Transfer Learning?

Transfer learning refers to when an agent or system figures out how to solve one kind of problem and then uses this knowledge to solve a different kind of problem. It’s a term that shows up all over artificial intelligence, cognitive psychology, and education theory.

Author, chess master, and martial artist Josh Waitzkin captures the idea nicely in the following passage from his blockbuster book, The Art of Learning:

“Since childhood I had treasured the sublime study of chess, the swim through ever-deepening layers of complexity. I could spend hours at a chessboard and stand up from the experience on fire with insight about chess, basketball, the ocean, psychology, love, art.”

Transfer learning is a broader concept than pretraining, but the two ideas are closely related. In machine learning, competence can be transferred from one domain (generating text) to another (translating between natural languages or creating Python code) by pretraining a sufficiently large model.

What is Fine-Tuning A Pretrained Language Model?

Fine-tuning a pretrained language model occurs when the model is repurposed for a particular task by being shown illustrations of the correct behavior.

If you’re in a whimsical mood, for example, you might give ChatGPT a few dozen limericks so that its future output always has that form.

It’s easy to confuse fine-tuning with a few other techniques for getting optimum performance out of LLMs, so it’s worth getting clear on terminology before we attempt to give a precise definition of fine-tuning.

Fine-Tuning a Language Model v.s. Zero-Shot Learning

Zero-shot learning is whatever you get out of a language model when you feed it a prompt without making any special effort to show it what you want. It’s not technically a form of fine-tuning at all, but it comes up in a lot of these conversations so it needs to be mentioned.

(NOTE: It is sometimes claimed that prompt engineering counts as zero-shot learning, and we’ll have more to say about that shortly.)

Fine-Tuning a Language Model v.s. One-Shot Learning

One-shot learning is showing a language model a single example of what you want it to do. Continuing our limerick example, one-shot learning would be giving the model one limerick and instructing it to format its replies with the same structure.

Fine-Tuning a Language Model v.s. Few-Shot Learning

Few-shot learning is more or less the same thing as one-shot learning, but you give the model several examples of how you want it to act.

How many counts as “several”? There’s no agreed-upon number that we know about, but probably 3 to 5, or perhaps as many as 10. More than this and you’re arguably not doing “few”-shot learning anymore.

Fine-Tuning a Language Model v.s. Prompt Engineering

Large language models like ChatGPT are stochastic and incredibly sensitive to the phrasing of the prompts they’re given. For this reason, it can take a while to develop a sense of how to feed the model instructions such that you get what you’re looking for.

The emerging discipline of prompt engineering is focused on cultivating this intuitive feel. Minor tweaks in word choice, sentence structure, etc. can have an enormous impact on the final output, and prompt engineers are those who have spent the time to learn how to make the most effective prompts (or are willing to just keep tinkering until the output is correct).

Does prompt engineering count as fine-tuning? We would argue that it doesn’t, primarily because we want to reserve the term “fine-tuning” for the more extensive process we describe in the next few sections.

Still, none of this is set in stone, and others might take the opposite view.

Distinguishing Fine-Tuning From Other Approaches

Having discussed prompt engineering and zero-, one-, and few-shot learning, we can give a fuller definition of fine-tuning.

Fine-tuning is taking a pretrained language model and optimizing it for a particular use case by giving it many examples to learn from. How many you ultimately need will depend a lot on your task – particularly how different the task is from the model’s training data and how strict your requirements for its output are – but you should expect it to take on the order of a few dozen or a few hundred examples.

Though it bears an obvious similarity to one-shot and few-shot learning, fine-tuning will generally require more work to come up with enough examples, and you might have to build a rudimentary pipeline that feeds the examples in through the API. It’s almost certainly not something you’ll be doing directly in the ChatGPT web interface.

Contact Us

How Can I Fine-Tune a Pretrained Language Model?

Having gotten this far, we can now turn our attention to what the fine-tuning procedure actually consists in. The basic steps are: deciding what you’re wanting to accomplish, gather the requisite data (and formatting it correctly), feeding it to your model, and evaluating the results.

Let’s discuss each, in turn.

Deciding on Your Use Case

The obvious place to begin is figuring out exactly what it is you want to fine-tune a pretrained model to do.

It may seem as though this is too obvious to be included as its own standalone step, but we’ve singled it out is because you need to think through the specifics of what you’re trying to accomplish. It’s not enough to say “We want to fine-tune this model to write tweets for us”, you have to consider questions like “Should the tone by formal or informal” and “Are we okay with it adding emojis”.

This matters because it informs the data that you gather for fine-tuning. If you feed the model irreverent tweets with lots of s and s, you can expect that to show up in the tweets it generates for you.

Picking a Base Model

Next, you have to figure out which model you want to fine-tune. This is not the place to get into a discussion on all the “foundation” models that are available today, but suffice it to say that HuggingFace, OpenAI, Anthropic, and the other companies in the pretrained model space offer a variety of different options. BigScience has BLOOM and T0pp models, OpenAI has Ada, Babbage, Da Vinci, and Curie, and so on.

Different models have different fine-tuning requirements, so this choice will impact how you structure your pipeline later.

Gathering and Formatting the Fine-Tuning Data

The heart of fine-tuning a pretrained model is gathering the samples from which it will learn. This is more or less exactly what it sounds like: you compile a list of prompts and desired responses. This is the data that will adjust the model’s internal parameters, optimizing it for your use case.

AI educator Dave Shapiro has a tutorial on fine-tuning GPT-3 to be a tutor for younger students, and here is one of the training samples he used (“TIM” is the name he’s using for the tutor):

User: Hey TIM, I’m interested in learning more about Charles Darwin. Can you tell me a bit about him?

TIM: Charles Darwin was an English naturalist and geologist who developed the theory of evolution by natural selection. He was born into a wealthy family and was able to attend the prestigious Shrewsbury School. After graduation, he enrolled at the University of Edinburgh to study medicine, but he soon dropped out and enrolled at Christ’s College, Cambridge.

User: Interesting! I didn’t know he was born into a wealthy family.

TIM: Yes, his family was very wealthy and his father was a doctor. Darwin’s grandfather, Erasmus Darwin, was a well-known scientist and wrote several books on botany and evolution.

User: Wow, I had no idea. What made Darwin decide to drop out of medical school and study at Cambridge?

TIM: Darwin was interested in natural history and had developed a keen interest in taxidermy. After dropping out of medical school, he traveled to Wales with some friends to study geology. It was during this time that he began to develop his theory of evolution.

One thing you’ll note is that this sample is pretty long. It could take a while to come up with hundreds of these to fine-tune your model, but that’s actually something a generative pretrained language model like ChatGPT can help with. Just be sure you have a human go over the samples and check them for accuracy, or you risk compromising the quality of your outputs.

Another thing to think about is how you’ll handle adversarial behavior and edge cases. If you’re training a conversational AI chatbot for a contact center, for example, you’ll want to include plenty of instances of the model calmly and politely responding to an irate customer. That way, your output will be similarly calm and polite.

Lastly, you’ll have to format the fine-tuning data according to whatever specifications are required by the base model you’re using. It’ll probably be something similar to JSON, but check the documentation to be sure.

Feeding it to Your Model

Now that you’ve got your samples ready, you’ll have to give them to the model for fine-tuning. This will involve you feeding the examples to the model via its API and waiting until the process has finished.

What is the Difference Between Fine-Tuning and a Pretrained Model?

A pretrained model is one that has been previously trained on a particular dataset or task, and fine-tuning is getting that model to do well on a new task by showing it examples of the output you want to see.

Pretrained models like ChatGPT are often pretty good out of the box, but if you’re wanting it to create legal contracts or work with highly-specialized scientific vocabulary, you’ll likely need to fine-tune it.

Should You Fine-Tune a Pretrained Model For Your Business?

Generative pretrained language models like ChatGPT and Bard have already begun to change the way businesses like contact centers function, and we think this is a trend that is likely to accelerate in the years ahead.

If you’ve been intrigued by the possibility of fine-tuning a pretrained model to supercharge your enterprise, then hopefully the information contained in this article gives you some ideas on how to begin.

Another option is to leverage the power of the Quiq platform. We’ve built a best-in-class conversational AI system that can automate substantial parts of your customer interactions (without you needing to run your own models or set up a fine-tuning pipeline.)

To see how we can help, schedule a demo with us today!

Request A Demo

Brand Voice And Tone Building With Prompt Engineering

Posted on The Quiq Team

Key Takeaways

  • Prompt engineering is essential for shaping AI output. Small changes in wording, context, or tone in a prompt can produce vastly different results, making prompt design a core skill for guiding generative models.
  • Prompts have distinct components that improve reliability. Effective prompts include: background context, clear instructions, example data, and output constraints to steer the model’s behavior.
  • There are risks and challenges tied to brand-level content. LLMs can hallucinate, stray in tone or style, or violate compliance constraints. Mitigations include instructing “what not to do,” iterative refinement, and human oversight.
  • Prompt engineering supports marketing tasks, but isn’t a silver bullet. You can use AI for idea generation, background research, and drafting, but models are best used as aids, not full replacements for skilled human writers.

Artificial intelligence tools like ChatGPT are changing the way strategists are building their brands.

But with the staggering rate of change in the field, it can be hard to know how to utilize its full potential. Should you hire an engineering team? Pay for a subscription and do it yourself?

The truth is, it depends. But one thing you can try is prompt engineering, a term that refers to carefully crafting the instructions you give to the AI to get the best possible results.

In this piece, we’ll cover the basics of prompt engineering and discuss the many ways in which you can build your brand voice with generative AI.

What is Prompt Engineering?

As the name implies, generative AI refers to any machine learning (ML) model whose primary purpose is to generate some output. There are generative AI applications for creating new images, text, code, and music.

There are also ongoing efforts to expand the range of outputs generative models can handle, such as a fascinating project to build a high-level programming language for creating new protein structures.

The way you get output from a generative AI model is by prompting it. Just as you could prompt a friend by asking “How was your vacation in Japan,” you can prompt a generative model by asking it questions and giving it instructions. Here’s an example:

“I’m working on learning Java, and I want you to act as though you’re an experienced Java teacher. I keep seeing terms like `public class` and `public static void`. Can you explain to me the different types of Java classes, giving an example and explanation of each?”

When we tried this prompt with GPT-4, it responded with a lucid breakdown of different Java classes (i.e., static, inner, abstract, final, etc.), complete with code snippets for each one.

When Small Changes Aren’t So Small

Mapping the relationship between human-generated inputs and machine-generated outputs is what the emerging field of “prompt engineering” is all about.

Prompt engineering only entered popular awareness in the past few years, as a direct consequence of the meteoric rise of large language models (LLMs). It rapidly became obvious that GPT-3.5 was vastly better than pretty much anything that had come before, and there arose a concomitant interest in the best ways of crafting prompts to maximize the effectiveness of these (and similar) tools.

At first glance, it may not be obvious why prompt engineering is a standalone profession. After all, how difficult could it be to simply ask the computer to teach you Chinese or explain a coding concept? Why have a “prompt engineer” instead of a regular engineer who sometimes uses GPT-4 for a particular task?

A lot could be said in reply, but the big complication is the fact that a generative AI’s output is extremely dependent upon the input it receives.

An example pulled from common experience will make this clearer. You’ve no doubt noticed that when you ask people different kinds of questions you elicit different kinds of responses. “What’s up?” won’t get the same reply as “I notice you’ve been distant recently, does that have anything to do with losing your job last month?”

The same basic dynamic applies to LLMs. Just as subtleties in word choice and tone will impact the kind of interaction you have with a person, they’ll impact the kind of interaction you have with a generative model.

All this nuance means that conversing with your fellow human beings is a skill that takes a while to develop, and that also holds in trying to productively using LLMs. You must learn to phrase your queries in a way that gives the model good context, includes specific criteria as to what you’re looking for in a reply, etc.

Honestly, it can feel a little like teaching a bright, eager intern who has almost no initial understanding of the problem you’re trying to get them to solve. If you give them clear instructions with a few examples they’ll probably do alright, but you can’t just point them at a task and set them loose.

We’ll have much more to say about crafting the kinds of prompts that help you build your brand voice in upcoming sections, but first, let’s spend some time breaking down the anatomy of a prompt.

This context will come in handy later.

What’s In A Prompt?

In truth, there are very few real restrictions on how you use an LLM. If you ask it to do something immoral or illegal it’ll probably respond along the lines of “I’m sorry Dave, but as a large language model I can’t let you do that,” otherwise you can just start feeding it text and seeing how it responds.

That being said, prompt engineers have identified some basic constituent parts that go into useful prompts. They’re worth understanding as you go about using prompt engineering to build your brand voice.

Context

First, it helps to offer the LLM some context for the task you want done. Under most circumstances, it’s enough to give it a sentence or two, though there can be instances in which it makes sense to give it a whole paragraph.

Here’s an example prompt without good context:

“Can you write me a title for a blog post?”

Most human beings wouldn’t be able to do a whole lot with this, and neither can an LLM. Here’s an example prompt with better context:

“I’ve just finished a blog post for a client that makes legal software. It’s about how they have the best payments integrations, and the tone is punchy, irreverent, and fun. Could you write me a title for the post that has the same tone?”

To get exactly what you’re looking for you may need to tinker a bit with this prompt, but you’ll have much better chances with the additional context.

Instructions

Of course, the heart of the matter is the actual instructions you give the LLM. Here’s the context-added prompt from the previous section, whose instructions are just okay:

“I’ve just finished a blog post for a client that makes legal software. It’s about how they have the best payments integrations, and the tone is punchy, irreverent, and fun. Could you write me a title for the post that has the same tone?”

A better way to format the instructions is to ask for several alternatives to choose from:

“I’ve just finished a blog post for a client that makes legal software. It’s about how they have the best payments integrations, and the tone is punchy, irreverent, and fun. Could you give me 2-3 titles for the blog post that have the same tone?”

Here again, it’ll often pay to go through a couple of iterations. You might find – as we did when we tested this prompt – that GPT-4 is just a little too irreverent (it used profanity in one of its titles.) If you feel like this doesn’t strike the right tone for your brand identity you can fix it by asking the LLM to be a bit more serious, or rework the titles to remove the profanity, etc.

You may have noticed that “keep iterating and testing” is a common theme here.

Example Data

Though you won’t always need to get the LLM input data, it is sometimes required (as when you need it to summarize or critique an argument) and is often helpful (as when you give it a few examples of titles you like.)

Here’s the reworked prompt from above, with input data:

“I’ve just finished a blog post for a client that makes legal software. It’s about how they have the best payments integrations, and the tone is punchy, irreverent, and fun. Could you give me 2-3 titles for the blog post that have the same tone?

Here’s a list of two titles that strike the right tone:
When software goes hard: dominating the legal payments game.
Put the ‘prudence’ back in ‘jurisprudence’ by streamlining your payment collections.”

Remember, LLMs are highly sensitive to what you give them as input, and they’ll key off your tone and style. Showing them what you want dramatically boosts the chances that you’ll be able to quickly get what you need.

Output Indicators

An output indicator is essentially any concrete metric you use to specify how you want the output to be structured. Our existing prompt already has one, and we’ve added another (both are bolded):

“I’ve just finished a blog post for a client that makes legal software. It’s about how they have the best payments integrations, and the tone is punchy, irreverent, and fun. Could you give me 2-3 titles for the blog post that have the same tone? Each title should be approximately 60 characters long.

Here’s a list of two titles that strike the right tone:
When software goes hard: dominating the legal payments game.
Put the ‘prudence’ back in ‘jurisprudence’ by streamlining your payment collections.”

As you go about playing with LLMs and perfecting the use of prompt engineering in building your brand voice, you’ll notice that the models don’t always follow these instructions. Sometimes you’ll ask for a five-sentence paragraph that actually contains eight sentences, or you’ll ask for 10 post ideas and get back 12.

We’re not aware of any general way of getting an LLM to consistently, strictly follow instructions. Still, if you include good instructions, clear output indicators, and examples, you’ll probably get close enough that only a little further tinkering is required.

What Are The Different Types of Prompts You Can Use For Prompt Engineering?

Though prompt engineering for tasks like brand voice and tone building is still in its infancy, there are nevertheless a few broad types of prompts that are worth knowing.

  • Zero-shot prompting: A zero-shot prompt is one in which you simply ask directly for what you want without providing any examples. It’ll simply generate an output on the basis of its internal weights and prior training, and, surprisingly, this is often more than sufficient.
  • One-shot prompting: With a one-shot prompt, you’re asking the LLM for output and giving it a single example to learn from.
  • Few-shot prompting: Few-shot prompts involve a least a few examples of expected output, as in the two titles we provided our prompt when we asked it for blog post titles.
  • Chain-of-thought prompting: Chain-of-thought prompting is similar to few-shot prompting, but with a twist. Rather than merely giving the model examples of what you want to see, you craft your examples such that they demonstrate a process of explicit reasoning. When done correctly, the model will actually walk through the process it uses to reason about a task. Not only does this make its output more interpretable, but it can also boost accuracy in domains at which LLMs are notoriously bad, like addition.

What Are The Challenges With Prompt Engineering For Brand Voice?

We don’t use the word “dazzling” lightly around here, but that’s the best way of describing the power of ChatGPT and the broader ecosystem of large language models.

You would be hard-pressed to find many people who have spent time with one and come away unmoved.

Still, challenges remain, especially when it comes to using prompt engineering for content marketing or building your brand voice.

One well-known problem is the tendency of LLMs to completely make things up, a phenomenon referred to as “hallucination”. The internet is now filled with examples of ChatGPT completely fabricating URLs, books, papers, professions, and individuals. If you use an LLM to create content for your website and don’t thoroughly vet it, you run the risk of damaging your reputation and your brand if it contains false or misleading information.

A related problem is legal or compliance issues that emerge as a result of using an LLM. Though the technology hasn’t been around long enough to get anyone into serious trouble (we suspect it won’t be long), there are now cases in which attorneys have been caught using faulty research generated by ChatGPT or engineering teams have leaked proprietary secrets by feeding meeting notes into it.

Finally, if you’re offering a fine-tuned model to customers to do something like answer questions, you must be very, very careful in delimiting its scope so that it doesn’t generate unwanted behavior. It’s pretty easy to accidentally wander into fraught territory when engaging with an LLM in an open-ended manner, and that’s not even counting users who deliberately try to get it to respond inappropriately.

One potential solution to this problem is by crafting your prompts such that they contain clear instructions about what not to do. You may tell it not to discuss its own rules, not to change its tone, not to speak negatively about anyone, not to argue, etc.

Crafting a prompt that illustrates the correct behavior while explicitly ruling out any incorrect behaviors is a non-trivial task, requiring a great deal of testing and refinement. But it’s one you’ll have to get right if you want to leverage LLMs for your brand voice while avoiding any possible harm down the line.

Prompt Engineering For Marketers

With all this context having been established, you’re no doubt excited about using prompt engineering in your marketing efforts. In this section, we’ll go through a couple of ways you can do that.

Coming up with ideas

One place where LLMs excel is in helping you with ideation. A lot goes into content marketing, but all of that follows from having a solid list of basic concepts to work from.

We tested ChatGPT’s functionality by feeding it this query:

“I’m starting a blog about becoming a data scientist. Could you give me a list of 10 blog post ideas, with a mix of beginner, intermediate, and advanced topics? The titles should be eye-catching but not too aggressive.

Here are two examples of good blog post titles:

‘Data science: what to know when considering a career in this hot new field.’
‘Data science v.s. data engineering: everything you wanted to know’”

And we got back some excellent ideas:

  1. “Demystifying Data Science: A Beginner’s Guide to Jumpstarting Your Career”
  2. “From Novice to Ninja: Essential Skills for Every Data Science Aspirant”
  3. “Unlocking the Power of Python: A Data Scientist’s Best Friend”
  4. “Exploratory Data Analysis: Unveiling Insights Hidden in the Numbers”
  5. “Machine Learning 101: A Gentle Introduction for Data Science Enthusiasts”
  6. “Feature Engineering: Enhancing Your Models Like a Pro”
  7. “The Art of Natural Language Processing: Extracting Meaning from Text”
  8. “Unsupervised Learning: Unveiling Patterns and Structure in Your Data”
  9. “Deep Dive into Neural Networks: Building Advanced Models for Predictive Analytics”
  10. “Data Science in the Real World: Tackling Complex Business Problems with Analytics”

And look, it even generated the correct number of titles! You’ll notice, though that every single one follows the same template, with an initial phrase, a colon, and then a follow-on phrase. That’s because the two examples I gave have this structure, and that’s what it used as a guide.

Performing Background Research

After you’re done coming up with good ideas for building your brand voice, you’ll likely want to do some additional background research on your domain. This, too, is a place where LLMs excel.

There can be a lot of subtlety to this. You might start with something obvious, like “give me a list of the top authors in the keto diet niche”, but you can also get more creative than this. We’ve heard of copywriters who have used GPT-3.5 to generate lengthy customer testimonials for fictional products, or diary entries for i.e. 40-year-old suburban dads who are into DIY home improvement projects.

Regardless, with a little bit of ingenuity, you can generate a tremendous amount of valuable research that can inform your attempts to develop a brand voice.

Be careful, though; this is one place where model hallucinations could be really problematic. Be sure to manually check a model’s outputs before using them for anything critical.

Generating Actual Content

Of course, one place where content marketers are using LLMs more often is in actually writing full-fledged content. We’re of the opinion that GPT-3.5 is still not at the level of a skilled human writer, but it’s excellent for creating outlines, generating email blasts, and writing relatively boilerplate introductions and conclusions.

Getting better at prompt engineering

Despite the word “engineering” in its title, prompt engineering remains as much an art as it is a science. Hopefully, the tips we’ve provided here will help you structure your prompts in a way that gets you good results, but there’s no substitute for practicing the way you interact with LLMs.

One way to approach this task is by paying careful attention to the ways in which small word choices impact the kinds of output generated. You could begin developing an intuitive feel for the relationship between input text and output text by simply starting multiple sessions with ChatGPT and trying out slight variations of prompts. If you really want to be scientific about it, copy everything over into a spreadsheet and look for patterns. Over time, you’ll become more and more precise in your instructions, just as an experienced teacher or manager does.

Prompt Engineering Can Help You Build Your Brand

Advanced AI models like ChatGPT are changing the way SEO, content marketing, and brand strategy are being done. From creating buyer personas to using chatbots for customer interactions, these tools can help you get far more work done with less effort.

But you have to be cautious, as LLMs are known to hallucinate information, change their tone, and otherwise behave inappropriately.

With the right prompt engineering expertise, these downsides can be ameliorated, and you’ll be on your way to building a strong brand. If you’re interested in other ways AI tools can take your business to the next level, schedule a demo of Quiq’s conversational CX platform today!

Contact Us

Frequently Asked Questions (FAQs)

What is prompt engineering?

Prompt engineering is the process of designing clear, strategic inputs that guide AI models to produce accurate, on-brand outputs. From small SMBs looking to create chatbots to large enterprises focused on AI agents, prompting is an essential skill.

Why does prompt wording matter?

Even small wording or tone changes can dramatically affect AI output quality, consistency, and alignment with brand voice.

How can prompt engineering help define a brand’s tone?

By setting context, examples, and constraints, teams can train AI tools to replicate their unique communication style and maintain voice consistency.

What are common prompting techniques?

Zero-shot, one-shot, few-shot, and chain-of-thought prompting. Each helps models improve reasoning or stay closer to brand-approved examples.

What are the biggest risks with prompt engineering?

AI can hallucinate, misinterpret tone, or generate non-compliant content. In enterprise applications, these risks are amplified – making it essential to establish clear guardrails for data privacy, security, and brand compliance. Regular review and prompt refinement help ensure reliable, accurate, and consistent brand messaging at scale.

LLMs For the Enterprise: How to Protect Brand Safety While Building Your Brand Persona

Posted on J.R. Rettenmeyer

It’s long been clear that advances in artificial intelligence change how businesses operate. Whether it’s extremely accurate machine translation, chatbots that automate customer service tasks, or spot-on recommendations for music and shows, enterprises have been using advanced AI systems to better serve their customers and boost their bottom line for years.

Today the big news is generative AI, with large language models (LLMs) in particular capturing the imagination. As we’d expect, businesses in many different industries are enthusiastically looking at incorporating these tools into their workflows, just as prior generations did for the internet, computers, and fax machines.

But this alacrity must be balanced with a clear understanding of the tradeoffs involved. It’s one thing to have a language model answer simple questions, and quite another to have one engaging in open-ended interactions with customers involving little direct human oversight.

If you have an LLM-powered application and it goes off the rails, it could be mildly funny, or it could do serious damage to your brand persona. You need to think through both possibilities before proceeding.

This piece is intended as a primer on effectively using LLMs for the enterprise. If you’re considering integrating LLMs for specific applications and aren’t sure how to weigh the pros and cons, it will provide invaluable advice on the different options available while furnishing the context you need to decide which is the best fit for you.

How Are LLMs Being Used in Business?

LLMs like GPT-4 are truly remarkable artifacts. They’re essentially gigantic neural networks with billions of internal parameters, trained on vast amounts of text data from books and the internet.

Once they’re ready to go, they can be used to ask and answer questions, suggest experiments or research ideas, write code, write blog posts, and perform many other tasks.

Their flexibility, in fact, has come as quite a surprise, which is why they’re showing up in so many places. Before we talk about specific strategies for integrating LLMs into your enterprise, let’s walk through a few business use cases for the technology.

Generating (or rewriting) text

The obvious use case is generating text. GPT-4 and related technologies are very good at writing generic blog posts, copy, and emails. But they’ve also proven useful in more subtle tasks, like producing technical documentation or explaining how pieces of code work.

Sometimes it makes sense to pass this entire job on to LLMs, but in other cases, they can act more like research assistants, generating ideas or taking human-generated bullet points and expanding on them. It really depends on the specifics of what you’re trying to accomplish.

Conversational AI

A subcategory of text generation is using an LLM as a conversational AI agent. Clients or other interested parties may have questions about your product, for instance, and many of them can be answered by a properly fine-tuned LLM instead of by a human. This is a use case where you need to think carefully about protecting your brand persona because LLMs are flexible enough to generate inappropriate responses to questions. You should extensively test any models meant to interact with customers and be sure your tests include belligerent or aggressive language to verify that the model continues to be polite.

Summarizing content

Another place that LLMs have excelled is in summarizing already-existing text. This, too, is something that once would’ve been handled by a human, but can now be scaled up to the greater speed and flexibility of LLMs. People are using LLMs to summarize everything from basic articles on the internet to dense scientific and legal documents (though it’s worth being careful here, as they’re known to sometimes include inaccurate information in these summaries.)

Answering questions

Though it might still be a while before ChatGPT is able to replace Google, it has become more common to simply ask it for help rather than search for the answer online. Programmers, for example, can copy and paste the error messages produced by their malfunctioning code into ChatGPT to get its advice on how to proceed. The same considerations around protecting brand safety that we mentioned in the ‘conversational AI’ section above apply here as well.

Classification

One way to get a handle on a huge amount of data is to use a classification algorithm to sort it into categories. Once you know a data point belongs in a particular bucket you already know a fair bit about it, which can cut down on the amount of time you need to spend on analysis. Classifying documents, tweets, etc. is something LLMs can help with, though at this point a fair bit of technical work is required to get models like GPT-3 to reliably and accurately handle classification tasks.

Sentiment analysis

Sentiment analysis refers to a kind of machine learning in which the overall tone of a piece of text is identified (i.e. is it happy, sarcastic, excited, etc.) It’s not exactly the same thing as classification, but it’s related. Sentiment analysis shows up in many customer-facing applications because you need to know how people are responding to your new brand persona or how they like an update to your core offering, and this is something LLMs have proven useful for.

What Are the Advantages of Using LLMs in Business?

More and more businesses are investigating LLMs for their specific applications because they confer many advantages to those that know how to use them.

For one thing, LLMs are extremely well-suited for certain domains. Though they’re still prone to hallucinations and other problems, LLMs can generate high-quality blog posts, emails, and general copy. At present, the output is usually still not as good as what a skilled human can produce.

But LLMs can generate text so quickly that it often makes sense to have the first draft created by a model and tweaked by a human, or to have relatively low-effort tasks (like generating headlines for social media) delegated to a machine so a human writer can focus on more valuable endeavors.

For another, LLMs are highly flexible. It’s relatively straightforward to take a baseline LLM like GPT-4 and feed it examples of behavior you want to see, such as generating math proofs in the form of poetry (if you’re into that sort of thing.) This can be done with prompt engineering or with a more sophisticated pipeline involving the model’s API, but in either case, you have the option of effectively pointing these general-purpose tools at specific tasks.

None of this is to suggest that LLMs are always and everywhere the right tool for the job. Still, in many domains, it makes sense to examine using LLMs for the enterprise.

What Are the Disadvantages of Using LLMs in Business?

For all their power, flexibility, and jaw-dropping speed, there are nevertheless drawbacks to using LLMs.

One disadvantage of using LLMs in business that people are already familiar with is the variable quality of their output. Sometimes, the text generated by an LLM is almost breathtakingly good. But LLMs can also be biased and inaccurate, and their hallucinations – which may not be a big deal for SEO blog posts – will be a huge liability if they end up damaging your brand.

Exacerbating this problem is the fact that no matter how right or wrong GPT-4 is, it’ll format its response in flawless, confident prose. You might expect a human being who doesn’t understand medicine very well to misspell a specialized word like “Umeclidinium bromide”, and that would offer you a clue that there might be other inaccuracies. But that essentially never happens with an LLM, so special diligence must be exercised in fact-checking their claims.

There can also be substantial operational costs associated with training and using LLMs. If you put together a team to build your own internal LLM you should expect to spend (at least) hundreds of thousands of dollars getting it up and running, to say nothing of the ongoing costs of maintenance.

Of course, you could also build your applications around API calls to external parties like OpenAI, who offer their models’ inferences as an endpoint. This is vastly cheaper, but it comes with downsides of its own. Using this approach means being beholden to another entity, which may release updates that dramatically change the performance of their models and materially impact your business.

Perhaps the biggest underlying disadvantage to using LLMs, however, is their sheer inscrutability. True, it’s not that hard to understand at a high level how models like GPT-4 are trained. But the fact remains that no one really understands what’s happening inside of them. It’s usually not clear why tiny changes to a prompt can result in such wildly different outputs, for example, or why a prompt will work well for a while before performance suddenly starts to decline.

Perhaps you just got unlucky – these models are stochastic, after all – or perhaps OpenAI changed the base model. You might not be able to tell, and either way, it’s hard to build robust, long-range applications around technologies that are difficult to understand and predict.

Contact Us

How Can LLMs Be Integrated Into Enterprise Applications?

If you’ve decided you want to integrate these groundbreaking technologies into your own platforms, there are two basic ways you can proceed. Either you can use a 3rd-party service through an API, or you can try to run your own models instead.

In the following two sections, we’ll cover each of these options and their respective tradeoffs.

Using an LLM through an API

An obvious way of leveraging the power of LLMs is by simply including API calls to a platform that specializes in them, such as OpenAI. Generally, this will involve creating infrastructure that is able to pass a prompt to an LLM and return its output.

If you’re building a user-facing chatbot through this method, that would mean that whenever the user types a question, their question is sent to the model and its response is sent back to the user.

The advantages of this approach are that they offer an extremely low barrier to entry, low costs, and fast response times. Hitting an API is pretty trivial as engineering tasks go, and though you’re charged per token, the bill will surely be less than it would be to stand up an entire machine-learning team to build your own model.

But, of course, the danger is that you’re relying on someone else to deliver crucial functionality. If OpenAI changes its terms of service or simply goes bankrupt, you could find yourself in a very bad spot.

Another disadvantage is that the company running the model may have access to the data you’re passing to its models. A team at Samsung recently made headlines when it was discovered they’d been plowing sensitive meeting notes and proprietary source code directly into ChatGPT, where both were viewable by OpenAI. You should always be careful about the data you’re exposing, particularly if it’s customer data whose privacy you’ve been entrusted to protect.

Running Your Own Model

The way to ameliorate the problems of accessing an LLM through an API is to either roll your own or run an open-source model in an environment that you control.

Building the kind of model that can compete with GPT-4 is really, really difficult, and it simply won’t be an option for any but the most elite engineering teams.

Using an open-source LLM, however, is a much more viable option. There are now many such models for text or code generation, and they can be fine-tuned for the specifics of your use case.

By and large, open-source models tend to be smaller and less performant than their closed-source cousins, so you’ll have to decide whether they’re good enough for you. And you should absolutely not underestimate the complexity of maintaining an open-sourced LLM. Though it’s nowhere near as hard as training one from scratch, maintaining an advanced piece of AI software is far from a trivial task.

All that having been said, this is one path you can take if you have the right applications in mind and the technical skills to pull it off.

How to Protect Brand Safety While Building Your Brand Persona

Throughout this piece, we’ve made mention of various ways in which LLMs can help supercharge your business while also warning of the potential damage a bad LLM response can do to your brand.

At present, there is no general-purpose way of making sure an LLM only does good things while never doing bad things. They can be startlingly creative, and with that power comes the possibility that they’ll be creative in ways you’d rather them not be (same as children, we suppose.)

Still, it is possible to put together an extensive testing suite that substantially reduces the possibility of a damaging incident. You need to feed the model many different kinds of interactions, including ones that are angry, annoyed, sarcastic, poorly spelled or formatted, etc., to see how it behaves.

What’s more, this testing needs to be ongoing. It’s not enough to run a test suite one weekend and declare the model fit for use, it needs to be periodically re-tested to ensure no bad behavior has emerged.

With these techniques, you should be able to build a persona as a company on the cutting edge while protecting yourself from incidents that damage your brand.

What Is the Future of LLMs and AI?

The business world moves fast, and if you’re not keeping up with the latest advances you run the risk of being left behind. At present, large language models like GPT-4 are setting the world ablaze with discussions of their potential to completely transform fields like customer experience chatbots.

If you want in on the action and you have the in-house engineering expertise, you could try to create your own offering. But if you would rather leverage the power of LLMs for chat-based applications by working with a world-class team that’s already done the hard engineering work, reach out to Quiq to schedule a demo.

Request A Demo

Semi-Supervised Learning: What It Is and How It Works

Posted on The Quiq Team

Key Takeaways

  • Semi-supervised learning combines a small set of labeled data with a large set of unlabeled data to improve model performance.
  • Common methods include self-training (model teaches itself with pseudo-labels), co-training (two models teach each other), and graph-based learning (labels spread through data connections).
  • It’s useful when labeling data is expensive or time-consuming, like in fraud detection, content classification, or image analysis.
  • Semi-supervised learning is different from self-supervised learning (predicting parts of data) and active learning (asking for labels on uncertain data).

From movie recommendations to AI agents as customer service reps, it seems like machine learning (ML) is everywhere. But one thing you may not realize is just how much data is required to train these advanced systems, and how much time and energy goes into formatting that data appropriately.

Machine learning engineers have developed many ways of trying to cut down on this bottleneck, and one of the techniques that has emerged from these efforts is semi-supervised learning.

Today, we’re going to discuss semi-supervised learning, how it works, and where it’s being applied.

What is Semi-Supervised Learning?

Semi-supervised learning (SSL) is an approach to machine learning (ML) that is appropriate for tasks where you have a large amount of data that you want to learn from, only a fraction of which is labeled.

Semi-supervised learning sits somewhere between supervised and unsupervised learning, and we’ll start by understanding these techniques because that will make it easier to grasp how semi-supervised learning works.

  • Supervised learning: refers to any ML setup in which a model learns from labeled data. It’s called “supervised” because the model is effectively being trained by showing it many examples of the right answer.
  • Unsupervised learning: requires no such labeled data. Instead, an unsupervised machine learning algorithm is able to ingest data, analyze its underlying structure, and categorize data points according to this learned structure.

Like we stated previously, semi-supervised learning combines elements of supervised and unsupervised learning. Instead of relying solely on labeled data (like supervised models) or unlabeled data (like unsupervised ones), it uses a small labeled dataset alongside a larger unlabeled one to improve accuracy and efficiency.

This approach is especially useful when labeling data is costly or time-consuming, such as tagging support chats or images. The labeled examples guide the model’s understanding, while the unlabeled data helps it generalize to new patterns. By blending both data types, semi-supervised learning strikes a balance between performance and scalability, making it ideal for AI applications like intent detection, chat automation, and content moderation.

Semi-supervised learning

How Does Semi-Supervised Learning Work?

The three main variants of semi-supervised learning are self-training, co-training, and graph-based label propagation, and we’ll discuss each of these in turn.

Self-training

Self-training is the simplest kind of semi-supervised learning, and it works like this.

A small subset of your data will have labels while the rest won’t have any, so you’ll begin by using supervised learning to train a model on the labeled data. With this model, you’ll go over the unlabeled data to generate pseudo-labels, so-called because they are machine-generated and not human-generated.

Now, you have a new dataset; a fraction of it has human-generated labels while the rest contains machine-generated pseudo-labels, but all the data points now have some kind of label, and a model can be trained on them.

Co-training

Co-training has the same basic flavor as self-training, but it has more moving parts. With co-training, you’re going to train two models on the labeled data, each on a different set of features (in literature, these are called “views”).

If we’re still working on that plant classifier from before, one model might be trained on the number of leaves or petals, while another might be trained on their color.

At any rate, now you have a pair of models trained on different views of the labeled data. These models will then generate pseudo-labels for all the unlabeled datasets. When one of the models is very confident in its pseudo-label (i.e., when the probability it assigns to its prediction is very high), that pseudo-label will be used to update the prediction of the other model, and vice versa.

Let’s say both models come to an image of a rose. The first model thinks it’s a rose with 95% probability, while the other thinks it’s a tulip with a 68% probability. Since the first model seems really sure of itself, its label is used to change the label on the other model.

Think of it like studying a complex subject with a friend. Sometimes a given topic will make more sense to you, and you’ll have to explain it to your friend. Other times, they’ll have a better handle on it, and you’ll have to learn from them.

In the end, you’ll both have made each other stronger, and you’ll get more done together than you would’ve done alone. Co-training attempts to utilize the same basic dynamic with ML models.

Graph-based semi-supervised learning

Another way to apply labels to unlabeled data is by utilizing a graph data structure. A graph is a set of nodes (in graph theory, we call them “vertices”) which are linked together through “edges.” The cities on a map would be vertices, and the highways linking them would be edges.

If you put your labeled and unlabeled data on a graph, you can propagate the labels throughout by counting the number of pathways from a given unlabeled node to the labeled nodes.

Imagine that we’ve got our fern and rose images in a graph, together with a bunch of other unlabeled plant images. We can choose one of those unlabeled nodes and count up how many ways we can reach all the “rose” nodes and all the “fern” nodes. If there are more paths to a rose node than a fern node, we classify the unlabeled node as a “rose”, and vice versa. This gives us a powerful alternative means by which to algorithmically generate labels for unlabeled data.

Contact Us

Common Semi-Supervised Applications

The amount of data in the world is increasing at a staggering rate, while the number of human-hours available for labeling it all is increasing at a much less impressive clip. This presents a problem because there’s no end to the places where we want to apply machine learning.

Semi-supervised learning presents a possible solution to this dilemma, and in the next few sections, we’ll describe semi-supervised learning examples in real life.

  • Identifying cases of fraud: In finance, semi-supervised learning can be used to train systems for identifying cases of fraud or extortion.
  • Classifying content on the web: The internet is a big place, and new websites are put up all the time. In order to serve useful search results, it’s necessary to classify huge amounts of this web content, which can be done with semi-supervised learning.
  • Analyzing audio and images: When audio files or image files are generated, they’re often not labeled, which makes it difficult to use them for machine learning. Beginning with a small subset of human-labeled data, however, this problem can be overcome with semi-supervised learning.

What Are the Benefits of Semi-Supervised Learning?

Semi-supervised learning delivers the best of both worlds – strong model performance without the steep cost of fully labeled datasets. Here are a few key benefits:

Key benefits include:

  • Cost Efficiency: Reduces the need for extensive manual labeling, allowing teams to use mostly unlabeled data while still achieving high accuracy.
  • Better Model Generalization: Improves a model’s ability to recognize patterns in new or unseen data by leveraging diverse, unlabeled examples.
  • Enhanced Performance: Even with limited labeled data, semi-supervised models often outperform those trained solely with supervised techniques.
  • Improved Data Utilization: Makes full use of available data resources, turning previously “unused” unlabeled data into valuable training material.
  • Scalability: Easily adapts as new unlabeled data becomes available, allowing continuous improvement without repeating costly labeling cycles.
  • Faster Deployment: Requires less upfront labeled data, meaning models can reach production readiness sooner and refine over time with additional feedback.

In essence, semi-supervised learning helps organizations maximize the value of their data – achieving stronger, more adaptable AI systems without the traditional bottlenecks of data labeling and cost.

When Should You Use Semi-Supervised Learning (and When Not To)

Semi-supervised learning is most effective when you have a large pool of unlabeled data but only a small amount of labeled data. It’s designed for situations where labeling is expensive or time-consuming, but unlabeled data is plentiful and easy to collect.

When to Use It

  • Labeled Data is Scarce or Costly:  Ideal when labeling requires specialized expertise or significant manual effort.
  • Unlabeled Data is Abundant: Works well when you have vast quantities of raw data – like chat transcripts, audio clips, or product images.
  • To Prevent Overfitting: Adding unlabeled data gives the model more context, helping it generalize better and avoid overfitting to a limited labeled set.
  • For Unstructured Data: Especially effective for text, image, and audio datasets where manual labeling is challenging or subjective.
  • When Supervised or Unsupervised Learning Falls Short: If supervised learning lacks enough labels for accuracy and unsupervised learning lacks direction, semi-supervised learning strikes the balance between structure and scale.

When to Not Use It

  • When Labeled Data is Already Plentiful: If you have a lot of high-quality labeled data, fully supervised learning will usually yield better and more predictable results than semi-supervised learning.
  • For Highly Regulated or Sensitive Applications: In domains like finance or healthcare compliance, the uncertainty of unlabeled data may pose additional risk unless carefully validated.
  • When Data Quality Is Poor: If your unlabeled dataset contains errors, duplicates, or inconsistencies, the model can amplify those problems rather than learn from them.

In short: use semi-supervised learning when you have lots of data, little labeling capacity, and need to scale efficiently. Avoid it when your labeled data is already sufficient or your unlabeled data isn’t reliable enough to guide the model.

The Bottom Line

Semi-supervised learning empowers businesses to get more value out of the data they already have, without waiting for fully labeled datasets. By combining a small amount of labeled data with a much larger pool of unlabeled data, teams can build smarter, faster, and more adaptive models that continually improve over time.

That same principle powers Quiq’s Agentic AI – a solution designed to help enterprise teams leverage their own data to train intelligent, context-aware AI agents. With built-in automation and learning loops, Quiq’s platform helps businesses scale insights, personalize customer interactions, and accelerate innovation with no endless data labeling required.

If you’re exploring how to make your data work harder for you, it’s the perfect time to see what’s possible with Quiq’s AI Studio.

 Frequently Asked Questions (FAQs)

What is semi-supervised learning in simple terms?

Semi-supervised learning is a machine learning approach that uses a small amount of labeled data and a large amount of unlabeled data to train models more efficiently.

How is semi-supervised learning different from supervised and unsupervised learning?

Supervised learning relies only on labeled data, while unsupervised learning uses none. Semi-supervised learning blends both, improving accuracy when labeling is costly or limited.

What are some real-world examples of semi-supervised learning?

It’s used in areas like fraud detection, medical image analysis, customer sentiment classification, and speech recognition – where gathering labeled data is time-consuming or expensive.

What are the main techniques in semi-supervised learning?

Common methods include self-training (the model generates pseudo-labels), co-training (multiple models teach one another), and graph-based algorithms (labels spread through data relationships).

Why is semi-supervised learning important?

It helps businesses and researchers make better use of large unlabeled datasets, reducing labeling costs while still achieving high model accuracy.

Request A Demo