Exam domain 2.1, 'Explain foundation models (LLMs, LMMs) and their capabilities,' is the bedrock of the Generative AI Professional exam. This concept solves the huge problem of having to build an AI from scratch every time you want a new application, which would be impossibly expensive and slow. For your 1Z0-1127 exam, understanding what a foundation model is and how Large Language Models (LLMs) and Large Multimodal Models (LMMs) work is the single most important prerequisite for everything else you will learn.
Jump to a section
A simple way to picture Foundation Models and Large Language Models
A master chef at a busy restaurant doesn't start from scratch for every dish. They have a thick, well-tested recipe book that took years to develop. This book contains the fundamental methods for making stocks, sauces, doughs, and basic preparations. For a beginner cook, this book is a godsend. Instead of needing to know the chemistry of why you brown meat before braising, or the history of how to make a perfect roux, the cook can just open the book and follow the instructions for 'brown the beef' or 'make a velouté sauce.' The book encodes all that complex knowledge into simple, repeatable steps.
A Foundation Model in AI is exactly that master chef's recipe book. It's a giant, pre-trained neural network that has learned patterns, grammar, facts, and reasoning from an enormous amount of text or images. You don't need to have trained it yourself, and you don't need to understand all the underlying neural maths. You just 'read' its knowledge by giving it a prompt (like a recipe name). The Large Language Model (LLM) is a specific type of this recipe book, ultra-specialised in text. When you give it the prompt 'Write a poem about a cat,' it's like asking the chef to 'make a chicken stock' – the foundational knowledge is there from the recipe book, and the model uses that to produce a high-quality result. It replaces the need to build an AI brain from nothing. The 'fine-tuning' is like the sous chef adapting the master's recipe for a specific customer's allergy.
At its heart, a Foundation Model is a single, massive AI model that has been trained on an incredibly broad dataset so it can be adapted to a wide range of downstream tasks. Think of it as the 'foundation' or the base layer on which you build specialised applications. Before these models existed, you had to train a separate AI model for every single job. If you wanted a model that could write emails, you trained one. If you wanted a model to analyse legal documents, you trained a different one. This was expensive, time-consuming, and required enormous amounts of labelled data.
The key breakthrough was the concept of 'pre-training' a model on a huge, unlabelled corpus of data from the internet – books, articles, code, and more. This process, which costs millions of dollars and takes weeks or months, teaches the model the underlying patterns of language, grammar, world facts, and reasoning. The resulting model, the Foundation Model, is not yet good at any specific task, but it has a very broad and deep 'understanding' of the world.
A Large Language Model (LLM) is a specific type of Foundation Model that specialises in text or code. The most famous examples are GPT-4, Claude, Gemini, and Llama 2. They are called 'large' because they have billions of parameters – the adjustable weights inside the neural network that encode its knowledge. Their primary input and output is text. When you ask an LLM a question, it doesn't 'know' the answer like a database does. Instead, it uses the patterns it learned during training to generate the most likely sequence of words that form a coherent and relevant response. It is a sophisticated text generator.
A Large Multimodal Model (LMM) takes this one step further. It is a Foundation Model that can process and generate not just text, but also images, audio, and video. Think of it as an LLM that has been given 'eyes' and 'ears.' An LMM like GPT-4V can look at a photograph, understand what's happening in it, and describe it in words. Or it could listen to a song and write lyrics that fit the melody. This is a significant step towards more general artificial intelligence because it can handle multiple types of data simultaneously, just like humans do.
Why do these models exist? They exist to replace the expensive, specialised model-building approach of the past. Instead of building a hundred different models, an organisation can take one Foundation Model and 'fine-tune' it. Fine-tuning is a much smaller, cheaper training process where you take the pre-trained model and give it a smaller, specialised dataset to make it excellent at one task. For example, a hospital could take an LLM fine-tuned on medical journals to create a model that helps doctors review patient notes. This is much faster and cheaper than training a medical AI from the ground up.
For the 1Z0-1127 exam, you need to know these core capabilities of foundation models:
Text generation and summarisation: producing articles, stories, or summaries of long documents.
Code generation and explanation: writing software code or explaining what a piece of code does.
Translation: translating between languages.
Question answering: providing factual answers based on the training data (though be careful of 'hallucinations' – making up plausible but false facts).
Sentiment analysis: determining the emotional tone of a piece of text.
Image understanding and generation (in LMMs): describing or creating visual content.
The magic of an LLM lies in its 'attention mechanism,' which allows it to weigh the importance of different words in a sentence when predicting the next word. This is how it keeps track of context over long passages. The training process uses 'transformer architecture,' a type of neural network layer that is exceptionally good at finding relationships between data points, no matter how far apart they are in the sequence.
Pre-training (The Foundation Phase)
The model is trained on a massive, unlabelled dataset (e.g., all of Wikipedia, books, and the internet). This is called 'unsupervised learning'. The model learns patterns of language, grammar, and facts. This phase is extremely expensive (millions of dollars) and is done by companies like Google, Meta, and OpenAI.
Architecture Selection (The Transformer)
All modern Foundation Models use the 'Transformer' neural network architecture. This is the key technology that allows the model to handle long sequences of text effectively using an 'attention mechanism', which decides which words in a sentence are most important for understanding the meaning.
Fine-tuning (The Specialisation Phase)
An organisation takes the pre-trained Foundation Model and trains it further on a smaller, labelled dataset specific to their task (e.g., legal documents, medical records). This is 'supervised learning'. It is much cheaper than pre-training and makes the model highly accurate for that one domain.
Prompt Engineering and Inference (The Usage Phase)
Instead of fine-tuning, a user can simply give the model a carefully crafted prompt (the 'instruction') to get a desired output. For example: 'Summarise this 10-page document in three bullet points.' The model processes the prompt and generates the output. This is called 'inference'.
Deployment and Monitoring (The Operational Phase)
The fine-tuned or prompted model is deployed as an API service (e.g., on OCI's Generative AI service). IT professionals monitor its performance, watch for 'hallucinations' or 'model drift' (degrading output quality over time), and manage the data pipeline for continuous improvement.
An IT professional working for a large insurance company is tasked with automating the process of answering customer queries from emails. Let's call her Priya. Six years ago, Priya would have had to do this: she would collect thousands of historical email-response pairs. She would then hire a team of data scientists to build and train a custom natural language processing (NLP) model from scratch. This project would take nine months, cost hundreds of thousands of dollars, and the resulting model would only be good for understanding insurance claim emails. If the company later wanted a model to write marketing copy, they would have to start the whole process over again.
Today, with Foundation Models, Priya does this:
Step 1: she selects a pre-trained LLM from Oracle Cloud Infrastructure's (OCI) Generative AI service, like one of the Cohere models or Llama 2. She doesn't need to build anything from scratch.
Step 2: she takes the LLM and feeds it a small, curated set of about 50 to 100 examples of excellent customer service emails. This is called 'few-shot learning' or 'prompt engineering.' She is teaching the model the *format and tone* of a good response without re-training the whole model.
Step 3: she deploys this fine-tuned model as an API endpoint in OCI. She writes a simple application that reads incoming customer emails, sends them to the model via an API call, and the model generates a draft response.
Step 4: a human customer service agent reviews the drafts and sends them. Over time, the agent's corrections are logged.
Step 5: Priya uses this feedback data to do a formal 'supervised fine-tuning' step, creating an even more accurate model specific to insurance claims.
What has Priya built? She has built an AI-powered assistant in weeks, not months, using a Foundation Model as her starting point. She avoided the enormous upfront cost of training a model. If the company's marketing team later asks for a model to write blog posts, they can take the same original Foundation Model and fine-tune it on marketing content, because the base model already knows how to write, it just needs to learn the specific domain.
On a daily basis, the IT professional now manages the OCI Generative AI service: they monitor API usage, check for model drift (when the model's performance degrades over time), manage the fine-tuning datasets, and ensure the data is kept secure and compliant. They might also use OCI's 'Model Garden' feature to compare the performance of different base models (like Llama 2 vs. Generative AI multilingual) before choosing which one to deploy for a specific workload.
The 1Z0-1127 exam tests Foundation Models in a very specific way. You are not expected to know the mathematics of the transformer architecture. What you must know is the *practical and conceptual* landscape. The exam loves to test your ability to distinguish between the key concepts and to understand how OCI's services fit into the picture.
Here are the exact concepts they test with high frequency:
The definition of a Foundation Model: you must know it is a pre-trained, large-scale AI model that can be adapted to many downstream tasks. Do not confuse it with a model that is built from scratch for one specific task. The exam will present scenarios where you have to choose between using a foundation model vs. building a custom model.
Differentiating between LLM and LMM: the exam will ask you what an LLM can and cannot do. An LLM cannot directly process images unless it is an LMM. Traps include suggesting an LLM can 'see' a picture. Always pick the answer that says an LMM is required for multimodal input.
The concept of 'fine-tuning': this is their favourite word. They will test the difference between 'prompt engineering' (giving instructions in the prompt) and 'fine-tuning' (re-training the model on a small, specific dataset). They love asking which approach is suitable for a given scenario. Fine-tuning is for deep, domain-specific learning. Prompt engineering is for quick, light adaptation.
The 'base model' vs. the 'fine-tuned model': the exam will ask which one retains more general knowledge (the base model) and which one is more specialised (the fine-tuned model).
Hallucination: they will test that a limitation of LLMs is that they can generate confident-sounding but false information. The correct solution is not to trust the model blindly but to implement 'grounding' (connecting the model to real, verifiable data sources like a database).
OCI Generative AI Service specifics: you must know that OCI offers both 'hosted models' (like Cohere Command and Llama) and 'custom models' (where you provide your own model). They test which service is used for fine-tuning (the 'Generative AI Agent' service is for building agents, while 'Generative AI' is for using and fine-tuning models).
The 'context window' of an LLM: this is the maximum amount of text (tokens) the model can consider at one time. They test that a larger context window is better for lengthy documents but more expensive.
The biggest trap in the exam is the 'one-size-fits-all' trap. A question might describe a need to translate documents into 10 languages and ask for a solution. The wrong answer suggests training a new model from scratch for each language. The correct answer is using a single pre-trained Foundation Model because it already understands multiple languages from its training data. Always look for the option that leverages the *pre-trained* nature of the model.
They also love to test the 'if you can Google it, you don't need to build it' principle. If the question asks for a solution to generate text, the answer is almost never 'train a new model' – it is always 'use an existing foundation model and fine-tune or prompt engineer it.'
A Foundation Model is a pre-trained, large-scale AI model that can be adapted to many different downstream tasks, saving the cost of training from scratch.
A Large Language Model (LLM) is a type of Foundation Model that specialises in generating and understanding text and code.
A Large Multimodal Model (LMM) is a Foundation Model that can process and generate multiple types of data, including text, images, audio, and video.
Fine-tuning is the process of taking a pre-trained Foundation Model and further training it on a small, specific dataset to make it excellent at one task.
LLMs do not store facts; they predict the most probable next word in a sequence, which is why they can sometimes produce confident-sounding falsehoods called 'hallucinations'.
On OCI, you can use the Generative AI service to access hosted Foundation Models (like Cohere Command and Llama 2) or deploy and fine-tune your own custom models.
These come up on the exam all the time. Here's how to tell them apart.
Foundation Model (Generalist)
Trained on a massive, general dataset from the internet.
Broadly capable across many tasks (writing, coding, translation).
Used as a starting point; not yet optimised for any single job.
Fine-Tuned Model (Specialist)
Trained further on a small, domain-specific dataset (e.g., legal documents).
Narrowly expert in one task (e.g., drafting legal contracts).
Optimised for high accuracy in its specific domain.
Large Language Model (LLM)
Only processes and generates text and code.
Cannot see images or listen to audio.
Examples: GPT-4 (text mode), Llama 2, Cohere Command.
Large Multimodal Model (LMM)
Processes and generates text, images, audio, and video.
Can describe a photo, generate an image from text, or transcribe spoken words.
Examples: GPT-4V, Gemini, Claude with vision.
Prompt Engineering
No model re-training is required.
You give the model instructions within the prompt itself.
Quick to implement and cheap; good for one-off or simple tasks.
Fine-Tuning
Requires a training step on a small, labelled dataset.
Permanently changes the model's internal weights for a specific task.
Takes more time and compute; good for deep, repeated, specific tasks.
Mistake
A Large Language Model (LLM) is a database that contains all the facts in the world and looks up the answer.
Correct
An LLM is a probability engine. It does not store facts. It generates the most likely sequence of words based on patterns it learned during training. It can 'hallucinate' and give a perfectly grammatical but completely false answer.
This is common because interacting with an LLM feels like asking a knowledgeable person a question. Our brains automatically assume it's 'retrieving' the answer, when in reality it's 'creating' the answer word by word.
Mistake
If an LLM is bad at a specific task, I need to train a completely new AI model from scratch.
Correct
You almost never need to train from scratch. You can take an existing Foundation Model (like Llama 2) and 'fine-tune' it on a small, specialised dataset. This is much cheaper and faster than pre-training a new model.
This misconception comes from the pre-AI era where every model was purpose-built from the ground up. The revolutionary idea of a reusable foundation model is still not intuitive to beginners.
Mistake
A Large Multimodal Model (LMM) is just a bigger Large Language Model (LLM) with more parameters.
Correct
An LMM is architecturally different. It has additional neural networks (often called 'encoders') that can process images, audio, and video, not just text. It is a distinct class of model.
The naming is confusing. 'Large Language Model' and 'Large Multimodal Model' sound like they are on a scale (big and bigger). In reality, they are different architectures for different input types.
Mistake
Foundation Models are always the best choice for every AI task because they are so powerful.
Correct
Foundation Models are excellent for general tasks and tasks with unstructured data, but for simple, deterministic tasks (like 'find the cheapest flight'), a small, rules-based script or a traditional machine learning model is cheaper, faster, and more reliable.
The hype around LLMs makes people think they solve everything. The exam tests that you know when *not* to use a Foundation Model – specifically, when a simple lookup or a lightweight algorithm will do the job with less cost and latency.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
A Foundation Model is the broad category of any large, pre-trained AI model that can be adapted to many tasks. A Large Language Model (LLM) is a specific type of Foundation Model that specialises in processing and generating text. So, every LLM is a Foundation Model, but not every Foundation Model is an LLM (some are multimodal).
The LLM doesn't 'know' facts like a database. It learns statistical relationships between words during training. When you ask 'What is the capital of France?', it has seen the phrase 'Paris is the capital of France' so many times that, given the prompt, 'Paris' is the most statistically likely word to appear next.
Fine-tuning is taking a pre-trained Foundation Model and training it a little bit more on a specialised dataset. It is better than training from scratch because it costs a fraction of the price and requires much less data and compute power. You are building on the model's existing knowledge, not re-teaching it everything.
Not a standard LLM. A standard LLM can only process text. To analyse an image, you need a Large Multimodal Model (LMM) which has been trained on both text and image data. Services like GPT-4V or Gemini are examples of LMMs.
A hallucination is when an LLM generates a piece of text that is fluent, grammatically correct, and sounds confident, but is factually wrong or made up. It is a key limitation of these models and is why critical applications often need to 'ground' the model by connecting it to a real database or search engine.
Oracle's main service is the 'OCI Generative AI' service. It provides access to a variety of pre-trained Foundation Models (like Cohere Command and Meta's Llama 2) and offers tools for fine-tuning them and deploying them as managed API endpoints.
You've finished Foundation Models and Large Language Models. Continue through the 1Z0-1127 study guide to build a complete picture of the exam.
Done with this chapter?