JOHN EWALD: Hello, and
welcome to Introduction to Large Language Models. My name is John Ewald, and
I'm a training developer here at Google Cloud. In this course, you learn
to define large language models, or LLMs,
describe LLM use cases, explain prompt tuning, and
describe Google's Gen AI development tools. Large language models, or LLMs,
are a subset of deep learning. To find out more
about deep learning, see our Introduction to
Generative AI course video. LLMs and generative AI
intersect and they are both a part of deep learning. Another area of AI you
may be hearing a lot about is generative AI. This is a type of
artificial intelligence that can produce new content,
including text, images, audio, and synthetic data. So what are large
language models? Large language models refer to
large general-purpose language models that can be
pre-trained and then fine tuned for specific purposes. What do pre-trained
and fine tuned mean? Imagine training a dog. Often, you train your
dog basic commands such as sit, come,
down, and stay. These commands are normally
sufficient for everyday life and help your dog become
a good canine citizen. However, if you need a special
service dog such as a police dog, a guide dog, or a hunting
dog, you add special trainings. The similar idea applies
to large language models. These models are trained
for general purposes to solve common language
problems such as text classification, question
answering, document summarization, and text
generation across industries. The models can then be tailored
to solve specific problems in different fields
such as retail, finance, and entertainment using a
relatively small size of field data sets. Let's further break
down the concept into three major features
of large language models. Large indicates two meanings. First is the enormous size
of the training data set, sometimes at the petabyte scale. Second, it refers to
the parameter count. In ML, parameters are often
called hyperparameters. Parameters are basically the
memories and the knowledge that the machine learned
from the model training. Parameters define
the skill of a model in solving a problem
such as predicting text. General purpose
means that the models are sufficient to
solve common problems. Two reasons lead to this idea. First is the commonality of
a human language regardless of the specific tasks. And second is the
resource restriction. Only certain organizations
have the capability to train such large language
models with huge data sets and a tremendous
number of parameters. How about letting them create
fundamental language models for others to use? This leads to the last point,
pre-trained and fine tuned, meaning to pre-train
a large language model for a general purpose
with a large data set and then fine tune it for
specific aims with a much smaller data set. The benefits of using
large language models are straightforward. First, a single model can
be used for different tasks. This is a dream come true. These large language
models that are trained with petabytes of
data and generate billions of parameters are smart enough
to solve different tasks, including language translation,
sentence completion, text classification, question
answering, and more. Second, large language models
require minimal field training data when you tailor them to
solve your specific problem. Large language models
obtain decent performance even with little
domain training data. In other words, they can be
used for few shot or even zero-shot scenarios. In machine learning,
few shot refers to training a model
with minimal data, and zero shot implies
that a model can recognize things that have not explicitly
been taught in the training before. Third, the performance
of large language models is continuously growing when you
add more data and parameters. Let's take PaLM as an example. In April 2022,
Google released PaLM, short for Pathways Language
Model, a 540 billion-parameter model that achieves a state
of the art performance across multiple language tasks. PaLM is a dense decoder-only
transformer model. It has 540 billion parameters. It leverages the
new pathways system, which has enabled
Google to efficiently train a single model across
multiple TPU V4 pods. Pathway is a new AI
architecture that will handle many tasks at
once, learn new tasks quickly, and reflect a better
understanding of the world. The system enables PaLM
to orchestrate distributed computation for accelerators. We previously mentioned that
PaLM is a transformer model. A transformer model consists
of encoder and decoder. The encoder encodes
the input sequence and passes it to
the decoder, which learns how to decode
the representations for a relevant task. We've come a long away from
traditional programming to neural networks
to generative models. In traditional
programming, we used to have to hard code the rules
for distinguishing a cat-- type, animal; legs, four;
ears, two; fur, yes; likes yarn, catnip. In the wave of
neural networks, we could give the network pictures
of cats and dogs and ask, is this a cat? And it would predict a cat. In the generative
wave, we as users can generate our own content,
whether it be text, images, audio, video, or other. For example, models
like PaLM, or LaMDA, or Language Model for
Dialogue Applications, ingest very, very large
data from multiple sources across the internet and build
foundation language models we can use simply by
asking a question, whether typing it into
a prompt or verbally talking into the prompt. So when you ask it
what's a cat, it can give you everything it
has learned about a cat. Let's compare LLM development
using pre-trained models with traditional ML development. First, with LLM development,
you don't need to be an expert. You don't need
training examples. And there is no need
to train a model. All you need to do is think
about prompt design, which is the process of creating a
prompt that is clear, concise, and informative. It is an important part of
natural language processing. In traditional
machine learning, you need training examples
to train a model. You also need compute
time and hardware. Let's take a look at an example
of a text generation use case. Question answering, or QA, is
a subfield of natural language processing that deals with the
task of automatically answering questions posed in
natural language. QA systems are typically
trained on a large amount of text and code. And they are able to answer
a wide range of questions, including factual, definitional,
and opinion-based questions. The key here is that you
need domain knowledge to develop these
question-answering models. For example, domain
knowledge is required to develop a question-answering
model for customer support, or health
care, or supply chain. Using generative QA, the
model generates free text directly based on the context. There is no need for
domain knowledge. Let's look at three
questions given to Bard, a large language model chat
bot developed by Google AI. Question one. "This year's sales are $100,000. Expenses are $60,000. How much is net profit?" Bard first shares how net
profit is calculated, then performs the calculation. Then Bard provides the
definition of net profit. Here's another question. Inventory on hand
is 6,000 units. A new order requires
8,000 units. How many units do I need to
fill to complete the order? Again, Bard answers the question
by performing the calculation. And our last example,
we have 1,000 sensors in 10 geographic regions. How many sensors do we have
on average in each region? Bard answers the
question with an example on how to solve the problem
and some additional context. In each of our questions, a
desired response was obtained. This is due to prompt design. Prompt design and
prompt engineering are two closely-related concepts
in natural language processing. Both involve the
process of creating a prompt that is clear,
concise, and informative. However, there are some key
differences between the two. Prompt design is the process
of creating a prompt that is tailored to the specific
task that this system is being asked to perform. For example, if
the system is being asked to translate a text
from English to French, the prompt should be
written in English and should specify that
the translation should be in French. Prompt engineering
is the process of creating a prompt
that is designed to improve performance. This may involve using
domain-specific knowledge, providing examples of
the desired output, or using keywords
that are known to be effective for the
specific system. Prompt design is a
more general concept, while prompt engineering is
a more specialized concept. Prompt design is essential,
while prompt engineering is only necessary
for systems that require a high degree of
accuracy or performance. There are three kinds of
large language models, generic language models,
instruction tuned, and dialogue tuned. Each needs prompting
in a different way. Generic language models
predict the next word based on the language
in the training data. This is an example of a
generic language model. The next word is a token based
on the language in the training data. In this example,
"the cat sat on," the next word should be "the." And you can see that "the"
is the most likely next word. Think of this type as an
autocomplete in search. In instruction
tuned, the model is trained to predict a
response to the instructions given in the input. For example,
summarize a text of X, generate a poem
in the style of X, give me a list of keywords based
on semantic similarity for X. And in this example,
classify the text into neutral,
negative, or positive. In dialogue tuned, the model
is trained to have a dialogue by the next response. Dialogue-tuned models
are a special case of instruction tuned where
requests are typically framed as questions to a chat bot. Dialogue tuning
is expected to be in the context of a longer
back and forth conversation, and typically works better
with natural question-like phrasings. Chain of thought reasoning
is the observation that models are better at
getting the right answer when they first output
text that explains the reason for the answer. Let's look at the question. Roger has five tennis balls. He buys two more
cans of tennis balls. Each can has three tennis balls. How many tennis balls
does he have now? This question is posed
initially with no response. The model is less likely to get
the correct answer directly. However, by the time the
second question is asked, the output is more likely to
end with the correct answer. A model that can do everything
has practical limitations. Task-specific tuning can
make LLMs more reliable. Vertex AI provides
task-specific foundation models. Let's say you have
a use case where you need to gather
sentiments, or how your customers are feeling
about your product or service. You can use the
classification task sentiment analysis task model. Same for vision tasks. If you need to perform
occupancy analytics, there is a task-specific
model for your use case. Tuning a model enables you to
customize the model response based on examples
of the task that you want the model to perform. It is essentially the
process of adapting a model to a new domain, or set
of custom use cases, by training the
model on new data. For example, we may
collect training data and tune the model specifically
for the legal or medical domain. You can also further tune
the model by fine tuning where you bring
your own data set and retrain the model by
tuning every weight in the LLM. This requires a big
training job and hosting your own fine-tuned model. Here's an example of a medical
foundation model trained on health care data. The tasks include question
answering, image analysis, finding similar
patients, and so forth. Fine tuning is expensive and
not realistic in many cases. So are there more efficient
methods of tuning? Yes. Parameter-efficient
tuning methods, or PETM, are methods for tuning
a large language model on your own custom data
without duplicating the model. The base model itself
is not altered. Instead, a small
number of add-on layers are tuned, which can be swapped
in and out at inference time. Generative AI Studio lets you
quickly explore and customize generative AI
models that you can leverage in your
applications on Google Cloud. Generative AI Studio helps
developers create and deploy generative AI
models by providing a variety of tools
and resources that make it easy to get started. For example, there's a
library of pre-trained models, a tool for fine tuning models,
a tool for deploying models to production, and a
community forum for developers to share ideas and collaborate. Generative AI App
Builder lets you create Gen AI apps without
having to write any code. Gen AI App Builder has a
drag-and-drop interface that makes it easy
to design and build apps, a visual editor that
makes it easy to create and edit app content, a built-in search
engine that allows users to search for information
within the app, and a conversational
AI engine that allows users to interact with
the app using natural language. You can create your own chat
bots, digital assistants, custom search engines, knowledge
bases, training applications, and more. PaLM API lets you
test and experiment with Google's large language
models and Gen AI tools. To make prototyping quick
and more accessible, developers can integrate
PaLM API with Maker Suite and use it to access the
API using a graphical user interface. The suite includes a
number of different tools such as a model-training
tool, a model-deployment tool, and a model-monitoring tool. The model-training tool helps
developers train ML models on their data using
different algorithms. The model deployment tool helps
developers deploy ML models to production with a number of
different deployment options. And the model-monitoring
tool helps developers monitor the
performance of their ML models in production using a
dashboard and a number of different metrics. That's all for now. Thanks for watching this course,
Introduction to Large Language Models.
