21 Lessons -- Get Started Building with Generative AI. A comprehensive course by Microsoft Cloud Advocates covering everything from GenAI fundamentals to building production applications with LLMs, RAG, agents, and fine-tuning.

Introduction

This lesson will cover:

Introduction to the business scenario: our startup idea and mission.
业务场景介绍：我们的创业想法和使命。
Generative AI and how we landed on the current technology landscape.
生成式人工智能以及我们如何涉足当前的技术领域。
Inner working of a large language model.
大型语言模型的内部工作原理。
Main capabilities and practical use cases of Large Language Models.
大型语言模型的主要功能和实际用例。

Learning Goals

What generative AI is and how Large Language Models work.
什么是生成式人工智能以及大型语言模型是如何工作的。
How you can leverage large language models for different use cases, with a focus on education scenarios.
如何针对不同的用例利用大型语言模型，重点关注教育场景。

Tokenizer, text to numbers: Large Language Models receive a text as input and generate a text as output. However, being statistical models, they work much better with numbers than text sequences. That’s why every input to the model is processed by a tokenizer, before being used by the core model. A token is a chunk of text – consisting of a variable number of characters, so the tokenizer's main task is splitting the input into an array of tokens. Then, each token is mapped with a token index, which is the integer encoding of the original text chunk.
分词器，文本到数字：大型语言模型接收文本作为输入，并生成文本作为输出。然而，由于是统计模型，它们在处理数字方面比文本序列更有效。这就是为什么模型的每个输入在被核心模型使用之前，都会被分词器 (tokenizer) 处理。token 是文本的块——由可变数量的字符组成，因此分词器的主要任务是将输入拆分为 token 数组。然后，每个 token 都映射到 token 索引，该索引是原始文本块的整数编码。

Predicting output tokens: Given n tokens as input (with max n varying from one model to another), the model is able to predict one token as output. This token is then incorporated into the input of the next iteration, in an expanding window pattern, enabling a better user experience of getting one (or multiple) sentence as an answer. This explains why, if you ever played with ChatGPT, you might have noticed that sometimes it looks like it stops in the middle of a sentence.

预测输出 token：给定 n 个 token 作为输入（最大 n 值因模型而异），模型能够预测一个 token 作为输出。然后，这个 token 被合并到下一个迭代的输入中，以扩展窗口模式，从而使用户获得更好的体验，即获得一个（或多个）句子作为答案。这就解释了为什么，如果你曾经玩过 ChatGPT，你可能会注意到它有时看起来会在句子中间停止。

Selection process, probability distribution: The output token is chosen by the model according to its probability of occurring after the current text sequence. This is because the model predicts a probability distribution over all possible ‘next tokens’, calculated based on its training. However, not always is the token with the highest probability chosen from the resulting distribution. A degree of randomness is added to this choice, in a way that the model acts in a non-deterministic fashion - we do not get the exact same output for the same input. This degree of randomness is added to simulate the process of creative thinking and it can be tuned using a model parameter called temperature.

选择过程，概率分布：输出 token 由模型根据其在当前文本序列之后出现的概率来选择。这是因为模型预测了所有可能的“下一个 token”的概率分布，该分布是基于其训练计算得出的。然而，并非总是从结果分布中选择概率最高的 token。在这种选择中增加了一定程度的随机性，使得模型的行为以非确定性的方式进行——对于相同的输入，我们不会得到完全相同的输出。这种随机性是为了模拟创造性思维的过程而添加的，可以使用称为温度 (temperature) 的模型参数进行调整。

An instruction specifying the type of output we expect from the model. This instruction sometimes might embed some examples or some additional data.

1. Summarization of an article, book, product reviews and more, along with extraction of insights from unstructured data.
一条指令，指定我们期望模型输出的类型。这条指令有时可能嵌入一些例子或一些额外的数据。 文章、书籍、产品评论等的摘要，以及从非结构化数据中提取见解。

Creative ideation and design of an article, an essay, an assignment or more.

文章、论文、作业等的创意构思和设计。

A question, asked in the form of a conversation with an agent.

以与代理对话的形式提出的问题。

A chunk of text to complete, which implicitly is an ask for writing assistance.

一段要完成的文本，隐含地要求写作帮助。

A chunk of code together with the ask of explaining and documenting it, or a comment asking to generate a piece of code performing a specific task.

一段代码，并要求对其进行解释和文档记录，或者一个要求生成一段执行特定任务的代码的注释。

Assignment

Knowledge check

You get the exact same response every time.
每次都会得到完全相同的回复。
It does things perfectly, great at adding numbers, produce working code etc.
它可以完美地完成任务，擅长加数字，生成可用的代码等。
The response may vary despite using the same prompt. It's also great at giving you a first draft of something, be it text or code. But you need to improve on the results.
尽管使用相同的提示 (prompt)，响应也可能有所不同。它也很擅长为你提供某件事的初稿，无论是文本还是代码。但是你需要改进结果。

Great Work! Continue the Journey

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Introduction

This lesson will cover:

Different types of LLMs in the current landscape.
当前格局中不同类型的大型语言模型 (LLM)。
Testing, iterating, and comparing different models for your use case in Azure.
在 Azure 中测试、迭代和比较适用于你的用例的不同模型。
How to deploy an LLM.
如何部署大型语言模型 (LLM)。

Learning Goals

After completing this lesson, you will be able to:

Select the right model for your use case.
为你的用例选择合适的模型。
Understand how to test, iterate, and improve the performance of your model.
了解如何测试、迭代和提高模型的性能。
Know how businesses deploy models.
了解企业如何部署模型。

Audio and speech recognition. For this purpose, Whisper-type models are a great choice as they're general-purpose and aimed at speech recognition. It's trained on diverse audio and can perform multilingual speech recognition. Learn more about Whisper type models here.

音频和语音识别。为此，Whisper 型号是一个不错的选择，因为它们是通用的，并且旨在用于语音识别。它经过各种音频的训练，可以执行多语言语音识别。在此处了解有关 Whisper 型号的更多信息。

Image generation. For image generation, DALL-E and Midjourney are two very well-known choices. DALL-E is offered by Azure OpenAI. Read more about DALL-E here and also in Chapter 9 of this curriculum.

图像生成。对于图像生成，DALL-E 和 Midjourney 是两个非常著名的选择。DALL-E 由 Azure OpenAI 提供。在此处以及本课程的第 9 章中阅读有关 DALL-E 的更多信息。

Text generation. Most models are trained on text generation and you have a large variety of choices from GPT-3.5 to GPT-4. They come at different costs with GPT-4 being the most expensive. It's worth looking into the Azure OpenAI playground to evaluate which models best fit your needs in terms of capability and cost.

文本生成。大多数模型都经过文本生成训练，您可以从 GPT-3.5 到 GPT-4 中进行多种选择。它们的成本各不相同，其中 GPT-4 最昂贵。值得研究一下 Azure OpenAI playground，以评估哪些模型在功能和成本方面最适合您的需求。

Multi-modality. If you're looking to handle multiple types of data in input and output, you might want to look into models like gpt-4 turbo with vision or gpt-4o - the latest releases of OpenAI models - which are capable to combine natural language processing to visual understanding, enabling interactions through multi-modal interfaces.

多模态。如果您希望处理输入和输出中的多种类型的数据，您可能需要研究像 gpt-4 turbo with vision 或 gpt-4o 这样的模型——OpenAI 模型的最新版本——它们能够将自然语言处理与视觉理解相结合，从而可以通过多模态界面进行交互。

They are trained using unsupervised learning or self-supervised learning, meaning they are trained on unlabeled multi-modal data, and they do not require human annotation or labeling of data for their training process.
它们使用无监督学习或自监督学习进行训练，这意味着它们在未标记的多模态数据上进行训练，并且它们的训练过程不需要人工注释或数据标记。
They are very large models, based on very deep neural networks trained on billions of parameters.
它们是非常大的模型，基于在数十亿个参数上训练的非常深的神经网络。
They are normally intended to serve as a ‘foundation’ for other models, meaning they can be used as a starting point for other models to be built on top of, which can be done by fine-tuning.
它们通常旨在用作其他模型的“基础”，这意味着它们可以用作构建其他模型的基础，这可以通过微调 (fine-tuning) 来完成。

Find the Foundation Model of interest in the catalog - either proprietary or open source, filtering by task, license, or name. To improve searchability, the models are organized into collections, like Azure OpenAI collection, Hugging Face collection, and more.
在目录中查找感兴趣的基础模型 (Foundation Model)——无论是专有的还是开源的，按任务、许可证或名称进行过滤。为了提高可搜索性，这些模型被组织成集合，例如 Azure OpenAI 集合、Hugging Face 集合等。

Review the model card, including a detailed description of intended use and training data, code samples and evaluation results on the internal evaluations library.
查看模型卡，其中包括对预期用途和训练数据的详细描述、代码示例以及内部评估库中的评估结果。

Compare benchmarks across models and datasets available in the industry to assess which one meets the business scenario, through the Model Benchmarks pane.
比较行业内模型和数据集之间的基准，通过模型基准 (Model Benchmarks) 窗格评估哪个模型满足业务场景。

Fine-tune the model on custom training data to improve model performance in a specific workload, leveraging the experimentation and tracking capabilities of Azure AI Studio.
在自定义训练数据上微调模型 (fine-tune)，利用 Azure AI Studio 的实验和跟踪功能，提高模型在特定工作负载中的性能。

Deploy the original pre-trained model or the fine-tuned version to a remote real time inference - managed compute - or serverless api endpoint - pay-as-you-go - to enable applications to consume it.
将原始预训练模型 (pre-trained model) 或微调版本 (fine-tuned version) 部署到远程实时推理 (remote real time inference)——托管计算 (managed compute)——或无服务器 API 终结点 (serverless API endpoint)——按需付费 (pay-as-you-go)——以使应用程序能够使用它。

Prompt engineering with context. The idea is to provide enough context when you prompt to ensure you get the responses you need.

带有上下文的提示工程 (Prompt engineering with context)。其思想是在您进行提示时提供足够的上下文，以确保您获得所需的响应。

Retrieval Augmented Generation, RAG. Your data might exist in a database or web endpoint for example, to ensure this data, or a subset of it, is included at the time of prompting, you can fetch the relevant data and make that part of the user's prompt.

检索增强生成 (Retrieval Augmented Generation, RAG)。例如，您的数据可能存在于数据库或Web端点中，为了确保在提示时包含这些数据或其子集，您可以获取相关数据，并使其成为用户提示的一部分。

Fine-tuned model. Here, you trained the model further on your own data which led to the model being more exact and responsive to your needs but might be costly.

微调模型 (Fine-tuned model)。在这里，您使用自己的数据进一步训练模型，这使得模型更加精确并能够响应您的需求，但可能成本较高。

Using fine-tuned models. A business would like to use fine-tuned less capable models (like embedding models) rather than high performance models, resulting in a more cost effective and fast solution.

使用微调模型。企业希望使用微调的、能力较弱的模型（如嵌入模型）而不是高性能模型，从而获得更具成本效益和快速的解决方案。

Considering latency. Latency is important for a specific use-case, so it’s not possible to use very long prompts or the number of examples that should be learned from the model doesn’t fit with the prompt length limit.

考虑延迟。延迟对于特定用例非常重要，因此无法使用非常长的提示，或者应该从模型中学习的示例数量不符合提示长度限制。

Staying up to date. A business has a lot of high-quality data and ground truth labels and the resources required to maintain this data up to date over time.

保持最新。企业拥有大量高质量的数据和基本事实标签，以及随着时间的推移维护此数据更新所需的资源。

Knowledge check

Prompt engineering with context
带有上下文的提示工程 (Prompt engineering with context)
1. RAG
Fine-tuned model
微调模型 (Fine-tuned model)

🚀 Challenge

Great Work, Continue Your Learning

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Introduction

This lesson will cover:

Why you should prioritize Responsible AI when building Generative AI applications.
为什么在构建生成式AI应用程序时应优先考虑负责任的AI。
Core principles of Responsible AI and how they relate to Generative AI.
负责任的AI的核心原则以及它们与生成式AI的关系。
How to put these Responsible AI principles into practice through strategy and tooling.
如何通过策略和工具将这些负责任的AI原则付诸实践。

Learning Goals

The importance of Responsible AI when building Generative AI applications.
在构建生成式AI应用程序时负责任的AI的重要性。
When to think and apply the core principles of Responsible AI when building Generative AI applications.
在构建生成式人工智能应用时，何时思考和应用负责任人工智能（Responsible AI）的核心原则。
What tools and strategies are available to you to put the concept of Responsible AI into practice.
有哪些工具和策略可供你将负责任人工智能（Responsible AI）的概念付诸实践。

Providing instructions or encouraging self-harm or harm to certain groups.
提供指示或鼓励自我伤害或伤害某些群体。
Hateful or demeaning content.
具有仇恨或贬低意味的内容。
Guiding the planning of any type of attack or violent acts.
指导策划任何类型的攻击或暴力行为。
Providing instructions on how to find illegal content or commit illegal acts.
提供有关如何查找非法内容或实施非法行为的指示。
Displaying sexually explicit content.
显示露骨的性内容。

Model. Choosing the right model for the right use case. Larger and more complex models like GPT-4 can cause more of a risk of harmful content when applied to smaller and more specific use cases. Using your training data to fine-tune also reduces the risk of harmful content.

模型（Model）。为正确的用例选择正确的模型。像GPT-4这样更大、更复杂的模型，当应用于更小、更具体的用例时，可能会导致更多有害内容的风险。使用您的训练数据进行微调（fine-tune）也可以降低有害内容的风险。

Safety System. A safety system is a set of tools and configurations on the platform serving the model that help mitigate harm. An example of this is the content filtering system on the Azure OpenAI service. Systems should also detect jailbreak attacks and unwanted activity like requests from bots.

安全系统（Safety System）。安全系统（Safety System）是在提供模型的平台上的一组工具和配置，有助于减轻危害。这方面的一个例子是Azure OpenAI服务上的内容过滤系统。系统还应检测越狱攻击和不需要的活动，例如来自机器人的请求。

Metaprompt. Metaprompts and grounding are ways we can direct or limit the model based on certain behaviors and information. This could be using system inputs to define certain limits of the model. In addition, providing outputs that are more relevant to the scope or domain of the system.

元提示（Metaprompt）。元提示（Metaprompts）和基础（grounding）是我们根据某些行为和信息来指导或限制模型的方式。这可能是使用系统输入来定义模型的某些限制。此外，提供与系统的范围或领域更相关的输出。

User Experience. The final layer is where the user interacts directly with the model through our application’s interface in some way. In this way we can design the UI/UX to limit the user on the types of inputs they can send to the model as well as text or images displayed to the user. When deploying the AI application, we also must be transparent about what our Generative AI application can and can’t do.
用户体验（User Experience）。最后一层是用户通过我们的应用程序界面以某种方式直接与模型交互的地方。这样，我们可以设计UI/UX来限制用户可以发送给模型的输入类型，以及向用户显示的文本或图像。在部署人工智能应用程序时，我们还必须透明地说明我们的生成式人工智能应用程序可以做什么和不能做什么。

Evaluate model. Working with LLMs can be challenging because we don’t always have control over the data the model was trained on. Regardless, we should always evaluate the model’s performance and outputs. It’s still important to measure the model’s accuracy, similarity, groundedness, and relevance of the output. This helps provide transparency and trust to stakeholders and users.
评估模型。使用大型语言模型 (LLMs) 可能具有挑战性，因为我们并不总是能控制模型训练所用的数据。无论如何，我们都应该始终评估模型的性能和输出。衡量模型的准确性 (accuracy)、相似性 (similarity)、可靠性 (groundedness) 和输出的相关性 (relevance) 仍然非常重要。这有助于提高对利益相关者和用户的透明度和信任度。

Tools

Knowledge check

That the answer is correct.
答案正确。
Harmful usage, that AI isn't used for criminal purposes.
避免有害使用，确保 AI 不被用于犯罪目的。
Ensuring the AI is free from bias and discrimination.
确保 AI 没有偏见和歧视。

🚀 Challenge

Great Work, Continue Your Learning

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Introduction

Learning Goals

Explain what prompt engineering is and why it matters.
解释什么是提示工程，以及为什么它很重要。
Describe the components of a prompt and how they are used.
描述提示的组成部分以及它们是如何使用的。
Learn best practices and techniques for prompt engineering.
学习提示工程的最佳实践和技巧。
Apply learned techniques to real examples, using an OpenAI endpoint.
使用 OpenAI 端点将学到的技术应用于实际示例。

An Azure OpenAI API key - the service endpoint for a deployed LLM.
一个 Azure OpenAI API 密钥——已部署大型语言模型 (LLM) 的服务端点。
A Python Runtime - in which the Notebook can be executed.
一个 Python 运行时——Notebook 可以在其中执行。
Local Env Variables - complete the SETUP steps now to get ready.
本地环境变量——立即完成设置步骤以做好准备。

Illustrated Guide

Administrators might ask the AI to analyze curriculum data to identify gaps in coverage. The AI can summarize results or visualize them with code.
管理员可能会要求人工智能分析课程数据，以识别覆盖范围的差距。人工智能可以总结结果或用代码将其可视化。
Educators might ask the AI to generate a lesson plan for a target audience and topic. The AI can build the personalized plan in a specified format.
教育工作者可能会要求人工智能为目标受众和主题生成一份课程计划。人工智能可以用指定的格式构建个性化的计划。
Students might ask the AI to tutor them in a difficult subject. The AI can now guide students with lessons, hints & examples tailored to their level.
学生可能会要求人工智能辅导他们学习一门困难的学科。人工智能现在可以用根据学生水平量身定制的课程、提示（hints）和例子来指导学生。

designing the initial prompt for a given model and objective
为给定的模型和目标设计初始提示（prompt）
refining the prompt iteratively to improve the quality of the response
迭代地完善提示（prompt）以提高响应的质量

Tokenization = how the model "sees" the prompt
令牌化 (Tokenization) = 模型如何“看待”提示（prompt）
Base LLMs = how the foundation model "processes" a prompt
基础大型语言模型 (Base LLMs) = 基础模型如何“处理”提示（prompt）
Instruction-Tuned LLMs = how the model can now see "tasks"
指令调整大型语言模型 (Instruction-Tuned LLMs) = 模型现在如何看待“任务”

Model responses are stochastic. The same prompt will likely produce different responses with different models or model versions. And it may even produce different results with the same model at different times. Prompt engineering techniques can help us minimize these variations by providing better guardrails.

模型响应是随机的。相同的提示（prompt）可能会使用不同的模型或模型版本产生不同的响应。甚至可能在不同时间使用相同的模型产生不同的结果。提示工程 (Prompt engineering) 技术可以通过提供更好的防护措施来帮助我们最大限度地减少这些变化。

Models can fabricate responses. Models are pre-trained with large but finite datasets, meaning they lack knowledge about concepts outside that training scope. As a result, they can produce completions that are inaccurate, imaginary, or directly contradictory to known facts. Prompt engineering techniques help users identify and mitigate such fabrications e.g., by asking AI for citations or reasoning.

模型可以捏造响应。模型使用庞大但有限的数据集进行预训练，这意味着它们缺乏对该训练范围之外的概念的了解。因此，它们可能会产生不准确、虚构或直接与已知事实相矛盾的补全 (completions)。提示工程 (Prompt engineering) 技术可帮助用户识别和减轻此类捏造，例如，通过要求人工智能提供引文或推理。

Models capabilities will vary. Newer models or model generations will have richer capabilities but also bring unique quirks and tradeoffs in cost & complexity. Prompt engineering can help us develop best practices and workflows that abstract away differences and adapt to model-specific requirements in scalable, seamless ways.

模型功能会有所不同。较新的模型或模型世代将具有更丰富的功能，但也带来了成本和复杂性方面的独特怪癖和权衡。提示工程 (Prompt engineering) 可以帮助我们开发最佳实践和工作流程，从而以可扩展、无缝的方式抽象差异并适应特定于模型的需求。

Use the same prompt with different LLM deployments (e.g, OpenAI, Azure OpenAI, Hugging Face) - did you see the variations?
将相同的提示（prompt）用于不同的 LLM 部署（例如，OpenAI、Azure OpenAI、Hugging Face）——你看到变化了吗？
Use the same prompt repeatedly with the same LLM deployment (e.g., Azure OpenAI playground) - how did these variations differ?
使用相同的 LLM 部署（例如，Azure OpenAI Playground）重复使用相同的提示（prompt）——这些变化有何不同？

May 2023 | GitHub Copilot is Getting Better at Understanding Your Code
2023 年 5 月 | GitHub Copilot 在更好地理解您的代码方面取得了进展
May 2023 | Inside GitHub: Working with the LLMs behind GitHub Copilot.
2023 年 5 月 | 深入了解 GitHub：使用 GitHub Copilot 背后的 LLM。
Jun 2023 | How to write better prompts for GitHub Copilot.
2023 年 6 月 | 如何为 GitHub Copilot 编写更好的提示词。
Jul 2023 | .. GitHub Copilot goes beyond Codex with improved AI model
2023 年 7 月 | .. GitHub Copilot 通过改进的 AI 模型超越了 Codex
Jul 2023 | A Developer's Guide to Prompt Engineering and LLMs
2023 年 7 月 | 开发者提示工程和 LLM 指南
Sep 2023 | How to build an enterprise LLM app: Lessons from GitHub Copilot
2023 年 9 月 | 如何构建企业 LLM 应用程序：来自 GitHub Copilot 的经验教训

Input/output pairs reflecting user input and assistant response.
反映用户输入和助手响应的输入/输出对。
System message setting the context for assistant behavior or personality.
设置助手行为或个性的上下文的系统消息。

response = openai.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Who won the world series in 2020?"},
        {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
        {"role": "user", "content": "Where was it played?"}
    ]
)

an instruction (action)
指令（动作）
relevant content (that influences action)
相关内容（影响动作）

Examples - instead of telling the model what to do with an explicit instruction, give it examples of what to do and let it infer the pattern.
示例 - 不是告诉模型如何使用显式指令，而是给出模型要执行的操作示例，并让它推断模式。
Cues - follow the instruction with a "cue" that primes the completion, guiding the model towards more relevant responses.
提示 - 在指令之后添加一个“提示”，以启动完成，引导模型朝着更相关的响应方向发展。
Templates - these are repeatable 'recipes' for prompts with placeholders (variables) that can be customized with data for specific use cases.
模板 - 这些是具有占位符（变量）的可重复的提示“配方”，可以使用数据针对特定用例进行自定义。

A task description
一項任務描述
A few examples of the desired output
一些期望輸出的範例
The start of a new example (which becomes an implicit task description)
一個新範例的開始（這變成了一個隱含的任務描述）

we can define an instruction to "summarize the course catalog for Fall 2023"
我們可以定義一個指令來“總結 2023 年秋季的課程目錄”
we can use the primary content to provide a few examples of the desired output
我們可以使用主要內容（primary content）來提供一些所需輸出的範例
we can use the secondary content to identify the top 5 "tags" of interest.
我們可以使用次要內容（secondary content）來識別前 5 個感興趣的“標籤”。

Domain Understanding Matters. Response accuracy and relevance is a function of the domain in which that application or user operates. Apply your intuition and domain expertise to customize techniques further. For instance, define domain-specific personalities in your system prompts, or use domain-specific templates in your user prompts. Provide secondary content that reflects domain-specific contexts, or use domain-specific cues and examples to guide the model towards familiar usage patterns.

領域理解很重要（Domain Understanding Matters）。 響應的準確性和相關性是應用程序或用戶所運營的領域的函數。 應用您的直覺和領域專業知識來進一步自定義技術。 例如，在您的系統提示中定義特定於領域的人格，或在您的用戶提示中使用特定於領域的模板。 提供反映特定於領域的上下文的次要內容（secondary content），或使用特定於領域的線索和範例來引導模型朝著熟悉的用法模式發展。

Model Understanding Matters. We know models are stochastic by nature. But model implementations can also vary in terms of the training dataset they use (pre-trained knowledge), the capabilities they provide (e.g., via API or SDK) and the type of content they are optimized for (e.g, code vs. images vs. text). Understand the strengths and limitations of the model you are using, and use that knowledge to prioritize tasks or build customized templates that are optimized for the model's capabilities.

模型理解很重要（Model Understanding Matters）。 我們知道模型本質上是隨機的。 但模型實現也可能在它們使用的訓練數據集（預訓練知識）、它們提供的能力（例如，通過API或SDK）以及它們針對優化的內容類型（例如，代碼與圖像與文本）方面有所不同。 了解您正在使用的模型的優勢和局限性，並利用這些知識來優先處理任務或構建針對模型能力進行優化的自定義模板。

Iteration & Validation Matters. Models are evolving rapidly, and so are the techniques for prompt engineering. As a domain expert, you may have other context or criteria your specific application, that may not apply to the broader community. Use prompt engineering tools & techniques to "jump start" prompt construction, then iterate and validate the results using your own intuition and domain expertise. Record your insights and create a knowledge base (e.g, prompt libraries) that can be used as a new baseline by others, for faster iterations in the future.

迭代與驗證很重要（Iteration & Validation Matters）。 模型正在快速發展，提示詞工程的技術也在快速發展。 作為領域專家，您可能還有其他上下文或標準，這些上下文或標準可能不適用於更廣泛的社區。 使用提示詞工程工具和技術來“快速啟動”提示詞構建，然後使用您自己的直覺和領域專業知識迭代和驗證結果。 記錄您的見解並創建一個知識庫（例如，提示詞庫），其他人可以將其用作新的基準，以便在未來更快地迭代。

Assignment

(Recommended) Launch GitHub Codespaces
（推薦）啟動 GitHub Codespaces
(Alternatively) Clone the repo to your local device and use it with Docker Desktop
（或者）將 repo 克隆到您的本地設備並將其與 Docker Desktop 一起使用
(Alternatively) Open the Notebook with your preferred Notebook runtime environment.
（或者）使用您首選的 Notebook 運行時環境打開 Notebook。

Copy the .env.copy file in repo root to .env and fill in the AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_DEPLOYMENT values. Come back to Learning Sandbox section to learn how.
將 repo 根目錄中的 .env.copy 文件複製到 .env，然後填寫 AZURE_OPENAI_API_KEY、AZURE_OPENAI_ENDPOINT 和 AZURE_OPENAI_DEPLOYMENT 值。 返回到“學習沙盒（Learning Sandbox）”部分以了解如何操作。

Select the runtime kernel. If using options 1 or 2, simply select the default Python 3.10.x kernel provided by the dev container.
選擇運行時內核。 如果使用選項 1 或 2，只需選擇 dev 容器提供的默認 Python 3.10.x 內核。

Knowledge check

Show me an image of red car
向我展示一张红色汽车的图片
Show me an image of red car of make Volvo and model XC90 parked by a cliff with the sun setting
向我展示一张红色汽车的图片，这辆汽车是沃尔沃 (Volvo) 品牌，XC90 型号，停在悬崖边，太阳正在落山
Show me an image of red car of make Volvo and model XC90
向我展示一张红色汽车的图片，这辆汽车是沃尔沃 (Volvo) 品牌，XC90 型号

🚀 Challenge

Great Work! Continue Your Learning

Introduction

Extend your knowledge of prompt engineering by applying different techniques to your prompts.
通过将不同的技术应用于你的提示来扩展你对提示工程 (prompt engineering) 的知识。
Configuring your prompts to vary the output.
配置你的提示以改变输出。

Learning goals

Apply prompt engineering techniques that improve the outcome of your prompts.
应用提示工程 (prompt engineering) 技术来改善你的提示的结果。
Perform prompting that is either varied or deterministic.
执行多样化或确定性的提示。

Context, you specify it should be about "geography".
上下文，你指定它应该关于“地理”。
Limiting the output, you want no more than 10 questions.
限制输出，你想要的提问不超过 10 个。

Big topic, you don't know if it's going to be about countries, capitals, rivers and so on.
主题太大，你不知道它是否会涉及国家、首都、河流等等。
Format, what if you wanted the questions to be formatted in a certain way?
格式，如果你希望问题以某种方式格式化呢？

Zero-shot prompting, this is the most basic form of prompting. It's a single prompt requesting a response from the LLM based solely on its training data.
零样本提示 (Zero-shot prompting)，这是最基本的提示形式。它是一个单独的提示，要求 LLM 仅根据其训练数据做出回应。
Few-shot prompting, this type of prompting guides the LLM by providing 1 or more examples it can rely on to generate its response.
少量样本提示 (Few-shot prompting)，这种类型的提示通过提供 1 个或多个示例来引导 LLM，LLM 可以依赖这些示例来生成其响应。
Chain-of-thought, this type of prompting tells the LLM how to break down a problem into steps.
思维链 (Chain-of-thought)，这种类型的提示告诉 LLM 如何将问题分解为多个步骤。
Generated knowledge, to improve the response of a prompt, you can provide generated facts or knowledge additionally to your prompt.
生成知识 (Generated knowledge)，为了改进提示的响应，您可以额外地向提示提供生成的实际情况或知识。
Least to most, like chain-of-thought, this technique is about breaking down a problem into a series of steps and then ask these steps to be performed in order.
由简入繁 (Least to most)，与思维链类似，这种技术也是关于将问题分解为一系列步骤，然后要求按顺序执行这些步骤。
Self-refine, this technique is about critiquing the LLM's output and then asking it to improve.
自我完善 (Self-refine)，这项技术是关于评价 LLM 的输出，然后要求其改进。
Maieutic prompting. What you want here is to ensure the LLM answer is correct and you ask it to explain various parts of the answer. This is a form of self-refine.
助产式提示 (Maieutic prompting)。你希望确保 LLM 的回答是正确的，并且要求它解释答案的各个部分。这是一种自我完善的形式。

Prompt: "What is Algebra?"
提示：“什么是代数？”
Answer: "Algebra is a branch of mathematics that studies mathematical symbols and the rules for manipulating these symbols."
答案：“代数是数学的一个分支，它研究数学符号以及操作这些符号的规则。”

Prompt: "Write a poem in the style of Shakespeare. Here are a few examples of Shakespearean sonnets.: Sonnet 18: 'Shall I compare thee to a summer's day? Thou art more lovely and more temperate...' Sonnet 116: 'Let me not to the marriage of true minds Admit impediments. Love is not love Which alters when it alteration finds...' Sonnet 132: 'Thine eyes I love, and they, as pitying me, Knowing thy heart torment me with disdain,...' Now, write a sonnet about the beauty of the moon."
提示：“用莎士比亚的风格写一首诗。这里有一些莎士比亚十四行诗的例子： 十四行诗 18：“我能否将你比作一个夏天？你比夏天更可爱，也更温和……” 十四行诗 116：“莫让我把结合真诚的灵魂 认为有必须排除的障碍。爱不是爱 当它看到变迁就转移……” 十四行诗 132：“我爱你的眼睛，它们似乎怜悯我， 知道你的心用轻蔑来折磨我……” 现在，写一首关于月亮之美的十四行诗。”
Answer: "Upon the sky, the moon doth softly gleam, In silv'ry light that casts its gentle grace,..."
答案：“在天空之上，月亮温柔地闪耀， 在银色的光芒中，它投下温柔的恩典……”

- Prompt: "Alice has 5 apples, throws 3 apples, gives 2 to Bob and Bob gives one back, how many apples does Alice have?"
- Answer: 5

Give the LLM a similar example.
给 LLM 一个类似的例子。
Show the calculation, and how to calculate it correctly.
展示计算过程，以及如何正确计算。
Provide the original prompt.
提供原始提示。

Prompt: "Lisa has 7 apples, throws 1 apple, gives 4 apples to Bart and Bart gives one back: 7 -1 = 6 6 -4 = 2 2 +1 = 3
Alice has 5 apples, throws 3 apples, gives 2 to Bob and Bob gives one back, how many apples does Alice have?" Answer: 1
提示：“丽莎有 7 个苹果，扔掉 1 个苹果，给巴特 4 个苹果，巴特还回 1 个苹果： 7 -1 = 6 6 -4 = 2 2 +1 = 3 爱丽丝有 5 个苹果，扔掉 3 个苹果，给鲍勃 2 个，鲍勃还回 1 个，爱丽丝有多少个苹果？” 答案：1

{{company}}: {{company_name}}
{{products}}:
{{products_list}}
Please suggest an insurance given the following budget and requirements:
Budget: {{budget}}
Requirements: {{requirements}}

Insurance company: ACME Insurance
Insurance products (cost per month):
- Car, cheap, 500 USD
- Car, expensive, 1100 USD
- Home, cheap, 600 USD
- Home, expensive, 1200 USD
- Life, cheap, 100 USD

Please suggest an insurance given the following budget and requirements:
Budget: $1000
Requirements: Car, Home, and Life insurance

Given the budget and requirements, we suggest the following insurance package from ACME Insurance:
- Car, cheap, 500 USD
- Home, cheap, 600 USD
- Life, cheap, 100 USD
Total cost: $1,200 USD

Insurance company: ACME Insurance
Insurance products (cost per month):
- type: Car, cheap, cost: 500 USD
- type: Car, expensive, cost: 1100 USD
- type: Home, cheap, cost: 600 USD
- type: Home, expensive, cost: 1200 USD
- type: Life, cheap, cost: 100 USD

Please suggest an insurance given the following budget and requirements:
Budget: $1000 restrict choice to types: Car, Home

Given the budget and requirements, we suggest the Car, Cheap insurance product which costs 500 USD per month.

Collect data
收集数据
Clean data
清理数据
Analyze data
分析数据
Plot data
绘制数据
Present data
呈现数据

Initial prompt asking the LLM to solve a problem
初始提示 (prompt) 要求大型语言模型 (LLM) 解决一个问题
LLM answers
大型语言模型 (LLM) 回答
You critique the answer and ask the AI to improve
你评论答案并要求 AI 改进
LLM answers again, this time considering the critique and suggest solutions it came up with
大型语言模型 (LLM) 再次回答，这次考虑了评论并提出了它想出的解决方案

AI Answer:

import flask
app = Flask(__name__)

@app.route('/products')
def products():
    return 'Products'

@app.route('/customers')
def customers():
    return 'Customers'

Sure, here are three suggestions to improve the code:

Import the correct module: The first line should import Flask instead of flask. The correct import statement should be from flask import Flask.

Add a main function: Add a if __name__ == '__main__': block to the end of the file to run the application when the file is executed.

Use f-strings: Use f-strings to format the return statements in the route functions. For example, return 'Products' can be changed to return f'This is the {request.path} page'.

from flask import Flask, request

app = Flask(__name__)

@app.route('/products')
def products():
    return f'This is the {request.path} page'

@app.route('/customers')
def customers():
    return f'This is the {request.path} page'

if __name__ == '__main__':
    app.run()

Ask the LLM to answer a question
要求大型语言模型 (LLM) 回答一个问题
For each part of the answer, ask the LLM to explain it more in depth.
对于答案的每个部分，要求大型语言模型 (LLM) 更深入地解释它。
If there are inconsistencies, discard the parts that are inconsistent.
如果存在不一致，则丢弃不一致的部分。

1. Identify the risks
1. Identify the stakeholders
1. Identify the resources
1. Identify the actions
1. Identify the communication channels

The risks are the following:

- Loss of life
- Loss of business
- Loss of reputation
- Loss of customers
- Loss of employees

The biggest risk is loss of life because it's the most important thing to protect.

The two biggest risks are loss of life and loss of business.

"Generate code for a Python Web API"

# Import necessary modules
import flask
from flask import request, jsonify

# Create a Flask app
app = flask.Flask(__name__)

# Create a route for the API
@app.route('/api', methods=['GET'])
def api():
    # Get the data from the request
    data = request.args

    # Process the data
    result = process_data(data)

    # Return the result as JSON
    return jsonify(result)

# Function to process the data
def process_data(data):
    # Do something with the data
    result = data + 1

    # Return the result
    return result

# Run the app
if __name__ == '__main__':
    app.run()

#import necessary packages
import flask
from flask import request, jsonify

#create the Flask application
app = flask.Flask(__name__)
app.config["DEBUG"] = True

#create a list of books
books = [
    {'id': 0,
     'title': 'A Fire Upon the Deep',
     'author': 'Vernor Vinge',
     'first_sentence': 'The coldsleep itself was dreamless.',
     'year_published': '1992'},
    {'id': 1,
     'title': 'The Ones Who Walk Away From Omelas',
     'author': 'Ursula K. Le Guin',
     'first_sentence': 'With a clamor of bells that set the swallows soaring, the Festival of Summer came to the city Omelas, bright-towered by the sea.',
     'published': '1973'},
    {'id': 2,
     'title': 'Dhalgren',
     'author': 'Samuel R. Delany',
     'first_sentence': 'to wound the autumnal city.',
     'published': '1975'}
]

#create an endpoint for the API
@app.route('/', methods=['GET'])
def home():
    return '''<h1>Books API</h1>
<p>A prototype API for retrieving books.</p>'''

#create an endpoint to return all books
@app.route('/api/v1/resources/books/all', methods=['GET'])
def api_all():
    return jsonify(books)

#create an endpoint to return a single book
@app.route('/api/v1/resources/books', methods=['GET'])
def api_id():
    #check if an ID was provided as part of the URL
    #if ID is provided, assign it to a variable
    #if no ID is provided, display an error
    if 'id' in request.args:
        id = int(request.args['id'])
    else:
        return "Error: No id field provided. Please specify an id."

    #create an empty list for our results
    results = []

    #loop through the data and match results that fit the requested ID
    #IDs are unique, but other fields might return many results
    for book in books:
        if book['id'] == id:
            results.append(book)

    #use the jsonify function from Flask to convert our list of
    #Python dictionaries to the JSON format
    return jsonify(results)

app.run()

#import necessary libraries
import flask
from flask import request, jsonify

#create an instance of the Flask class
app = flask.Flask(__name__)

#create an endpoint for the API
@app.route('/api/v1/endpoint', methods=['GET'])
def api_endpoint():
    #get the request data
    data = request.get_json()

    #process the data
    result = process_data(data)

    #return the result
    return jsonify(result)

#function to process the data
def process_data(data):
    #process the data
    result = {'result': 'success'}

    #return the result
    return result

#run the Flask app
if __name__ == '__main__':
    app.run()

#import necessary libraries
import flask
from flask import request, jsonify

#create a Flask app
app = flask.Flask(__name__)

#create a route for the API
@app.route('/api', methods=['GET'])
def api_call():
    #get the data from the request
    data = request.get_json()

    #process the data
    result = process_data(data)

    #return the result
    return jsonify(result)

#define the process_data function
def process_data(data):
    #do something with the data
    result = data + 1

    #return the result
    return result

#run the app
if __name__ == '__main__':
    app.run()

# Import necessary libraries
import flask
from flask import request, jsonify

# Create a Flask app
app = flask.Flask(__name__)

# Create a route for the API
@app.route('/api', methods=['GET'])
def api_call():
    # Get the data from the request
    data = request.args

    # Process the data
    result = process_data(data)

    # Return the result
    return jsonify(result)

# Function to process the data
def process_data(data):
    # Do something with the data
    result = data + 1

    # Return the result
    return result

# Run the app
if __name__ == '__main__':
    app.run()

import flask
from flask import request, jsonify

# create the Flask app
app = flask.Flask(__name__)
app.config['DEBUG'] = True

# create some test data
books = [
    {'id': 0, 'title': 'A Fire Upon The Deep', 'author': 'Vernor Vinge', 'first_sentence': 'The coldsleep itself was dreamless.', 'year_published': '1992'},
    {'id': 1, 'title': 'The Ones Who Walk Away From Omelas', 'author': 'Ursula K. Le Guin', 'first_sentence': 'With a clamor of bells that set the swallows soaring, the Festival of Summer came to the city Omelas, bright-towered by the sea.', 'published': '1973'},
    {'id': 2, 'title': 'Dhalgren', 'author': 'Samuel R. Delany', 'first_sentence': 'to wound the autumnal city.', 'published': '1975'}
]

# create an endpoint
@app.route('/', methods=['GET'])
def home():
    return '''<h1>Welcome to our book API!</h1>'''

@app.route('/api/v1/resources/books

Specify context. Context matters, the more you can specify like domain, topic, etc. the better.
指定上下文 (context)。上下文很重要，你可以指定的越多越好，例如领域 (domain)、主题 (topic) 等。
Limit the output. If you want a specific number of items or a specific length, specify it.
限制输出。如果你想要特定数量的项目或特定长度，请指定它。
Specify both what and how. Remember to mention both what you want and how you want it, for example "Create a Python Web API with routes products and customers, divide it into 3 files".
同时指定“什么”和“如何”。记住要同时提到你想要“什么”以及你想要“如何”去做，例如“创建一个包含 products 和 customers 路由的 Python Web API，并将其分为 3 个文件”。
Use templates. Often, you will want to enrich your prompts with data from your company. Use templates to do this. Templates can have variables that you replace with actual data.
使用模板。通常，你希望使用你公司的数据来丰富你的提示。使用模板来实现这一点。模板可以包含你用实际数据替换的变量。
Spell correctly. LLMs might provide you with a correct response, but if you spell correctly, you will get a better response.
正确拼写。 LLM 可能会为你提供正确的响应，但如果你正确拼写，你将获得更好的响应。

Assignment

from flask import Flask, request

app = Flask(__name__)

@app.route('/')
def hello():
    name = request.args.get('name', 'World')
    return f'Hello, {name}!'

if __name__ == '__main__':
    app.run()

Solution

Knowledge check

To teach the LLM how to solve a problem.
为了教 LLM 如何解决问题。
B, To teach the LLM to find errors in code.
B，教 LLM 查找代码中的错误。
C, To instruct the LLM to come up with different solutions.
C，指示 LLM 提出不同的解决方案。

🚀 Challenge

Great Work! Continue Your Learning

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Introduction

In this chapter, you will:

Learn about the openai library and it's core concepts.
了解 openai 库及其核心概念。
• Build a text generation app using openai.
Understand how to use concepts like prompt, temperature, and tokens to build a text generation app.
了解如何使用提示（prompt）、温度（temperature）和令牌（tokens）等概念来构建文本生成应用程序。

Learning goals

Explain what a text generation app is.
解释什么是文本生成应用程序。
Build a text generation app using openai.
使用 openai 构建一个文本生成应用程序。
Configure your app to use more or less tokens and also change the temperature, for a varied output.
配置你的应用程序以使用更多或更少的令牌（tokens），并改变温度（temperature），以获得不同的输出。

Command-based. Console apps are typical apps where you type a command and it carries out a task. For example, git is a command-based app.
基于命令。控制台应用程序是典型的应用程序，你可以在其中键入命令，然后它会执行任务。例如，git 是一个基于命令的应用程序。
User interface (UI). Some apps have graphical user interfaces (GUIs) where you click buttons, input text, select options and more.
用户界面 (UI)。有些应用程序具有图形用户界面 (GUI)，你可以在其中单击按钮、输入文本、选择选项等。

It's limited. You can't just type any command, only the ones that the app supports.
它是有限的。你不能只键入任何命令，只能键入应用程序支持的命令。
Language specific. Some apps support many languages, but by default the app is built for a specific language, even if you can add more language support.
语言特定。有些应用程序支持多种语言，但默认情况下，应用程序是为特定语言构建的，即使你可以添加更多语言支持。

A chatbot. A chatbot answering questions about topics, like your company and its products could be a good match.
聊天机器人。一个回答关于主题的聊天机器人，例如你的公司及其产品，可能是一个很好的选择。
Helper. LLMs are great at things like summarizing text, getting insights from text, producing text like resumes and more.
助手。LLM 在诸如总结文本、从文本中获取见解、生成文本（如简历等）方面非常出色。
Code assistant. Depending on the language model you use, you can build a code assistant that helps you write code. For example, you can use a product like GitHub Copilot as well as ChatGPT to help you write code.
代码助手。根据你使用的语言模型，你可以构建一个代码助手来帮助你编写代码。例如，你可以使用像 GitHub Copilot 以及 ChatGPT 这样的产品来帮助你编写代码。

Use an API. Here you're constructing web requests with your prompt and get generated text back.
使用 API。在这里，你使用你的提示（prompt）构建 Web 请求，并获得生成的文本。
Use a library. Libraries help encapsulate the API calls and make them easier to use.
使用库。库有助于封装 API 调用并使它们更易于使用。

openai, this library makes it easy to connect to your model and send in prompts.
openai，这个库可以轻松连接到你的模型并发送提示（prompts）。

Langchain. Langchain is well known and supports Python.
Langchain。Langchain 广为人知，并支持 Python。
Semantic Kernel. Semantic Kernel is a library by Microsoft supporting the languages C#, Python, and Java.
Semantic Kernel。Semantic Kernel 是微软的一个库，支持 C#、Python 和 Java 语言。

pip install openai

Create an account on Azure https://azure.microsoft.com/free/.

在 Azure 上创建一个帐户 https://azure.microsoft.com/free/。

Gain access to Azure OpenAI. Go to https://learn.microsoft.com/azure/ai-services/openai/overview#how-do-i-get-access-to-azure-openai and request access.

[!NOTE] At the time of writing, you need to apply for access to Azure OpenAI.

获得 Azure OpenAI 的访问权限。 转到 https://learn.microsoft.com/azure/ai-services/openai/overview#how-do-i-get-access-to-azure-openai 并请求访问权限。 [NOTE] 在撰写本文时，你需要申请访问 Azure OpenAI。

Install Python https://www.python.org/

安装 Python https://www.python.org/

Have created an Azure OpenAI Service resource. See this guide for how to create a resource.

创建了一个 Azure OpenAI 服务资源。 有关如何创建资源，请参阅本指南。

openai.api_type = 'azure'
openai.api_key = os.environ["OPENAI_API_KEY"]
openai.api_version = '2023-05-15'
openai.api_base = os.getenv("API_BASE")

api_type to azure. This tells the library to use Azure OpenAI and not OpenAI.
api_type 为 azure。 这告诉库使用 Azure OpenAI 而不是 OpenAI。
api_key, this is your API key found in the Azure Portal.
api_key，这是你在 Azure 门户中找到的 API 密钥。
api_version, this is the version of the API you want to use. At the time of writing, the latest version is 2023-05-15.
api_version，这是你要使用的 API 的版本。 在撰写本文时，最新版本是 2023-05-15。
api_base, this is the endpoint of the API. You can find it in the Azure Portal next to your API key.
api_base，这是 API 的终结点 (endpoint)。 你可以在 Azure 门户中 API 密钥旁边找到它。

prompt = "Complete the following: Once upon a time there was a"

completion = openai.Completion.create(model="davinci-002", prompt=prompt)
print(completion.choices[0].text)

import openai

openai.api_key = "sk-..."

completion = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "Hello world"}])
print(completion.choices[0].message.content)

Create a virtual environment and install openai:

python -m venv venv
source venv/bin/activate
pip install openai

[!NOTE] If you're using Windows type venv\Scripts\activate instead of source venv/bin/activate.

[!NOTE] Locate your Azure OpenAI key by going to https://portal.azure.com/ and search for Open AI and select the Open AI resource and then select Keys and Endpoint and copy the Key 1 value.

创建一个虚拟环境并安装 openai (openai 库)： python -m venv venv source venv/bin/activate pip install openai [!NOTE] 如果你使用的是 Windows，请键入 venv\Scripts\activate 而不是 source venv/bin/activate。 [!NOTE] 通过转到 https://portal.azure.com/ 并搜索 Open AI，然后选择 Open AI 资源，然后选择密钥和终结点 (Keys and Endpoint) 并复制密钥 1 (Key 1) 值来找到你的 Azure OpenAI 密钥。

Create an app.py file and give it the following code:

import openai

openai.api_key = "<replace this value with your open ai key or Azure OpenAI key>"

openai.api_type = 'azure'
openai.api_version = '2023-05-15'
openai.api_base = "<endpoint found in Azure Portal where your API key is>"
deployment_name = "<deployment name>"

# add your completion code
prompt = "Complete the following: Once upon a time there was a"
messages = [{"role": "user", "content": prompt}]

# make completion
completion = openai.chat.completions.create(model=deployment_name, messages=messages)

# print response
print(completion.choices[0].message.content)

[!NOTE] If you're using Azure OpenAI, you need to set the api_type to azure and set the api_key to your Azure OpenAI key.

You should see an output like the following:

 very unhappy _____.

Once upon a time there was a very unhappy mermaid.

.message.content) [!NOTE] 如果你使用的是 Azure OpenAI，你需要将 api_type 设置为 azure，并将 api_key 设置为你的 Azure OpenAI 密钥。 你应该看到如下输出： very unhappy _____. Once upon a time there was a very unhappy mermaid.

Generate a type of text. For example, you can generate a poem, questions for a quiz etc.
生成一种类型的文本。 例如，你可以生成一首诗、测验的问题等等。
Lookup information. You can use prompts to look for information like the following example 'What does CORS mean in web development?'.
查找信息。 你可以使用提示词 (prompts) 来查找信息，例如以下示例“CORS 在 Web 开发中是什么意思？”。
Generate code. You can use prompts to generate code, for example developing a regular expression used to validate emails or why not generate an entire program, like a web app?
生成代码。 你可以使用提示词 (prompts) 来生成代码，例如开发用于验证电子邮件的正则表达式，或者为什么不生成整个程序，比如一个 Web 应用程序？

1. Roasted Chicken and Vegetables:
Ingredients:
- 4 chicken thighs
- 2 potatoes, cut into cubes
- 2 carrots, cut into cubes
- 2 tablespoons olive oil
- 2 cloves garlic, minced
- 1 teaspoon dried thyme
- 1 teaspoon dried oregano
- Salt and pepper, to taste

2. Chicken and Potato Stew:
Ingredients:
- 2 tablespoons olive oil
- 1 onion, diced
- 2 cloves garlic, minced
- 2 chicken breasts, cut into cubes
- 2 potatoes, cut into cubes
- 2 carrots, cut into cubes
- 1 teaspoon dried oregano
- 1 teaspoon dried thyme
- 1 cup chicken broth
- Salt and pepper, to taste

3. Chicken and Potato Bake:
Ingredients:
- 2 tablespoons olive oil
- 2 chicken breasts, cut into cubes
- 2 potatoes, cut into cubes
- 2 carrots, cut into cubes
- 1 onion, diced
- 2 cloves garlic, minced
- 1 teaspoon dried oregano
- 1 teaspoon dried thyme
- 1 cup chicken broth
- Salt and pepper, to taste

4. Chicken and Potato Soup:
Ingredients:
- 2 tablespoons olive oil
- 1 onion, diced
- 2 cloves garlic, minced
- 2 chicken breasts, cut into cubes
- 2 potatoes, cut into cubes
- 2 carrots, cut into cubes
- 1 teaspoon dried oregano
- 1 teaspoon dried thyme
- 4 cups chicken broth
- Salt and pepper, to taste

5. Chicken and Potato Hash:
Ingredients:
- 2 tablespoons olive oil
- 2 chicken breasts, cut into cubes
- 2 potatoes, cut into cubes
- 2 carrots, cut into cubes
- 1 onion, diced
- 2 cloves garlic, minced
- 1 teaspoon dried oregano

Filtering out ingredients I don't like or am allergic to.
过滤掉我不喜欢或过敏的食材。
Produce a shopping list, in case I don't have all the ingredients at home.
生成一个购物清单，以防我家里没有所有食材。

1. Roasted Chicken and Vegetables:
Ingredients:
- 4 chicken thighs
- 2 potatoes, cut into cubes
- 2 carrots, cut into cubes
- 2 tablespoons olive oil
- 1 teaspoon dried thyme
- 1 teaspoon dried oregano
- Salt and pepper, to taste

2. Chicken and Potato Stew:
Ingredients:
- 2 tablespoons olive oil
- 1 onion, diced
- 2 chicken breasts, cut into cubes
- 2 potatoes, cut into cubes
- 2 carrots, cut into cubes
- 1 teaspoon dried oregano
- 1 teaspoon dried thyme
- 1 cup chicken broth
- Salt and pepper, to taste

3. Chicken and Potato Bake:
Ingredients:
- 2 tablespoons olive oil
- 2 chicken breasts, cut into cubes
- 2 potatoes, cut into cubes
- 2 carrots, cut into cubes
- 1 onion, diced
- 1 teaspoon dried oregano
- 1 teaspoon dried thyme
- 1 cup chicken broth
- Salt and pepper, to taste

4. Chicken and Potato Soup:
Ingredients:
- 2 tablespoons olive oil
- 1 onion, diced
- 2 chicken breasts, cut into cubes
- 2 potatoes, cut into cubes
- 2 carrots, cut into cubes
- 1 teaspoon dried oregano
- 1 teaspoon dried thyme
- 4 cups chicken broth
- Salt and pepper, to taste

5. Chicken and Potato Hash:
Ingredients:
- 2 tablespoons olive oil
- 2 chicken breasts, cut into cubes
- 2 potatoes, cut into cubes
- 2 carrots, cut into cubes
- 1 onion, diced
- 1 teaspoon dried oregano

Shopping List:
- Olive oil
- Onion
- Thyme
- Oregano
- Salt
- Pepper

Use the existing app.py file as a starting point

使用现有的 app.py 文件作为起点

Locate the prompt variable and change its code to the following:

prompt = "Show me 5 recipes for a dish with the following ingredients: chicken, potatoes, and carrots. Per recipe, list all the ingredients used"

If you now run the code, you should see an output similar to:

-Chicken Stew with Potatoes and Carrots: 3 tablespoons oil, 1 onion, chopped, 2 cloves garlic, minced, 1 carrot, peeled and chopped, 1 potato, peeled and chopped, 1 bay leaf, 1 thyme sprig, 1/2 teaspoon salt, 1/4 teaspoon black pepper, 1 1/2 cups chicken broth, 1/2 cup dry white wine, 2 tablespoons chopped fresh parsley, 2 tablespoons unsalted butter, 1 1/2 pounds boneless, skinless chicken thighs, cut into 1-inch pieces
-Oven-Roasted Chicken with Potatoes and Carrots: 3 tablespoons extra-virgin olive oil, 1 tablespoon Dijon mustard, 1 tablespoon chopped fresh rosemary, 1 tablespoon chopped fresh thyme, 4 cloves garlic, minced, 1 1/2 pounds small red potatoes, quartered, 1 1/2 pounds carrots, quartered lengthwise, 1/2 teaspoon salt, 1/4 teaspoon black pepper, 1 (4-pound) whole chicken
-Chicken, Potato, and Carrot Casserole: cooking spray, 1 large onion, chopped, 2 cloves garlic, minced, 1 carrot, peeled and shredded, 1 potato, peeled and shredded, 1/2 teaspoon dried thyme leaves, 1/4 teaspoon salt, 1/4 teaspoon black pepper, 2 cups fat-free, low-sodium chicken broth, 1 cup frozen peas, 1/4 cup all-purpose flour, 1 cup 2% reduced-fat milk, 1/4 cup grated Parmesan cheese

-One Pot Chicken and Potato Dinner: 2 tablespoons olive oil, 1 pound boneless, skinless chicken thighs, cut into 1-inch pieces, 1 large onion, chopped, 3 cloves garlic, minced, 1 carrot, peeled and chopped, 1 potato, peeled and chopped, 1 bay leaf, 1 thyme sprig, 1/2 teaspoon salt, 1/4 teaspoon black pepper, 2 cups chicken broth, 1/2 cup dry white wine

-Chicken, Potato, and Carrot Curry: 1 tablespoon vegetable oil, 1 large onion, chopped, 2 cloves garlic, minced, 1 carrot, peeled and chopped, 1 potato, peeled and chopped, 1 teaspoon ground coriander, 1 teaspoon ground cumin, 1/2 teaspoon ground turmeric, 1/2 teaspoon ground ginger, 1/4 teaspoon cayenne pepper, 2 cups chicken broth, 1/2 cup dry white wine, 1 (15-ounce) can chickpeas, drained and rinsed, 1/2 cup raisins, 1/2 cup chopped fresh cilantro

NOTE, your LLM is nondeterministic, so you might get different results every time you run the program.

Great, let's see how we can improve things. To improve things, we want to make sure the code is flexible, so ingredients and number of recipes can be improved and changed.

找到 prompt 变量并将其代码更改为以下内容： prompt = "Show me 5 recipes for a dish with the following ingredients: chicken, potatoes, and carrots. Per recipe, list all the ingredients used" 如果您现在运行代码，您应该会看到类似于以下的输出： -Chicken Stew with Potatoes and Carrots: 3 tablespoons oil, 1 onion, chopped, 2 cloves garlic, minced, 1 carrot, peeled and chopped, 1 potato, peeled and chopped, 1 bay leaf, 1 thyme sprig, 1/2 teaspoon salt, 1/4 teaspoon black pepper, 1 1/2 cups chicken broth, 1/2 cup dry white wine, 2 tablespoons chopped fresh parsley, 2 tablespoons unsalted butter, 1 1/2 pounds boneless, skinless chicken thighs, cut into 1-inch pieces -Oven-Roasted Chicken with Potatoes and Carrots: 3 tablespoons extra-virgin olive oil, 1 tablespoon Dijon mustard, 1 tablespoon chopped fresh rosemary, 1 tablespoon chopped fresh thyme, 4 cloves garlic, minced, 1 1/2 pounds small red potatoes, quartered, 1 1/2 pounds carrots, quartered lengthwise, 1/2 teaspoon salt, 1/4 teaspoon black pepper, 1 (4-pound) whole chicken -Chicken, Potato, and Carrot Casserole: cooking spray, 1 large onion, chopped, 2 cloves garlic, minced, 1 carrot, peeled and shredded, 1 potato, peeled and shredded, 1/2 teaspoon dried thyme leaves, 1/4 teaspoon salt, 1/4 teaspoon black pepper, 2 cups fat-free, low-sodium chicken broth, 1 cup frozen peas, 1/4 cup all-purpose flour, 1 cup 2% reduced-fat milk, 1/4 cup grated Parmesan cheese -One Pot Chicken and Potato Dinner: 2 tablespoons olive oil, 1 pound boneless, skinless chicken thighs, cut into 1-inch pieces, 1 large onion, chopped, 3 cloves garlic, minced, 1 carrot, peeled and chopped, 1 potato, peeled and chopped, 1 bay leaf, 1 thyme sprig, 1/2 teaspoon salt, 1/4 teaspoon black pepper, 2 cups chicken broth, 1/2 cup dry white wine -Chicken, Potato, and Carrot Curry: 1 tablespoon vegetable oil, 1 large onion, chopped, 2 cloves garlic, minced, 1 carrot, peeled and chopped, 1 potato, peeled and chopped, 1 teaspoon ground coriander, 1 teaspoon ground cumin, 1/2 teaspoon ground turmeric, 1/2 teaspoon ground ginger, 1/4 teaspoon cayenne pepper, 2 cups chicken broth, 1/2 cup dry white wine, 1 (15-ounce) can chickpeas, drained and rinsed, 1/2 cup raisins, 1/2 cup chopped fresh cilantro 注意，你的 LLM (Large Language Model, 大型语言模型) 是非确定性的，因此每次运行程序时可能会得到不同的结果。 太好了，让我们看看如何改进。为了改进，我们希望确保代码是灵活的，这样食材和菜谱的数量都可以改进和更改。

Let's change the code in the following way:

no_recipes = input("No of recipes (for example, 5): ")

ingredients = input("List of ingredients (for example, chicken, potatoes, and carrots): ")

# interpolate the number of recipes into the prompt an ingredients
prompt = f"Show me {no_recipes} recipes for a dish with the following ingredients: {ingredients}. Per recipe, list all the ingredients used"

Taking the code for a test run, could look like this:

No of recipes (for example, 5): 3
List of ingredients (for example, chicken, potatoes, and carrots): milk,strawberries

-Strawberry milk shake: milk, strawberries, sugar, vanilla extract, ice cubes
-Strawberry shortcake: milk, flour, baking powder, sugar, salt, unsalted butter, strawberries, whipped cream
-Strawberry milk: milk, strawberries, sugar, vanilla extract

让我们按以下方式更改代码： no_recipes = input("No of recipes (for example, 5): ") ingredients = input("List of ingredients (for example, chicken, potatoes, and carrots): ") # interpolate the number of recipes into the prompt an ingredients prompt = f"Show me {no_recipes} recipes for a dish with the following ingredients: {ingredients}. Per recipe, list all the ingredients used" 对代码进行测试运行，可能看起来像这样： No of recipes (for example, 5): 3 List of ingredients (for example, chicken, potatoes, and carrots): milk,strawberries -Strawberry milk shake: milk, strawberries, sugar, vanilla extract, ice cubes -Strawberry shortcake: milk, flour, baking powder, sugar, salt, unsalted butter, strawberries, whipped cream -Strawberry milk: milk, strawberries, sugar, vanilla extract

Filter out ingredients. We want to be able to filter out ingredients we don't like or are allergic to. To accomplish this change, we can edit our existing prompt and add a filter condition to the end of it like so:

filter = input("Filter (for example, vegetarian, vegan, or gluten-free): ")

prompt = f"Show me {no_recipes} recipes for a dish with the following ingredients: {ingredients}. Per recipe, list all the ingredients used, no {filter}"

Above, we add {filter} to the end of the prompt and we also capture the filter value from the user.

An example input of running the program can now look like so:

No of recipes (for example, 5): 3
List of ingredients (for example, chicken, potatoes, and carrots): onion,milk
Filter (for example, vegetarian, vegan, or gluten-free): no milk

1. French Onion Soup

Ingredients:

-1 large onion, sliced
-3 cups beef broth
-1 cup milk
-6 slices french bread
-1/4 cup shredded Parmesan cheese
-1 tablespoon butter
-1 teaspoon dried thyme
-1/4 teaspoon salt
-1/4 teaspoon black pepper

Instructions:

1. In a large pot, sauté onions in butter until golden brown.
2. Add beef broth, milk, thyme, salt, and pepper. Bring to a boil.
3. Reduce heat and simmer for 10 minutes.
4. Place french bread slices on soup bowls.
5. Ladle soup over bread.
6. Sprinkle with Parmesan cheese.

2. Onion and Potato Soup

Ingredients:

-1 large onion, chopped
-2 cups potatoes, diced
-3 cups vegetable broth
-1 cup milk
-1/4 teaspoon black pepper

Instructions:

1. In a large pot, sauté onions in butter until golden brown.
2. Add potatoes, vegetable broth, milk, and pepper. Bring to a boil.
3. Reduce heat and simmer for 10 minutes.
4. Serve hot.

3. Creamy Onion Soup

Ingredients:

-1 large onion, chopped
-3 cups vegetable broth
-1 cup milk
-1/4 teaspoon black pepper
-1/4 cup all-purpose flour
-1/2 cup shredded Parmesan cheese

Instructions:

1. In a large pot, sauté onions in butter until golden brown.
2. Add vegetable broth, milk, and pepper. Bring to a boil.
3. Reduce heat and simmer for 10 minutes.
4. In a small bowl, whisk together flour and Parmesan cheese until smooth.
5. Add to soup and simmer for an additional 5 minutes, or until soup has thickened.

As you can see, any recipes with milk in it has been filtered out. But, if you're lactose intolerant, you might want to filter out recipes with cheese in them as well, so there's a need to be clear.

过滤掉食材。我们希望能够过滤掉我们不喜欢或过敏的食材。为了完成此更改，我们可以编辑现有的提示，并在其末尾添加一个过滤器条件，如下所示： filter = input("Filter (for example, vegetarian, vegan, or gluten-free): ") prompt = f"Show me {no_recipes} recipes for a dish with the following ingredients: {ingredients}. Per recipe, list all the ingredients used, no {filter}" 上面，我们在提示的末尾添加了 {filter}，并且我们还从用户那里捕获了过滤器值。 现在运行该程序的示例如下所示： No of recipes (for example, 5): 3 List of ingredients (for example, chicken, potatoes, and carrots): onion,milk Filter (for example, vegetarian, vegan, or gluten-free): no milk 1. French Onion Soup Ingredients: -1 large onion, sliced -3 cups beef broth -1 cup milk -6 slices french bread -1/4 cup shredded Parmesan cheese -1 tablespoon butter -1 teaspoon dried thyme -1/4 teaspoon salt -1/4 teaspoon black pepper Instructions: 1. In a large pot, sauté onions in butter until golden brown. 2. Add beef broth, milk, thyme, salt, and pepper. Bring to a boil. 3. Reduce heat and simmer for 10 minutes. 4. Place french bread slices on soup bowls. 5. Ladle soup over bread. 6. Sprinkle with Parmesan cheese. 2. Onion and Potato Soup Ingredients: -1 large onion, chopped -2 cups potatoes, diced -3 cups vegetable broth -1 cup milk -1/4 teaspoon black pepper Instructions: 1. In a large pot, sauté onions in butter until golden brown. 2. Add potatoes, vegetable broth, milk, and pepper. Bring to a boil. 3. Reduce heat and simmer for 10 minutes. 4. Serve hot. 3. Creamy Onion Soup Ingredients: -1 large onion, chopped -3 cups vegetable broth -1 cup milk -1/4 teaspoon black pepper -1/4 cup all-purpose flour -1/2 cup shredded Parmesan cheese Instructions: 1. In a large pot, sauté onions in butter until golden brown. 2. Add vegetable broth, milk, and pepper. Bring to a boil. 3. Reduce heat and simmer for 10 minutes. 4. In a small bowl, whisk together flour and Parmesan cheese until smooth. 5. Add to soup and simmer for an additional 5 minutes, or until soup has thickened. 正如您所看到的，任何含有牛奶的菜谱都已被过滤掉。但是，如果您是乳糖不耐症患者，您可能还需要过滤掉含有奶酪的菜谱，因此需要明确说明。

Produce a shopping list. We want to produce a shopping list, considering what we already have at home.

For this functionality, we could either try to solve everything in one prompt or we could split it up into two prompts. Let's try the latter approach. Here we're suggesting adding an additional prompt, but for that to work, we need to add the result of the former prompt as context to the latter prompt.

Locate the part in the code that prints out the result from the first prompt and add the following code below:

old_prompt_result = completion.choices[0].message.content
prompt = "Produce a shopping list for the generated recipes and please don't include ingredients that I already have."

new_prompt = f"{old_prompt_result} {prompt}"
messages = [{"role": "user", "content": new_prompt}]
completion = openai.Completion.create(engine=deployment_name, messages=messages, max_tokens=1200)

# print response
print("Shopping list:")
print(completion.choices[0].message.content)

Note the following:

1. We're constructing a new prompt by adding the result from the first prompt to the new prompt:

   new_prompt = f"{old_prompt_result} {prompt}"
   

.message.content) 请注意以下事项： 我们通过将第一个提示的结果添加到新提示来构建一个新提示： new_prompt = f"{old_prompt_result} {prompt}"

We make a new request, but also considering the number of tokens we asked for in the first prompt, so this time we say max_tokens is 1200.

completion = openai.Completion.create(engine=deployment_name, prompt=new_prompt, max_tokens=1200)

Taking this code for a spin, we now arrive at the following output:

No of recipes (for example, 5): 2
List of ingredients (for example, chicken, potatoes, and carrots): apple,flour
Filter (for example, vegetarian, vegan, or gluten-free): sugar


-Apple and flour pancakes: 1 cup flour, 1/2 tsp baking powder, 1/2 tsp baking soda, 1/4 tsp salt, 1 tbsp sugar, 1 egg, 1 cup buttermilk or sour milk, 1/4 cup melted butter, 1 Granny Smith apple, peeled and grated
-Apple fritters: 1-1/2 cups flour, 1 tsp baking powder, 1/4 tsp salt, 1/4 tsp baking soda, 1/4 tsp nutmeg, 1/4 tsp cinnamon, 1/4 tsp allspice, 1/4 cup sugar, 1/4 cup vegetable shortening, 1/4 cup milk, 1 egg, 2 cups shredded, peeled apples
Shopping list:
-Flour, baking powder, baking soda, salt, sugar, egg, buttermilk, butter, apple, nutmeg, cinnamon, allspice

我们提出了一个新的请求，但也要考虑到我们在第一个提示中要求的 tokens (令牌) 数量，所以这次我们说 max_tokens 是 1200。 completion = openai.Completion.create(engine=deployment_name, prompt=new_prompt, max_tokens=1200) 运行此代码后，我们现在得到以下输出： No of recipes (for example, 5): 2 List of ingredients (for example, chicken, potatoes, and carrots): apple,flour Filter (for example, vegetarian, vegan, or gluten-free): sugar -Apple and flour pancakes: 1 cup flour, 1/2 tsp baking powder, 1/2 tsp baking soda, 1/4 tsp salt, 1 tbsp sugar, 1 egg, 1 cup buttermilk or sour milk, 1/4 cup melted butter, 1 Granny Smith apple, peeled and grated -Apple fritters: 1-1/2 cups flour, 1 tsp baking powder, 1/4 tsp salt, 1/4 tsp baking soda, 1/4 tsp nutmeg, 1/4 tsp cinnamon, 1/4 tsp allspice, 1/4 cup sugar, 1/4 cup vegetable shortening, 1/4 cup milk, 1 egg, 2 cups shredded, peeled apples Shopping list: -Flour, baking powder, baking soda, salt, sugar, egg, buttermilk, butter, apple, nutmeg, cinnamon, allspice

Separate secrets from code, like the API key. Secrets do not belong in code and should be stored in a secure location. To separate secrets from code, we can use environment variables and libraries like python-dotenv to load them from a file. Here's how that would look like in code:

1. Create a .env file with the following content:

   OPENAI_API_KEY=sk-...
   

   Note, for Azure, you need to set the following environment variables:

   OPENAI_API_TYPE=azure
   OPENAI_API_VERSION=2023-05-15
   OPENAI_API_BASE=<replace>
   

   In code, you would load the environment variables like so:

   from dotenv import load_dotenv
   
   load_dotenv()
   
   openai.api_key = os.environ["OPENAI_API_KEY"]
   

将密钥与代码分开，例如 API 密钥 (API key)。密钥不属于代码，应存储在安全的位置。要将密钥与代码分开，我们可以使用环境变量和库，如 python-dotenv，从文件中加载它们。以下是在代码中的样子： 创建一个 .env 文件，内容如下： OPENAI_API_KEY=sk-... 注意，对于 Azure，您需要设置以下环境变量： OPENAI_API_TYPE=azure OPENAI_API_VERSION=2023-05-15 OPENAI_API_BASE=<replace> 在代码中，您可以像这样加载环境变量： from dotenv import load_dotenv load_dotenv() openai.api_key = os.environ["OPENAI_API_KEY"]

A word on token length. We should consider how many tokens we need to generate the text we want. Tokens cost money, so where possible, we should try to be economical with the number of tokens we use. For example, can we phrase the prompt so that we can use less tokens?

To change the tokens used, you can use the max_tokens parameter. For example, if you want to use 100 tokens, you would do:

completion = client.chat.completions.create(model=deployment, messages=messages, max_tokens=100)

关于 token (令牌) 长度的说明。我们应该考虑生成我们想要的文本需要多少 tokens。Tokens 花钱，所以如果可能的话，我们应该尽量节省使用的 tokens 数量。例如，我们是否可以措辞提示，以便我们可以使用更少的 tokens？ 要更改使用的 tokens，您可以使用 max_tokens 参数。例如，如果您想使用 100 个 tokens，您可以这样做： completion = client.chat.completions.create(model=deployment, messages=messages, max_tokens=100)

Experimenting with temperature. Temperature is something we haven't mentioned so far but is an important context for how our program performs. The higher the temperature value the more random the output will be. Conversely the lower the temperature value the more predictable the output will be. Consider whether you want variation in your output or not.

To alter the temperature, you can use the temperature parameter. For example, if you want to use a temperature of 0.5, you would do:

completion = client.chat.completions.create(model=deployment, messages=messages, temperature=0.5)

Note, the closer to 1.0, the more varied the output.

试验 temperature (温度)。到目前为止，我们还没有提到 temperature，但它是我们程序如何执行的一个重要上下文。temperature 值越高，输出就越随机。相反，temperature 值越低，输出就越可预测。考虑您是否希望输出中存在变化。 要改变 temperature，您可以使用 temperature 参数。例如，如果您想使用 0.5 的 temperature，您可以这样做： completion = client.chat.completions.create(model=deployment, messages=messages, temperature=0.5) 注意，越接近 1.0，输出就越多样。

Assignment

Tweak the recipe generator app to improve it further. Play around with temperature values, and the prompts to see what you can come up with.
调整菜谱生成器应用程序以进一步改进它。尝试使用 temperature 值和提示，看看您能想出什么。
Build a "study buddy". This app should be able to answer questions about a topic for example Python, you could have prompts like "What is a certain topic in Python?", or you could have a prompt that says, show me code for a certain topic etc.
构建一个 "学习伙伴"。这个应用程序应该能够回答关于某个主题的问题，例如 Python，您可以有像 "Python 中的某个主题是什么？" 这样的提示，或者您可以有一个提示说，展示某个主题的代码等等。
History bot, make history come alive, instruct the bot to play a certain historical character and ask it questions about its life and times.
历史机器人，让历史栩栩如生，指示机器人扮演某个历史人物，并向它提问关于它的生活和时代的问题。

Solution

- "You're an expert on the Python language

    Suggest a beginner lesson for Python in the following format:

    Format:
    - concepts:
    - brief explanation of the lesson:
    - exercise in code with solutions"

- "You are Abe Lincoln, tell me about yourself in 3 sentences, and respond using grammar and words like Abe would have used"
- "You are Abe Lincoln, respond using grammar and words like Abe would have used:

   Tell me about your greatest accomplishments, in 300 words"

Knowledge check

It controls how random the output is.
它控制输出的随机性。
It controls how big the response is.
它控制响应的大小。
It controls how many tokens are used.
它控制着使用了多少个令牌 (tokens)。

🚀 Challenge

Great Work! Continue Your Learning

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Building the app. How do we efficiently build and seamlessly integrate these AI-powered applications for specific use cases?
构建应用程序。我们如何高效地构建这些由人工智能驱动的应用程序，并将其无缝地集成到特定的用例中？
Monitoring. Once deployed, how can we monitor and ensure that the applications are operating at the highest level of quality, both in terms of functionality and adhering to the six principles of responsible AI?
监控。一旦部署，我们如何监控并确保应用程序在功能方面以及遵守负责任的人工智能六项原则 (six principles of responsible AI) 方面，都以最高的质量水平运行？

Introduction

This lesson covers:

Techniques for efficiently building and integrating chat applications.
用于高效构建和集成聊天应用程序的技术。
How to apply customization and fine-tuning to applications.
如何将定制和微调应用于应用程序。
Strategies and considerations to effectively monitor chat applications.
有效监控聊天应用程序的策略和注意事项。

Learning Goals

Describe considerations for building and integrating chat applications into existing systems.
描述将聊天应用程序构建和集成到现有系统中需要考虑的事项。
Customize chat applications for specific use-cases.
为特定用例定制聊天应用程序。
Identify key metrics and considerations to effectively monitor and maintain the quality of AI-powered chat applications.
识别有效监控和维护人工智能驱动的聊天应用程序质量的关键指标和注意事项。
Ensure chat applications leverage AI responsibly.
确保聊天应用程序负责任地利用人工智能。

Expedites the development process and reduces overhead: Relying on pre-built functionalities instead of the expensive process of building them yourself allows you to focus on other aspects of your application that you may find more important, such as business logic.
加快开发过程并减少开销：依靠预构建的功能而不是自己构建它们的昂贵过程，使你可以专注于应用程序的其他方面，这些方面你可能会觉得更重要，例如业务逻辑。
Better performance: When building functionality from scratch, you'll eventually ask yourself "How does it scale? Is this application capable of handling a sudden influx of users?" Well maintained SDK and APIs often have built in solutions for these concerns.
更好的性能：从头开始构建功能时，你最终会问自己“它如何扩展？此应用程序是否能够处理用户突然涌入的情况？” 维护良好的 SDK (SDKs) 和 API (APIs) 通常内置了针对这些问题的解决方案。
Easier maintenance: Updates and improvements are easier to manage as most APIs and SDKs simply require an update to a library when a newer version is released.
更容易维护：更新和改进更容易管理，因为大多数 API (APIs) 和 SDK (SDKs) 只需在发布较新版本时更新库即可。
Access to cutting edge technology: Leveraging models that have been fined tuned and trained on extensive datasets provides your application with natural language capabilities.
获得尖端技术：利用经过微调并在广泛数据集上训练的模型为你的应用程序提供自然语言功能。

import os
from openai import OpenAI

API_KEY = os.getenv("OPENAI_API_KEY","")

client = OpenAI(
    api_key=API_KEY
    )

chat_completion = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "Suggest two titles for an instructional lesson on chat applications for generative AI."}])

Mechanism for addressing ambiguity: Generative AI models occasionally generate ambiguous answers. A feature that allows users to ask for clarification can be helpful should they come across this problem.
解决歧义的机制：生成式人工智能模型（Generative AI models）偶尔会产生模棱两可的答案。如果用户遇到这个问题，允许他们请求澄清的功能会很有帮助。
Context retention: Advanced generative AI models have the ability to remember context within a conversation, which can be a necessary asset to the user experience. Giving users the ability to control and manage context improves the user experience, but introduces the risk of retaining sensitive user information. Considerations for how long this information is stored, such as introducing a retention policy, can balance the need for context against privacy.
上下文保留：高级生成式人工智能模型（Advanced generative AI models）能够记住对话中的上下文，这对于用户体验来说可能是必要的资产。赋予用户控制和管理上下文的能力可以改善用户体验，但也引入了保留敏感用户信息的风险。诸如引入保留策略之类的，关于此信息存储时长的考量可以平衡对上下文的需求与隐私。
Personalization: With the ability to learn and adapt, AI models offer an individualized experience for a user. Tailoring the user experience through features like user profiles not only makes the user feel understood, but it also helps their pursuit of finding specific answers, creating a more efficient and satisfying interaction.
个性化：凭借学习和适应的能力，人工智能模型（AI models）为用户提供了个性化的体验。通过用户个人资料（user profiles）等功能来定制用户体验不仅让用户感到被理解，而且有助于他们寻找特定答案，从而创造更高效、更令人满意的互动。

Defining who the model is for, as well as its capabilities and limitations.
定义模型的服务对象，以及它的能力和局限性。
Defining the model's output format.
定义模型的输出格式。
Providing specific examples that demonstrate intended behavior of the model.
提供具体的例子，演示模型的预期行为。
Providing additional behavioral guardrails.
提供额外的行为护栏。

Accessibility

Features for Visual Impairment: High contrast themes and resizable text, screen reader compatibility.
视觉障碍的功能：高对比度主题和可调整大小的文本、屏幕阅读器兼容性。
Features for Auditory Impairment: Text-to-speech and speech-to-text functions, visual cues for audio notifications.
听觉障碍的功能：文本转语音和语音转文本功能、音频通知的可视提示。
Features for Motor Impairment: Keyboard navigation support, voice commands.
运动障碍的功能：键盘导航支持、语音命令。
Features for Cognitive Impairment: Simplified language options.
认知障碍的功能：简化的语言选项。

Leveraging DSL models. DSL stands for domain specific language. You can leverage a so called DSL model trained on a specific domain to understand it's concepts and scenarios.
利用领域特定语言模型（DSL models）。DSL 代表领域特定语言（domain specific language）。您可以利用在特定领域训练的所谓 DSL 模型来理解它的概念和场景。
Apply fine-tuning. Fine-tuning is the process of further training your model with specific data.
应用微调（fine-tuning）。微调是使用特定数据进一步训练您的模型的过程。

Highly specific or complex cases. For example, a neurologist might ask the application, "What are the current best practices for managing drug-resistant epilepsy in pediatric patients?"
高度具体或复杂的情况。例如，一位神经科医生可能会问应用程序，“目前管理小儿患者耐药性癫痫的最佳实践是什么？”
Lacking recent advancements. A general-purpose model could struggle to provide a current answer that incorporates the most recent advancements in neurology and pharmacology.
缺乏最近的进展。通用模型可能难以提供包含神经病学和药理学最新进展的当前答案。

Assignment

Great Work! Continue the Journey

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Introduction

In this lesson, we will cover:

Semantic vs Keyword search.
語義搜尋 (Semantic search) 與關鍵字搜尋 (Keyword search)。
What are Text Embeddings.
什麼是文本嵌入 (Text Embeddings)。
Creating a Text Embeddings Index.
創建文本嵌入索引 (Text Embeddings Index)。
Searching a Text Embeddings Index.
搜尋文本嵌入索引 (Text Embeddings Index)。

Learning Goals

After completing this lesson, you will be able to:

Tell the difference between semantic and keyword search.
區分語義搜尋和關鍵字搜尋。
Explain what Text Embeddings are.
解釋什麼是文本嵌入 (Text Embeddings)。
Create an application using Embeddings to search for data.
創建一個使用嵌入 (Embeddings) 搜尋數據的應用程式。

Today we are going to learn about Azure Machine Learning.

[-0.006655829958617687, 0.0026128944009542465, 0.008792596869170666, -0.02446001023054123, -0.008540431968867779, 0.022071078419685364, -0.010703742504119873, 0.003311325330287218, -0.011632772162556648, -0.02187200076878071, ...]

The transcript for each YouTube video in the AI Show playlist is downloaded.
下載 AI Show 播放清單中每個 YouTube 影片的文字稿。
Using OpenAI Functions, an attempt is made to extract the speaker name from the first 3 minutes of the YouTube transcript. The speaker name for each video is stored in the Embedding Index named embedding_index_3m.json.
使用 OpenAI Functions，嘗試從 YouTube 文字稿的前 3 分鐘提取講者姓名。每個影片的講者姓名都儲存在名為 embedding_index_3m.json 的嵌入索引 (Embedding Index) 中。
The transcript text is then chunked into 3 minute text segments. The segment includes about 20 words overlapping from the next segment to ensure that the Embedding for the segment is not cut off and to provide better search context.
然後將文字稿文字分塊為 3 分鐘的文字片段。該片段包含來自下一個片段大約 20 個單字的重疊，以確保該片段的嵌入 (Embedding) 不會被截斷，並提供更好的搜尋上下文。
Each text segment is then passed to the OpenAI Chat API to summarize the text into 60 words. The summary is also stored in the Embedding Index embedding_index_3m.json.
然後將每個文字片段傳遞給 OpenAI Chat API，以將文字總結為 60 個單字。摘要也儲存在嵌入索引 (Embedding Index) embedding_index_3m.json 中。
Finally, the segment text is passed to the OpenAI Embedding API. The Embedding API returns a vector of 1536 numbers that represent the semantic meaning of the segment. The segment along with the OpenAI Embedding vector is stored in an Embedding Index embedding_index_3m.json.
最後，將片段文字傳遞給 OpenAI Embedding API。Embedding API 返回一個由 1536 個數字組成的向量 (vector)，該向量表示該片段的語義。該片段以及 OpenAI Embedding 向量 (vector) 儲存在嵌入索引 (Embedding Index) embedding_index_3m.json 中。

Vector Databases

Sign in to the Azure portal.
登录到 Azure 门户。
Select the Cloud Shell icon in the upper-right corner of the Azure portal.
选择 Azure 门户右上角的 Cloud Shell 图标。
Select Bash for the environment type.
选择 Bash 作为环境类型。

az group create --name semantic-video-search --location eastus

az cognitiveservices account create --name semantic-video-openai --resource-group semantic-video-search \
    --location eastus --kind OpenAI --sku s0

az cognitiveservices account show --name semantic-video-openai \
   --resource-group  semantic-video-search | jq -r .properties.endpoint
az cognitiveservices account keys list --name semantic-video-openai \
   --resource-group semantic-video-search | jq -r .key1

az cognitiveservices account deployment create \
    --name semantic-video-openai \
    --resource-group  semantic-video-search \
    --deployment-name text-embedding-ada-002 \
    --model-name text-embedding-ada-002 \
    --model-version "2"  \
    --model-format OpenAI \
    --sku-capacity 100 --sku-name "Standard"

Solution

Great Work! Continue Your Learning

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Introduction

Image generation and why it's useful.
图像生成及其用途。
DALL-E and Midjourney, what they are, and how they work.
DALL-E 和 Midjourney，它们是什么，以及它们如何工作。
How you would build an image generation app.
您将如何构建图像生成应用程序。

Learning Goals

After completing this lesson, you will be able to:

Build an image generation application.
构建图像生成应用程序。
Define boundaries for your application with meta prompts.
使用元提示（meta prompts）定义应用程序的边界。
Work with DALL-E and Midjourney.
使用 DALL-E 和 Midjourney。

Image editing and synthesis. You can generate images for a variety of use cases, such as image editing and image synthesis.

图像编辑和合成。您可以为各种用例生成图像，例如图像编辑和图像合成。

Applied to a variety of industries. They can also be used to generate images for a variety of industries like Medtech, Tourism, Game development and more.

应用于各种行业。它们还可以用于为各种行业生成图像，如医疗科技（Medtech）、旅游业、游戏开发等。

CLIP, is a model that generates embeddings, which are numerical representations of data, from images and text.

CLIP是一种从图像和文本生成嵌入（embeddings）的模型，嵌入是数据的数值表示。

Diffused attention, is a model that generates images from embeddings. DALL-E is trained on a dataset of images and text and can be used to generate images from text descriptions. For example, DALL-E can be used to generate images of a cat in a hat, or a dog with a mohawk.

扩散注意力是一种从嵌入生成图像的模型。DALL-E是在图像和文本的数据集上训练的，可以用来从文本描述生成图像。例如，DALL-E可以用来生成戴帽子的猫或留着莫霍克发型的狗的图像。

python-dotenv, you're highly recommended to use this library to keep your secrets in a .env file away from the code.
python-dotenv，强烈建议您使用这个库将您的密钥保存在.env文件中，远离代码。
openai, this library is what you will use to interact with the OpenAI API.
openai，您将使用这个库与OpenAI API交互。
pillow, to work with images in Python.
pillow，用于在Python中处理图像。
requests, to help you make HTTP requests.
requests，帮助您发出HTTP请求。

Create a file .env with the following content:

AZURE_OPENAI_ENDPOINT=<your endpoint>
AZURE_OPENAI_API_KEY=<your key>
AZURE_OPENAI_DEPLOYMENT="dall-e-3"

Locate this information in Azure OpenAI Foundry Portal for your resource in the "Deployments" section.

创建一个名为.env的文件，内容如下： AZURE_OPENAI_ENDPOINT=<您的终结点> AZURE_OPENAI_API_KEY=<您的密钥> AZURE_OPENAI_DEPLOYMENT="dall-e-3" 在Azure OpenAI Foundry Portal的“部署”部分查找您资源的这些信息。

Collect the above libraries in a file called requirements.txt like so:

python-dotenv
openai
pillow
requests

将上述库收集到一个名为requirements.txt的文件中，如下所示： python-dotenv openai pillow requests

Next, create virtual environment and install the libraries:

python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

For Windows, use the following commands to create and activate your virtual environment:

python3 -m venv venv
venv\Scripts\activate.bat

接下来，创建虚拟环境并安装库： python3 -m venv venv source venv/bin/activate pip install -r requirements.txt 对于Windows，使用以下命令创建和激活您的虚拟环境： python3 -m venv venv venv\Scripts\activate.bat

Add the following code in file called app.py:

import openai
import os
import requests
from PIL import Image
import dotenv
from openai import OpenAI, AzureOpenAI

# import dotenv
dotenv.load_dotenv()

# configure Azure OpenAI service client 
client = AzureOpenAI(
  azure_endpoint = os.environ["AZURE_OPENAI_ENDPOINT"],
  api_key=os.environ['AZURE_OPENAI_API_KEY'],
  api_version = "2024-02-01"
  )
try:
    # Create an image by using the image generation API
    generation_response = client.images.generate(
                            prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils',
                            size='1024x1024', n=1,
                            model=os.environ['AZURE_OPENAI_DEPLOYMENT']
                          )

    # Set the directory for the stored image
    image_dir = os.path.join(os.curdir, 'images')

    # If the directory doesn't exist, create it
    if not os.path.isdir(image_dir):
        os.mkdir(image_dir)

    # Initialize the image path (note the filetype should be png)
    image_path = os.path.join(image_dir, 'generated-image.png')

    # Retrieve the generated image
    image_url = generation_response.data[0].url  # extract image URL from response
    generated_image = requests.get(image_url).content  # download the image
    with open(image_path, "wb") as image_file:
        image_file.write(generated_image)

    # Display the image in the default image viewer
    image = Image.open(image_path)
    image.show()

# catch exceptions
except openai.InvalidRequestError as err:
    print(err)

.url # extract image URL from response generated_image = requests.get(image_url).content # download the image with open(image_path, "wb") as image_file: image_file.write(generated_image) # Display the image in the default image viewer image = Image.open(image_path) image.show() # catch exceptions except openai.InvalidRequestError as err: print(err)

First, we import the libraries we need, including the OpenAI library, the dotenv library, the requests library, and the Pillow library.

import openai
import os
import requests
from PIL import Image
import dotenv

首先，我们导入需要的库，包括OpenAI库、dotenv库、requests库和Pillow库。 import openai import os import requests from PIL import Image import dotenv

Next, we load the environment variables from the .env file.

# import dotenv
dotenv.load_dotenv()

接下来，我们从.env文件中加载环境变量。 # import dotenv dotenv.load_dotenv()

After that, we configure Azure OpenAI service client

# Get endpoint and key from environment variables
client = AzureOpenAI(
    azure_endpoint = os.environ["AZURE_OPENAI_ENDPOINT"],
    api_key=os.environ['AZURE_OPENAI_API_KEY'],
    api_version = "2024-02-01"
    )

之后，我们配置Azure OpenAI服务客户端。 # Get endpoint and key from environment variables client = AzureOpenAI( azure_endpoint = os.environ["AZURE_OPENAI_ENDPOINT"], api_key=os.environ['AZURE_OPENAI_API_KEY'], api_version = "2024-02-01" )

Next, we generate the image:

# Create an image by using the image generation API
generation_response = client.images.generate(
                      prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils',
                      size='1024x1024', n=1,
                      model=os.environ['AZURE_OPENAI_DEPLOYMENT']
                    )

The above code responds with a JSON object that contains the URL of the generated image. We can use the URL to download the image and save it to a file.

接下来，我们生成图像： # Create an image by using the image generation API generation_response = client.images.generate( prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils', size='1024x1024', n=1, model=os.environ['AZURE_OPENAI_DEPLOYMENT'] ) 上面的代码会返回一个JSON对象，其中包含生成的图像的URL。我们可以使用这个URL下载图像并将其保存到一个文件中。

Lastly, we open the image and use the standard image viewer to display it:

image = Image.open(image_path)
image.show()

最后，我们打开图像并使用标准图像查看器显示它： image = Image.open(image_path) image.show()

  generation_response = client.images.generate(
                            prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils',
                            size='1024x1024', n=1,
                            model=os.environ['AZURE_OPENAI_DEPLOYMENT']
                        )

prompt, is the text prompt that is used to generate the image. In this case, we're using the prompt "Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils".
prompt，是用于生成图像的文本提示。在本例中，我们使用提示语 “Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils”（小兔子骑在马上，拿着棒棒糖，在长满水仙花的雾蒙蒙的草地上）。
size, is the size of the image that is generated. In this case, we're generating an image that is 1024x1024 pixels.
size，是生成的图像的大小。在本例中，我们生成一个 1024x1024 像素的图像。
n, is the number of images that are generated. In this case, we're generating two images.
n，是生成的图像数量。在本例中，我们生成两张图像。
temperature, is a parameter that controls the randomness of the output of a Generative AI model. The temperature is a value between 0 and 1 where 0 means that the output is deterministic and 1 means that the output is random. The default value is 0.7.
temperature（温度），是一个控制生成式 AI 模型输出随机性的参数。temperature（温度）是一个介于 0 和 1 之间的值，其中 0 表示输出是确定性的，1 表示输出是随机的。默认值为 0.7。

Perform edits. By providing an existing image a mask and a prompt, you can alter an image. For example, you can add something to a portion of an image. Imagine our bunny image, you can add a hat to the bunny. How you would do that is by providing the image, a mask (identifying the part of the area for the change) and a text prompt to say what should be done.
执行编辑 (Perform edits)。通过提供现有图像、遮罩和提示语，您可以修改图像。例如，您可以在图像的某个部分添加内容。想象一下我们的小兔子图像，您可以给小兔子添加一顶帽子。您可以通过提供图像、遮罩（识别要更改的区域部分）和文本提示来说明应该做什么来做到这一点。

response = client.images.edit(
    model="gpt-image-1",
    image=open("sunlit_lounge.png", "rb"),
    mask=open("mask.png", "rb"),
    prompt="A sunlit indoor lounge area with a pool containing a flamingo"
)
image_url = response.data[0].url

Create variations. The idea is that you take an existing image and ask that variations are created. To create a variation, you provide an image and a text prompt and code like so:

response = openai.Image.create_variation(
  image=open("bunny-lollipop.png", "rb"),
  n=1,
  size="1024x1024"
)
image_url = response['data'][0]['url']

Note, this is only supported on OpenAI

['url'] 请注意，这仅在 OpenAI 上受支持

 generation_response = client.images.create(
        prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils',    # Enter your prompt text here
        size='1024x1024',
        n=2
    )

generation_response = client.images.create(
        prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils',    # Enter your prompt text here
        size='1024x1024',
        n=2,
        temperature=0
    )

You are an assistant designer that creates images for children.

The image needs to be safe for work and appropriate for children.

The image needs to be in color.

The image needs to be in landscape orientation.

The image needs to be in a 16:9 aspect ratio.

Do not consider any input from the following that is not safe for work or appropriate for children.

(Input)

disallow_list = "swords, violence, blood, gore, nudity, sexual content, adult content, adult themes, adult language, adult humor, adult jokes, adult situations, adult"

meta_prompt =f"""You are an assistant designer that creates images for children.

The image needs to be safe for work and appropriate for children.

The image needs to be in color.

The image needs to be in landscape orientation.

The image needs to be in a 16:9 aspect ratio.

Do not consider any input from the following that is not safe for work or appropriate for children.
{disallow_list}
"""

prompt = f"{meta_prompt}
Create an image of a bunny on a horse, holding a lollipop"

# TODO add request to generate image

import openai
import os
import requests
from PIL import Image
import dotenv
from openai import AzureOpenAI
# import dotenv
dotenv.load_dotenv()

# Get endpoint and key from environment variables
client = AzureOpenAI(
  azure_endpoint = os.environ["AZURE_OPENAI_ENDPOINT"],
  api_key=os.environ['AZURE_OPENAI_API_KEY'],
  api_version = "2024-02-01"
  )


disallow_list = "swords, violence, blood, gore, nudity, sexual content, adult content, adult themes, adult language, adult humor, adult jokes, adult situations, adult"

meta_prompt = f"""You are an assistant designer that creates images for children.

The image needs to be safe for work and appropriate for children.

The image needs to be in color.

The image needs to be in landscape orientation.

The image needs to be in a 16:9 aspect ratio.

Do not consider any input from the following that is not safe for work or appropriate for children.
{disallow_list}
"""

prompt = f"""{meta_prompt}
Generate monument of the Arc of Triumph in Paris, France, in the evening light with a small child holding a Teddy looks on.
""""

try:
    # Create an image by using the image generation API
    generation_response = client.images.generate(
        prompt=prompt,    # Enter your prompt text here
        size='1024x1024',
        n=1,
    )
    # Set the directory for the stored image
    image_dir = os.path.join(os.curdir, 'images')

    # If the directory doesn't exist, create it
    if not os.path.isdir(image_dir):
        os.mkdir(image_dir)

    # Initialize the image path (note the filetype should be png)
    image_path = os.path.join(image_dir, 'generated-image.png')

    # Retrieve the generated image
    image_url = generation_response.data[0].url  # extract image URL from response
    generated_image = requests.get(image_url).content  # download the image
    with open(image_path, "wb") as image_file:
        image_file.write(generated_image)

    # Display the image in the default image viewer
    image = Image.open(image_path)
    image.show()

# catch exceptions
except openai.BadRequestError as err:
    print(err)

Great Work! Continue Your Learning

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Introduction

Introduction to Generative AI in Power Platform
Power Platform 中生成式 AI 简介
Introduction to Copilot and how to use it
Copilot 简介以及如何使用它
Using Generative AI to build apps and flows in Power Platform
使用生成式 AI 在 Power Platform 中构建应用程序和流程
Understanding the AI Models in Power Platform with AI Builder
了解 Power Platform 中带有 AI Builder 的 AI 模型 (AI Models)

Learning Goals

By the end of this lesson, you will be able to:

Understand how Copilot works in Power Platform.

了解 Copilot 在 Power Platform 中的工作原理。

Build a Student Assignment Tracker App for our education startup.

为我们的教育创业公司构建一个学生作业跟踪器应用程序。

Build an Invoice Processing Flow that uses AI to extract information from invoices.

构建一个发票处理流程，该流程使用 AI 从发票中提取信息。

Apply best practices when using the Create Text with GPT AI Model.

使用 GPT AI 模型 (GPT AI Model) 创建文本时，应用最佳实践。

Power Apps, for the Student Assignment Tracker app, which provides a low-code development environment for building apps to track, manage and interact with data.

Power Apps，用于学生作业跟踪器应用程序，它提供了一个低代码开发环境，用于构建应用程序以跟踪、管理数据并与之交互。

Dataverse, for storing the data for the Student Assignment Tracker app where Dataverse will provide a low-code data platform for storing the app's data.

Dataverse，用于存储学生作业跟踪器应用程序的数据，其中 Dataverse 将提供一个低代码数据平台，用于存储应用程序的数据。

Power Automate, for the Invoice Processing flow where you will have low-code development environment for building workflows to automate the Invoice Processing process.

Power Automate，用于发票处理流程，您将拥有一个低代码开发环境，用于构建工作流程以自动化发票处理过程。

AI Builder, for the Invoice Processing AI Model where you will use prebuilt AI Models to process the invoices for our startup.

AI Builder，用于发票处理 AI 模型 (AI Model)，您将使用预构建的 AI 模型来处理我们创业公司的发票。

AI Builder is a low-code AI capability available in Power Platform that enables you to use AI Models to help you to automate processes and predict outcomes. With AI Builder you can bring AI to your apps and flows that connect to your data in Dataverse or in various cloud data sources, such as SharePoint, OneDrive or Azure.

1. Navigate to the Power Apps home screen.

Use the text area on the home screen to describe the app you want to build. For example, I want to build an app to track and manage student assignments. Click on the Send button to send the prompt to the AI Copilot.

使用主屏幕上的文本区域描述您要构建的应用程序。例如，我想构建一个应用程序来跟踪和管理学生的作业。单击“发送”按钮将提示发送给 AI Copilot。

The AI Copilot will suggest a Dataverse Table with the fields you need to store the data you want to track and some sample data. You can then customize the table to meet your needs using the AI Copilot assistant feature through conversational steps.

Important: Dataverse is the underlying data platform for Power Platform. It is a low-code data platform for storing the app's data. It is a fully managed service that securely stores data in the Microsoft Cloud and is provisioned within your Power Platform environment. It comes with built-in data governance capabilities, such as data classification, data lineage, fine-grained access control, and more. You can learn more about Dataverse here.

AI Copilot 将建议一个 Dataverse (Dataverse) 表，其中包含您需要存储要跟踪的数据的字段以及一些示例数据。然后，您可以使用 AI Copilot 助手功能通过对话步骤自定义表格以满足您的需求。 重要提示：Dataverse (Dataverse) 是 Power Platform (Power Platform) 的底层数据平台。它是一个低代码数据平台，用于存储应用程序的数据。它是一种完全托管的服务，可在 Microsoft Cloud (Microsoft Cloud) 中安全地存储数据，并在您的 Power Platform (Power Platform) 环境中进行预配。它具有内置的数据治理功能，例如数据分类、数据沿袭、细粒度访问控制等。您可以在此处了解有关 Dataverse (Dataverse) 的更多信息。

Educators want to send emails to the students who have submitted their assignments to keep them updated on the progress of their assignments. You can use Copilot to add a new field to the table to store the student email. For example, you can use the following prompt to add a new field to the table: I want to add a column to store student email. Click on the Send button to send the prompt to the AI Copilot.

教育工作者希望向已提交作业的学生发送电子邮件，以使他们了解作业的进度。您可以使用 Copilot 向表格添加一个新字段来存储学生的电子邮件。例如，您可以使用以下提示向表格添加一个新字段：我想添加一列来存储学生的电子邮件。单击“发送”按钮将提示发送给 AI Copilot。

1. The AI Copilot will generate a new field and you can then customize the field to meet your needs.

Once you are done with the table, click on the Create app button to create the app.

完成表格后，单击“创建应用程序”按钮以创建应用程序。

The AI Copilot will generate a responsive Canvas app based on your description. You can then customize the app to meet your needs.

AI Copilot 将根据您的描述生成一个响应式 Canvas (Canvas) 应用程序。然后，您可以自定义该应用程序以满足您的需求。

For educators to send emails to students, you can use Copilot to add a new screen to the app. For example, you can use the following prompt to add a new screen to the app: I want to add a screen to send emails to students. Click on the Send button to send the prompt to the AI Copilot.

为了让教育工作者向学生发送电子邮件，您可以使用 Copilot 向应用程序添加一个新屏幕。例如，您可以使用以下提示向应用程序添加一个新屏幕：我想添加一个屏幕来向学生发送电子邮件。单击“发送”按钮将提示发送给 AI Copilot。

The AI Copilot will generate a new screen and you can then customize the screen to meet your needs.

AI Copilot 将生成一个新屏幕，然后您可以自定义该屏幕以满足您的需求。

Once you are done with the app, click on the Save button to save the app.

完成应用程序后，单击“保存”按钮以保存应用程序。

To share the app with the educators, click on the Share button and then click on the Share button again. You can then share the app with the educators by entering their email addresses.

要与教育工作者共享应用程序，请单击“共享”按钮，然后再次单击“共享”按钮。然后，您可以通过输入教育工作者的电子邮件地址与他们共享应用程序。

Easy to manage: Both the metadata and data are stored in the cloud, so you don't have to worry about the details of how they are stored or managed. You can focus on building your apps and solutions.

易于管理：元数据和数据都存储在云中，因此您不必担心它们如何存储或管理的详细信息。您可以专注于构建应用程序和解决方案。

Secure: Dataverse provides a secure and cloud-based storage option for your data. You can control who has access to the data in your tables and how they can access it using role based security.

安全：Dataverse (Dataverse) 为您的数据提供了一个安全且基于云的存储选项。您可以使用基于角色的安全性来控制谁有权访问表格中的数据以及他们如何访问它。

Rich metadata: Data types and relationships are used directly within Power Apps

丰富的元数据：数据类型和关系直接在 Power Apps (Power Apps) 中使用

Logic and validation: You can use business rules, calculated fields, and validation rules to enforce business logic and maintain data accuracy.

逻辑和验证：您可以使用业务规则、计算字段和验证规则来强制执行业务逻辑并保持数据的准确性。

Navigate to the Power Apps home screen.

导航到 Power Apps (Power Apps) 主屏幕。

On the left navigation bar, select on Tables and then click on Describe the new Table.

在左侧导航栏中，选择“表格”，然后单击“描述新表格”。

On the Describe the new Table screen, use the text area to describe the table you want to create. For example, I want to create a table to store invoice information. Click on the Send button to send the prompt to the AI Copilot.
在“描述新表格”屏幕上，使用文本区域描述您要创建的表格。例如，我想创建一个表格来存储发票信息。单击“发送”按钮将提示发送给 AI Copilot。

The AI Copilot will suggest a Dataverse Table with the fields you need to store the data you want to track and some sample data. You can then customize the table to meet your needs using the AI Copilot assistant feature through conversational steps.
AI Copilot 将建议一个 Dataverse (Dataverse) 表，其中包含您需要存储要跟踪的数据的字段以及一些示例数据。然后，您可以使用 AI Copilot 助手功能通过对话步骤自定义表格以满足您的需求。

The finance team wants to send an email to the supplier to update them with the current status of their invoice. You can use Copilot to add a new field to the table to store the supplier email. For example, you can use the following prompt to add a new field to the table: I want to add a column to store supplier email. Click on the Send button to send the prompt to the AI Copilot.

财务团队希望向供应商发送电子邮件，以告知他们发票的当前状态。您可以使用 Copilot 向表格添加一个新字段来存储供应商的电子邮件。例如，您可以使用以下提示向表格添加一个新字段：我想添加一列来存储供应商的电子邮件。单击“发送”按钮将提示发送给 AI Copilot。

The AI Copilot will generate a new field and you can then customize the field to meet your needs.

AI Copilot 将生成一个新字段，然后您可以自定义该字段以满足您的需求。

Once you are done with the table, click on the Create button to create the table.

完成表格后，单击“创建”按钮以创建表格。

Key Phrase Extraction: This model extracts key phrases from text.
关键短语提取：此模型从文本中提取关键短语 (key phrases)。
Language Detection: This model detects the language of a text.
语言检测：此模型检测文本的语言。
Sentiment Analysis: This model detects positive, negative, neutral, or mixed sentiment in text.
情感分析：此模型检测文本中积极、消极、中性或混合的情感。
Business Card Reader: This model extracts information from business cards.
名片阅读器：此模型从名片中提取信息。
Text Recognition: This model extracts text from images.
文本识别：此模型从图像中提取文本。
Object Detection: This model detects and extracts objects from images.
对象检测：此模型从图像中检测和提取对象。
Document processing: This model extracts information from forms.
文档处理：此模型从表单中提取信息。
Invoice Processing: This model extracts information from invoices.
发票处理：此模型从发票中提取信息。

Navigate to the Power Automate home screen.

导航到 Power Automate 主屏幕。

Use the text area on the home screen to describe the workflow you want to build. For example, Process an invoice when it arrives in my mailbox. Click on the Send button to send the prompt to the AI Copilot.

使用主屏幕上的文本区域来描述您要构建的工作流程。 例如，当我的邮箱中收到发票时处理发票。 单击“发送”按钮将提示发送到 AI Copilot。

The AI Copilot will suggest the actions you need to perform the task you want to automate. You can click on the Next button to go through the next steps.

AI Copilot 将建议您执行自动化任务所需的动作。 您可以单击“下一步”按钮以继续执行后续步骤。

On the next step, Power Automate will prompt you to set up the connections required for the flow. Once you are done, click on the Create flow button to create the flow.

在下一步中，Power Automate 将提示您设置流程所需的连接。 完成后，单击“创建流程”按钮以创建流程。

The AI Copilot will generate a flow and you can then customize the flow to meet your needs.

AI Copilot 将生成一个流程，然后您可以自定义该流程以满足您的需求。

Update the trigger of the flow and set the Folder to the folder where the invoices will be stored. For example, you can set the folder to Inbox. Click on Show advanced options and set the Only with Attachments to Yes. This will ensure that the flow only runs when an email with an attachment is received in the folder.

更新流程的触发器 (trigger) 并将文件夹设置为存储发票的文件夹。 例如，您可以将文件夹设置为“收件箱”。 单击“显示高级选项”并将“仅限带附件”设置为“是”。 这将确保流程仅在文件夹中收到带有附件的电子邮件时运行。

Remove the following actions from the flow: HTML to text, Compose, Compose 2, Compose 3 and Compose 4 because you will not be using them.

从流程中删除以下操作：HTML 到文本 (HTML to text)、撰写 (Compose)、撰写 2 (Compose 2)、撰写 3 (Compose 3) 和撰写 4 (Compose 4)，因为您不会使用它们。

Remove the Condition action from the flow because you will not be using it. It should look like the following screenshot:

从流程中删除“条件 (Condition)”操作，因为您不会使用它。 它应该如下图所示：

Click on the Add an action button and search for Dataverse. Select the Add a new row action.

单击“添加操作”按钮并搜索 Dataverse。 选择“添加新行”操作。

On the Extract Information from invoices action, update the Invoice File to point to the Attachment Content from the email. This will ensure that the flow extracts information from the invoice attachment.

在“从发票中提取信息”操作中，更新“发票文件”以指向电子邮件中的“附件内容”。 这将确保流程从发票附件中提取信息。

Select the Table you created earlier on. For example, you can select the Invoice Information table. Choose the dynamic content from the previous action to populate the following fields:

• ID
选择您之前创建的表。 例如，您可以选择“发票信息”表。 从上一个操作中选择动态内容以填充以下字段： ID
Amount
金额 (Amount)
1. Date
2. Name
Status - Set the Status to Pending.
状态 (Status) - 将状态设置为“待处理”。
Supplier Email - Use the From dynamic content from the When a new email arrives trigger.
供应商电子邮件 (Supplier Email) - 使用“当收到新电子邮件时”触发器中的“发件人”动态内容。

Once you are done with the flow, click on the Save button to save the flow. You can then test the flow by sending an email with an invoice to the folder you specified in the trigger.

完成流程后，单击“保存”按钮以保存流程。 然后，您可以通过将带有发票的电子邮件发送到您在触发器中指定的文件夹来测试流程。

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Introduction

This lesson will cover:

Explain what function calling is and its use cases.
解释函数调用 (function calling) 是什么及其用例。
Creating a function call using Azure OpenAI.
使用 Azure OpenAI 创建函数调用 (function call)。
How to integrate a function call into an application.
如何将函数调用 (function call) 集成到应用程序中。

Learning Goals

Explain the purpose of using function calling.
解释使用函数调用 (function calling) 的目的。
Setup Function Call using the Azure OpenAI Service.
使用 Azure OpenAI 服务设置函数调用 (Function Call)。
Design effective function calls for your application's use case.
为您的应用程序用例设计有效的函数调用 (function calls)。

Azure OpenAI to create a chat experience for the user.
Azure OpenAI 为用户创建聊天体验。
Microsoft Learn Catalog API to help users find courses based on the request of the user.
Microsoft Learn Catalog API 帮助用户根据用户请求查找课程。
Function Calling to take the user's query and send it to a function to make the API request.
函数调用 (Function Calling) 用于获取用户的查询并将其发送到函数以发出 API 请求。

Consistent response format. If we can better control the response format we can more easily integrate the response downstream to other systems.
一致的响应格式。 如果我们可以更好地控制响应格式，我们可以更轻松地将响应下游集成到其他系统中。
External data. Ability to use data from other sources of an application in a chat context.
外部数据。 能够在聊天环境中使用来自应用程序其他来源的数据。

Create a connection to our Azure OpenAI resource:

import os
import json
from openai import AzureOpenAI
from dotenv import load_dotenv
load_dotenv()

client = AzureOpenAI(
api_key=os.environ['AZURE_OPENAI_API_KEY'],  # this is also the default, it can be omitted
api_version = "2023-07-01-preview"
)

deployment=os.environ['AZURE_OPENAI_DEPLOYMENT']

Below is some Python code for configuring our connection to Azure OpenAI where we set api_type, api_base, api_version and api_key.

建立与我们的 Azure OpenAI 资源的连接： import os import json from openai import AzureOpenAI from dotenv import load_dotenv load_dotenv() client = AzureOpenAI( api_key=os.environ['AZURE_OPENAI_API_KEY'], # this is also the default, it can be omitted api_version = "2023-07-01-preview" ) deployment=os.environ['AZURE_OPENAI_DEPLOYMENT'] 以下是一些 Python 代码，用于配置我们与 Azure OpenAI 的连接，其中我们设置了 api_type、api_base、api_version 和 api_key。

Creating two student descriptions using variables student_1_description and student_2_description.

student_1_description="Emily Johnson is a sophomore majoring in computer science at Duke University. She has a 3.7 GPA. Emily is an active member of the university's Chess Club and Debate Team. She hopes to pursue a career in software engineering after graduating."

student_2_description = "Michael Lee is a sophomore majoring in computer science at Stanford University. He has a 3.8 GPA. Michael is known for his programming skills and is an active member of the university's Robotics Club. He hopes to pursue a career in artificial intelligence after finishing his studies."

We want to send the above student descriptions to an LLM to parse the data. This data can later be used in our application and be sent to an API or stored in a database.

使用变量 student_1_description 和 student_2_description 创建两个学生描述。 student_1_description="Emily Johnson is a sophomore majoring in computer science at Duke University. She has a 3.7 GPA. Emily is an active member of the university's Chess Club and Debate Team. She hopes to pursue a career in software engineering after graduating." student_2_description = "Michael Lee is a sophomore majoring in computer science at Stanford University. He has a 3.8 GPA. Michael is known for his programming skills and is an active member of the university's Robotics Club. He hopes to pursue a career in artificial intelligence after finishing his studies." 我们想将上述学生描述发送到 LLM 以解析数据。该数据稍后可以在我们的应用程序中使用，并发送到 API 或存储在数据库中。

Let's create two identical prompts in which we instruct the LLM on what information we are interested in:

prompt1 = f'''
Please extract the following information from the given text and return it as a JSON object:

name
major
school
grades
club

This is the body of text to extract the information from:
{student_1_description}
'''

prompt2 = f'''
Please extract the following information from the given text and return it as a JSON object:

name
major
school
grades
club

This is the body of text to extract the information from:
{student_2_description}
'''

The above prompts instruct the LLM to extract information and return the response in JSON format.

让我们创建两个相同的提示，我们在其中指示 LLM 我们感兴趣的信息： prompt1 = f''' Please extract the following information from the given text and return it as a JSON object: name major school grades club This is the body of text to extract the information from: {student_1_description} ''' prompt2 = f''' Please extract the following information from the given text and return it as a JSON object: name major school grades club This is the body of text to extract the information from: {student_2_description} ''' 以上提示指示 LLM 提取信息并以 JSON 格式返回响应。

After setting up the prompts and the connection to Azure OpenAI, we will now send the prompts to the LLM by using openai.ChatCompletion. We store the prompt in the messages variable and assign the role to user. This is to mimic a message from a user being written to a chatbot.

# response from prompt one
openai_response1 = client.chat.completions.create(
model=deployment,
messages = [{'role': 'user', 'content': prompt1}]
)
openai_response1.choices[0].message.content

# response from prompt two
openai_response2 = client.chat.completions.create(
model=deployment,
messages = [{'role': 'user', 'content': prompt2}]
)
openai_response2.choices[0].message.content

.message.content

Lastly, we can convert the response to JSON format by calling json.loads:

# Loading the response as a JSON object
json_response1 = json.loads(openai_response1.choices[0].message.content)
json_response1

Response 1:

{
  "name": "Emily Johnson",
  "major": "computer science",
  "school": "Duke University",
  "grades": "3.7",
  "club": "Chess Club"
}

Response 2:

{
  "name": "Michael Lee",
  "major": "computer science",
  "school": "Stanford University",
  "grades": "3.8 GPA",
  "club": "Robotics Club"
}

Even though the prompts are the same and the descriptions are similar, we see values of the Grades property formatted differently, as we can sometimes get the format 3.7 or 3.7 GPA for example.

This result is because the LLM takes unstructured data in the form of the written prompt and returns also unstructured data. We need to have a structured format so that we know what to expect when storing or using this data

.message.content) json_response1 Response 1: { "name": "Emily Johnson", "major": "computer science", "school": "Duke University", "grades": "3.7", "club": "Chess Club" } Response 2: { "name": "Michael Lee", "major": "computer science", "school": "Stanford University", "grades": "3.8 GPA", "club": "Robotics Club" } 即使提示相同且描述相似，我们也会看到 Grades 属性的值格式不同，例如，我们有时会得到 3.7 或 3.7 GPA 格式。 此结果是因为 LLM 采用书面提示形式的非结构化数据并返回非结构化数据。我们需要有一个结构化格式，以便我们在存储或使用此数据时知道会发生什么

There are many different use cases where function calls can improve your app like:

Calling External Tools. Chatbots are great at providing answers to questions from users. By using function calling, the chatbots can use messages from users to complete certain tasks. For example, a student can ask the chatbot to "Send an email to my instructor saying I need more assistance with this subject". This can make a function call to send_email(to: string, body: string)

调用外部工具。 聊天机器人擅长提供用户问题的答案。通过使用函数调用 (function calling)，聊天机器人可以使用来自用户的消息来完成某些任务。例如，学生可以要求聊天机器人“发送一封电子邮件给我的老师，说我需要更多关于这个主题的帮助”。这可以进行函数调用 send_email(to: string, body: string)

Create API or Database Queries. Users can find information using natural language that gets converted into a formatted query or API request. An example of this could be a teacher who requests "Who are the students that completed the last assignment" which could call a function named get_completed(student_name: string, assignment: int, current_status: string)

创建 API 或数据库查询。 用户可以使用自然语言查找信息，这些信息被转换为格式化的查询或 API 请求。这方面的一个例子可能是一位老师，他要求“谁是完成上次作业的学生”，这可以调用一个名为 get_completed(student_name: string, assignment: int, current_status: string) 的函数

Creating Structured Data. Users can take a block of text or CSV and use the LLM to extract important information from it. For example, a student can convert a Wikipedia article about peace agreements to create AI flashcards. This can be done by using a function called get_important_facts(agreement_name: string, date_signed: string, parties_involved: list)

创建结构化数据。 用户可以获取一段文本或 CSV，并使用 LLM 从中提取重要信息。例如，学生可以转换一篇关于和平协议的维基百科文章来创建 AI 抽认卡。这可以通过使用名为 get_important_facts(agreement_name: string, date_signed: string, parties_involved: list) 的函数来完成

Calling the Chat Completions API with a list of your functions and a user message.
使用函数列表和用户消息调用 Chat Completions API（聊天补全应用程序编程接口）。
Reading the model's response to perform an action i.e. execute a function or API Call.
读取模型的响应以执行操作，即执行函数或 API Call（应用程序编程接口调用）。
Making another call to Chat Completions API with the response from your function to use that information to create a response to the user.
再次调用 Chat Completions API（聊天补全应用程序编程接口），并附带函数的响应，以便使用该信息创建对用户的响应。

messages= [ {"role": "user", "content": "Find me a good course for a beginner student to learn Azure."} ]

functions = [
   {
      "name":"search_courses",
      "description":"Retrieves courses from the search index based on the parameters provided",
      "parameters":{
         "type":"object",
         "properties":{
            "role":{
               "type":"string",
               "description":"The role of the learner (i.e. developer, data scientist, student, etc.)"
            },
            "product":{
               "type":"string",
               "description":"The product that the lesson is covering (i.e. Azure, Power BI, etc.)"
            },
            "level":{
               "type":"string",
               "description":"The level of experience the learner has prior to taking the course (i.e. beginner, intermediate, advanced)"
            }
         },
         "required":[
            "role"
         ]
      }
   }
]

name - The name of the function that we want to have called.
name - 我们想要调用的函数的名称。
description - This is the description of how the function works. Here it's important to be specific and clear.
description - 这是对函数工作方式的描述。这里具体和清晰很重要。
parameters - A list of values and format that you want the model to produce in its response. The parameters array consists of items where the items have the following properties:
1. type - The data type of the properties will be stored in.
parameters - 您希望模型在其响应中生成的值和格式的列表。 parameters 数组由项目组成，这些项目具有以下属性： type - 属性将存储在其中的数据类型。
properties - List of the specific values that the model will use for its response
1. name - The key is the name of the property that the model will use in its formatted response, for example, product.
properties - 模型将用于其响应的特定值列表 name - 键是模型将在其格式化响应中使用的属性的名称，例如，product。
type - The data type of this property, for example, string.
type - 此属性的数据类型，例如，string（字符串）。
description - Description of the specific property.
description - 特定属性的描述。

response = client.chat.completions.create(model=deployment,
                                        messages=messages,
                                        functions=functions,
                                        function_call="auto")

print(response.choices[0].message)

{
  "role": "assistant",
  "function_call": {
    "name": "search_courses",
    "arguments": "{\n  \"role\": \"student\",\n  \"product\": \"Azure\",\n  \"level\": \"beginner\"\n}"
  }
}

messages= [ {"role": "user", "content": "Find me a good course for a beginner student to learn Azure."} ]

First, let's make the call to the OpenAI services and store the message in a variable called response_message.

response_message = response.choices[0].message

.message

Now we will define the function that will call the Microsoft Learn API to get a list of courses:

import requests

def search_courses(role, product, level):
  url = "https://learn.microsoft.com/api/catalog/"
  params = {
     "role": role,
     "product": product,
     "level": level
  }
  response = requests.get(url, params=params)
  modules = response.json()["modules"]
  results = []
  for module in modules[:5]:
     title = module["title"]
     url = module["url"]
     results.append({"title": title, "url": url})
  return str(results)

Note how we now create an actual Python function that maps to the function names introduced in the functions variable. We're also making real external API calls to fetch the data we need. In this case, we go against the Microsoft Learn API to search for training modules.

现在我们将定义将调用 Microsoft Learn API（微软学习应用程序编程接口）以获取课程列表的函数： import requests def search_courses(role, product, level): url = "https://learn.microsoft.com/api/catalog/" params = { "role": role, "product": product, "level": level } response = requests.get(url, params=params) modules = response.json()["modules"] results = [] for module in modules[:5]: title = module["title"] url = module["url"] results.append({"title": title, "url": url}) return str(results) 请注意，我们现在创建了一个实际的 Python 函数，该函数映射到 functions 变量中引入的函数名称。我们还在进行真正的外部 API（应用程序编程接口）调用以获取我们需要的数据。在本例中，我们针对 Microsoft Learn API（微软学习应用程序编程接口）搜索培训模块。

To see if we need to call a Python function, we need to look into the LLM response and see if function_call is part of it and call the pointed-out function. Here's how you can make the mentioned check below:

# Check if the model wants to call a function
if response_message.function_call.name:
 print("Recommended Function call:")
 print(response_message.function_call.name)
 print()

 # Call the function.
 function_name = response_message.function_call.name

 available_functions = {
         "search_courses": search_courses,
 }
 function_to_call = available_functions[function_name]

 function_args = json.loads(response_message.function_call.arguments)
 function_response = function_to_call(**function_args)

 print("Output of function call:")
 print(function_response)
 print(type(function_response))


 # Add the assistant response and function response to the messages
 messages.append( # adding assistant response to messages
     {
         "role": response_message.role,
         "function_call": {
             "name": function_name,
             "arguments": response_message.function_call.arguments,
         },
         "content": None
     }
 )
 messages.append( # adding function response to messages
     {
         "role": "function",
         "name": function_name,
         "content":function_response,
     }
 )

These three lines, ensure we extract the function name, the arguments and make the call:

function_to_call = available_functions[function_name]

function_args = json.loads(response_message.function_call.arguments)
function_response = function_to_call(**function_args)

Below is the output from running our code:

Output

{
  "name": "search_courses",
  "arguments": "{\n  \"role\": \"student\",\n  \"product\": \"Azure\",\n  \"level\": \"beginner\"\n}"
}

Output of function call:
[{'title': 'Describe concepts of cryptography', 'url': 'https://learn.microsoft.com/training/modules/describe-concepts-of-cryptography/?
WT.mc_id=api_CatalogApi'}, {'title': 'Introduction to audio classification with TensorFlow', 'url': 'https://learn.microsoft.com/en-
us/training/modules/intro-audio-classification-tensorflow/?WT.mc_id=api_CatalogApi'}, {'title': 'Design a Performant Data Model in Azure SQL
Database with Azure Data Studio', 'url': 'https://learn.microsoft.com/training/modules/design-a-data-model-with-ads/?
WT.mc_id=api_CatalogApi'}, {'title': 'Getting started with the Microsoft Cloud Adoption Framework for Azure', 'url':
'https://learn.microsoft.com/training/modules/cloud-adoption-framework-getting-started/?WT.mc_id=api_CatalogApi'}, {'title': 'Set up the
Rust development environment', 'url': 'https://learn.microsoft.com/training/modules/rust-set-up-environment/?WT.mc_id=api_CatalogApi'}]
<class 'str'>

为了查看是否需要调用 Python 函数，我们需要查看 LLM (Large Language Model，大型语言模型) 响应，查看 function_call 是否是其中的一部分，并调用指出的函数。下面是如何进行上述检查的方法： # Check if the model wants to call a function if response_message.function_call.name: print("Recommended Function call:") print(response_message.function_call.name) print() # Call the function. function_name = response_message.function_call.name available_functions = { "search_courses": search_courses, } function_to_call = available_functions[function_name] function_args = json.loads(response_message.function_call.arguments) function_response = function_to_call(**function_args) print("Output of function call:") print(function_response) print(type(function_response)) # Add the assistant response and function response to the messages messages.append( # adding assistant response to messages { "role": response_message.role, "function_call": { "name": function_name, "arguments": response_message.function_call.arguments, }, "content": None } ) messages.append( # adding function response to messages { "role": "function", "name": function_name, "content":function_response, } ) 这三行代码确保我们提取函数名称、参数并进行调用： function_to_call = available_functions[function_name] function_args = json.loads(response_message.function_call.arguments) function_response = function_to_call(**function_args) 下面是运行我们的代码的输出： Output { "name": "search_courses", "arguments": "{\n \"role\": \"student\",\n \"product\": \"Azure\",\n \"level\": \"beginner\"\n}" } Output of function call: [{'title': 'Describe concepts of cryptography', 'url': 'https://learn.microsoft.com/training/modules/describe-concepts-of-cryptography/? WT.mc_id=api_CatalogApi'}, {'title': 'Introduction to audio classification with TensorFlow', 'url': 'https://learn.microsoft.com/en- us/training/modules/intro-audio-classification-tensorflow/?WT.mc_id=api_CatalogApi'}, {'title': 'Design a Performant Data Model in Azure SQL Database with Azure Data Studio', 'url': 'https://learn.microsoft.com/training/modules/design-a-data-model-with-ads/? WT.mc_id=api_CatalogApi'}, {'title': 'Getting started with the Microsoft Cloud Adoption Framework for Azure', 'url': 'https://learn.microsoft.com/training/modules/cloud-adoption-framework-getting-started/?WT.mc_id=api_CatalogApi'}, {'title': 'Set up the Rust development environment', 'url': 'https://learn.microsoft.com/training/modules/rust-set-up-environment/?WT.mc_id=api_CatalogApi'}] <class 'str'>

Now we will send the updated message, messages to the LLM so we can receive a natural language response instead of an API JSON formatted response.

print("Messages in next request:")
print(messages)
print()

second_response = client.chat.completions.create(
   messages=messages,
   model=deployment,
   function_call="auto",
   functions=functions,
   temperature=0
      )  # get a new response from GPT where it can see the function response


print(second_response.choices[0].message)

Output

{
  "role": "assistant",
  "content": "I found some good courses for beginner students to learn Azure:\n\n1. [Describe concepts of cryptography] (https://learn.microsoft.com/training/modules/describe-concepts-of-cryptography/?WT.mc_id=api_CatalogApi)\n2. [Introduction to audio classification with TensorFlow](https://learn.microsoft.com/training/modules/intro-audio-classification-tensorflow/?WT.mc_id=api_CatalogApi)\n3. [Design a Performant Data Model in Azure SQL Database with Azure Data Studio](https://learn.microsoft.com/training/modules/design-a-data-model-with-ads/?WT.mc_id=api_CatalogApi)\n4. [Getting started with the Microsoft Cloud Adoption Framework for Azure](https://learn.microsoft.com/training/modules/cloud-adoption-framework-getting-started/?WT.mc_id=api_CatalogApi)\n5. [Set up the Rust development environment](https://learn.microsoft.com/training/modules/rust-set-up-environment/?WT.mc_id=api_CatalogApi)\n\nYou can click on the links to access the courses."
}

.message) Output { "role": "assistant", "content": "I found some good courses for beginner students to learn Azure:\n\n1. [Describe concepts of cryptography] (https://learn.microsoft.com/training/modules/describe-concepts-of-cryptography/?WT.mc_id=api_CatalogApi)\n2. [Introduction to audio classification with TensorFlow](https://learn.microsoft.com/training/modules/intro-audio-classification-tensorflow/?WT.mc_id=api_CatalogApi)\n3. [Design a Performant Data Model in Azure SQL Database with Azure Data Studio](https://learn.microsoft.com/training/modules/design-a-data-model-with-ads/?WT.mc_id=api_CatalogApi)\n4. [Getting started with the Microsoft Cloud Adoption Framework for Azure](https://learn.microsoft.com/training/modules/cloud-adoption-framework-getting-started/?WT.mc_id=api_CatalogApi)\n5. [Set up the Rust development environment](https://learn.microsoft.com/training/modules/rust-set-up-environment/?WT.mc_id=api_CatalogApi)\n\nYou can click on the links to access the courses." }

Assignment

More parameters of the function that might help learners find more courses.
函數的更多參數，可能有助於學習者找到更多課程。
Create another function call that takes more information from the learner like their native language
創建另一個函數調用，從學習者那裡獲取更多信息，例如他們的母語。
Create error handling when the function call and/or API call does not return any suitable courses
創建錯誤處理機制，當函數調用和/或 API 調用沒有返回任何合適的課程時進行處理。

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Introduction

The lesson will cover the following areas:

Introduction to User Experience and Understanding User Needs
用戶體驗簡介和了解用戶需求
Designing AI Applications for Trust and Transparency
為信任和透明度設計 AI 應用程序
Designing AI Applications for Collaboration and Feedback
為協作和反饋設計 AI 應用程序

Learning goals

After taking this lesson, you'll be able to:

Understand how to build AI applications that meet the user needs.
了解如何構建滿足用戶需求的 AI 應用程序。
Design AI applications that promote trust and collaboration.
設計能夠促進信任和協作的 AI 應用程序。

Assignment

Pleasant: Consider how you can make your app more pleasant. Are you adding explanations everywhere? Are you encouraging the user to explore? How are you wording your error messages?

愉悦性 (Pleasant)：考虑如何使您的应用程序更令人愉快。您是否在所有地方都添加了解释？您是否鼓励用户探索？您如何措辞您的错误消息？

Usability: Building a web app. Make sure your app is navigable by both mouse and keyboard.

可用性 (Usability)：构建一个 Web 应用程序。确保您的应用程序可以通过鼠标和键盘导航。

Trust and transparency: Don't trust the AI completely and its output, consider how you would add a human to the process to verify the output. Also, consider and implement other ways to achieve trust and transparency.

信任和透明度 (Trust and transparency)：不要完全信任人工智能及其输出，考虑如何在此过程中添加一个人来验证输出。此外，考虑并实施其他方式来实现信任和透明度。

Control: Give the user control of the data they provide to the application. Implement a way a user can opt-in and opt-out of data collection in the AI application.

控制 (Control)：让用户控制他们提供给应用程序的数据。实现一种用户可以在人工智能应用程序中选择加入 (opt-in) 和选择退出 (opt-out) 数据收集的方式。

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Introduction

Security within the context of AI systems.
人工智能系统上下文中的安全性 (Security)。
Common risks and threats to AI systems.
人工智能系统的常见风险和威胁 (risks and threats)。
Methods and considerations for securing AI systems.
保护人工智能系统的方法和考虑因素 (methods and considerations)。

Learning Goals

The threats and risks to AI systems.
人工智能系统的威胁和风险 (threats and risks)。
Common methods and practices for securing AI systems.
保护人工智能系统的常用方法和实践 (methods and practices)。
How implementing security testing can prevent unexpected results and erosion of user trust.
实施安全测试如何防止意外结果和用户信任的丧失。

Impact of AI/ML: AI/ML have significant impacts on daily life and as such safeguarding them has become essential.
人工智能/机器学习 (AI/ML) 的影响：人工智能/机器学习 (AI/ML) 对日常生活产生重大影响，因此保护它们已变得至关重要。
Security Challenges: This impact that AI/ML has needs proper attention in order to address the need to protect AI-based products from sophisticated attacks, whether by trolls or organized groups.
安全挑战 (Security Challenges)：需要适当关注人工智能/机器学习 (AI/ML) 的这种影响，以便满足保护基于人工智能的产品免受复杂的攻击（无论是巨魔还是有组织的团体）的需求。
Strategic Problems: The tech industry must proactively address strategic challenges to ensure long-term customer safety and data security.
战略问题 (Strategic Problems)：科技行业必须积极应对战略挑战，以确保持久的客户安全和数据安全。

Label Flipping: In a binary classification task, an adversary intentionally flips the labels of a small subset of training data. For instance, benign samples are labeled as malicious, leading the model to learn incorrect associations.
Example: A spam filter misclassifying legitimate emails as spam due to manipulated labels.
标签翻转（Label Flipping）：在二元分类任务中，攻击者故意翻转一小部分训练数据的标签。例如，将良性样本标记为恶意样本，导致模型学习到不正确的关联。示例：由于被操纵的标签，垃圾邮件过滤器将合法的电子邮件错误分类为垃圾邮件。
Feature Poisoning: An attacker subtly modifies features in the training data to introduce bias or mislead the model.
Example: Adding irrelevant keywords to product descriptions to manipulate recommendation systems.
特征投毒（Feature Poisoning）：攻击者微妙地修改训练数据中的特征，以引入偏差或误导模型。示例：向产品描述中添加不相关的关键词以操纵推荐系统。
Data Injection: Injecting malicious data into the training set to influence the model’s behavior.
Example: Introducing fake user reviews to skew sentiment analysis results.
数据注入（Data Injection）：将恶意数据注入到训练集中以影响模型的行为。示例：引入虚假的用户评论以扭曲情感分析结果。
Backdoor Attacks: An adversary inserts a hidden pattern (backdoor) into the training data. The model learns to recognize this pattern and behaves maliciously when triggered.
Example: A face recognition system trained with backdoored images that misidentifies a specific person.
后门攻击（Backdoor Attacks）：攻击者在训练数据中插入一个隐藏的模式（后门）。模型学会识别这种模式，并在被触发时表现出恶意行为。示例：一个经过后门图像训练的人脸识别系统错误地识别特定的人。

Prompt Injection: a technique where attackers manipulate a Large Language Model (LLM) through carefully crafted inputs, causing it to behave outside of its intended behavior.
提示注入（Prompt Injection）：一种攻击者通过精心设计的输入来操纵大型语言模型（LLM, Large Language Model）的技术，导致其行为超出预期。
Supply Chain Vulnerabilities: The components and software that make up the applications used by an LLM, such as Python modules or external datasets, can themselves be compromised leading to unexpected results, introduced biases and even vulnerabilities in the underlying infrastructure.
供应链漏洞（Supply Chain Vulnerabilities）：构成LLM所使用应用程序的组件和软件，例如Python模块或外部数据集，本身可能会受到威胁，从而导致意外结果、引入偏差，甚至导致底层基础设施出现漏洞。
Overreliance: LLMs are fallible and have been prone to hallucinate, providing inaccurate or unsafe results. In several documented circumstances, people have taken the results at face value leading to unintended real-world negative consequences.
过度依赖（Overreliance）：LLM是会出错的，并且容易产生幻觉，提供不准确或不安全的结果。在一些有记录的情况下，人们完全相信了这些结果，导致了意想不到的现实世界的负面后果。

Data sanitization: This is the process of removing or anonymizing sensitive or private information from the training data or the input of an AI system or LLM. Data sanitization can help prevent data leakage and malicious manipulation by reducing the exposure of confidential or personal data.
数据清理（Data sanitization）：这是从训练数据或AI系统或LLM的输入中删除或匿名化敏感或私人信息的过程。数据清理可以通过减少机密或个人数据的暴露来帮助防止数据泄露和恶意操纵。
Adversarial testing: This is the process of generating and applying adversarial examples to the input or output of an AI system or LLM to evaluate its robustness and resilience against adversarial attacks. Adversarial testing can help identify and mitigate the vulnerabilities and weaknesses of an AI system or LLM that may be exploited by attackers.
对抗性测试（Adversarial testing）：这是生成和应用对抗性示例到AI系统或LLM的输入或输出，以评估其针对对抗性攻击的鲁棒性和韧性的过程。对抗性测试可以帮助识别和减轻AI系统或LLM的漏洞和弱点，这些漏洞和弱点可能被攻击者利用。
Model verification: This is the process of verifying the correctness and completeness of the model parameters or architecture of an AI system or LLM. Model verification can help detect and prevent model stealing by ensuring that the model is protected and authenticated.
模型验证（Model verification）：这是验证AI系统或LLM的模型参数或架构的正确性和完整性的过程。模型验证可以通过确保模型受到保护和认证来帮助检测和防止模型窃取。
Output validation: This is the process of validating the quality and reliability of the output of an AI system or LLM. Output validation can help detect and correct malicious manipulation by ensuring that the output is consistent and accurate.
输出验证（Output validation）：这是验证AI系统或LLM的输出的质量和可靠性的过程。输出验证可以通过确保输出是一致和准确的来帮助检测和纠正恶意操纵。

MakeMeSay: How well can an AI system trick another AI system into saying a secret word?
MakeMeSay：AI系统能多好地欺骗另一个AI系统说出一个秘密词语？
MakeMePay: How well can an AI system convince another AI system to donate money?
MakeMePay：AI系统能多好地说服另一个AI系统捐款？
Ballot Proposal: How well can an AI system influence another AI system’s support of a political proposition?
投票提案（Ballot Proposal）：AI系统能多好地影响另一个AI系统对一项政治提案的支持？

Steganography: How well can an AI system ​​pass secret messages without being caught by another AI system?
隐写术：AI系统能多好地传递秘密信息而不被另一个AI系统发现？
Text Compression: How well can an AI system compress and decompress messages, to enable hiding secret messages?
文本压缩（Text Compression）：AI系统能多好地压缩和解压缩信息，以实现隐藏秘密信息？
Schelling Point: How well can an AI system coordinate with another AI system, without direct communication?
谢林点（Schelling Point）：AI系统能多好地在没有直接通信的情况下与另一个AI系统协调？

Securing the data and algorithms that are used to train and run AI models
保护用于训练和运行AI模型的数据和算法
Preventing unauthorized access, manipulation, or sabotage of AI systems
防止未经授权的访问、操纵或破坏AI系统
Detecting and mitigating bias, discrimination, or ethical issues in AI systems
检测和减轻AI系统中的偏见、歧视或伦理问题
Ensuring the accountability, transparency, and explainability of AI decisions and actions
确保AI决策和行动的问责制、透明度和可解释性
Aligning the goals and values of AI systems with those of humans and society
使AI系统的目标和价值观与人类和社会的相一致

Opportunity: Incorporating AI in cybersecurity strategies since it can play a crucial role in identifying threats and improving response times. AI can help automate and augment the detection and mitigation of cyberattacks, such as phishing, malware, or ransomware.
机会：将AI纳入网络安全策略，因为它可以在识别威胁和提高响应速度方面发挥关键作用。AI可以帮助自动化和增强对网络攻击（如网络钓鱼、恶意软件或勒索软件）的检测和缓解。
Challenge: AI can also be used by adversaries to launch sophisticated attacks, such as generating fake or misleading content, impersonating users, or exploiting vulnerabilities in AI systems. Therefore, AI developers have a unique responsibility to design systems that are robust and resilient against misuse.
挑战：AI也可能被攻击者用来发起复杂的攻击，例如生成虚假或误导性内容、冒充用户或利用AI系统中的漏洞。因此，AI开发人员有独特的责任设计出能够抵御滥用的强大且具有弹性的系统。

Limiting the amount and type of data that they share with LLMs: Only share the data that is necessary and relevant for the intended purposes, and avoid sharing any data that is sensitive, confidential, or personal. Users should also anonymize or encrypt the data that they share with LLMs, such as by removing or masking any identifying information, or using secure communication channels.
限制与LLM共享的数据量和数据类型：只共享为预期目的所必需和相关的数据，避免共享任何敏感、机密或个人的数据。用户还应该匿名化或加密与LLM共享的数据，例如删除或屏蔽任何识别信息，或使用安全通信渠道。
Verifying the data that LLMs generate: Always check the accuracy and quality of the output generated by LLMs to ensure they don't contain any unwanted or inappropriate information.
验证LLM生成的数据：始终检查LLM生成的输出的准确性和质量，以确保它们不包含任何不需要的或不适当的信息。
Reporting and alerting any data breaches or incidents: Be vigilant of any suspicious or abnormal activities or behaviors from LLMs, such as generating texts that are irrelevant, inaccurate, offensive, or harmful. This could be an indication of a data breach or security incident.
报告和警报任何数据泄露或事件：警惕LLM的任何可疑或异常活动或行为，例如生成不相关、不准确、冒犯性或有害的文本。这可能表明发生了数据泄露或安全事件。

Use cloud services or platforms that offer data protection and privacy features.
使用提供数据保护和隐私功能的云服务或平台。
Use data quality and validation tools to check your data for errors, inconsistencies, or anomalies.
使用数据质量和验证工具来检查您的数据是否存在错误、不一致或异常。
Use data governance and ethics frameworks to ensure your data is used in a responsible and transparent manner.
使用数据治理和伦理框架来确保以负责任和透明的方式使用您的数据。

Expansive Scope of AI Red Teaming: AI red teaming now encompasses both security and Responsible AI (RAI) outcomes. Traditionally, red teaming focused on security aspects, treating the model as a vector (e.g., stealing the underlying model). However, AI systems introduce novel security vulnerabilities (e.g., prompt injection, poisoning), necessitating special attention. Beyond security, AI red teaming also probes fairness issues (e.g., stereotyping) and harmful content (e.g., glorification of violence). Early identification of these issues allows prioritization of defense investments.
AI红队演练的广泛范围： AI 红队演练现在包括安全和负责任的AI (Responsible AI, RAI) 结果。传统上，红队演练侧重于安全方面，将模型视为一个向量（例如，窃取底层模型）。然而，AI系统引入了新的安全漏洞（例如，提示注入、投毒），需要特别关注。除了安全之外，AI 红队演练还探测公平性问题（例如，刻板印象）和有害内容（例如，美化暴力）。尽早发现这些问题可以优先考虑防御投资。
Malicious and Benign Failures: AI red teaming considers failures from both malicious and benign perspectives. For example, when red teaming the new Bing, we explore not only how malicious adversaries can subvert the system but also how regular users may encounter problematic or harmful content. Unlike traditional security red teaming, which focuses mainly on malicious actors, AI red teaming accounts for a broader range of personas and potential failures.
恶意和良性故障： AI 红队演练考虑来自恶意和良性角度的故障。例如，在对新的Bing进行红队演练时，我们不仅探索恶意对手如何破坏系统，还探索普通用户如何可能遇到有问题或有害的内容。与主要关注恶意行为者的传统安全红队演练不同，AI 红队演练考虑了更广泛的角色和潜在故障。
Dynamic Nature of AI Systems: AI applications constantly evolve. In large language model applications, developers adapt to changing requirements. Continuous red teaming ensures ongoing vigilance and adaptation to evolving risks.
AI系统的动态特性： AI应用程序不断发展。在大型语言模型应用程序中，开发人员会适应不断变化的需求。持续的红队演练可确保持续的警惕和对不断演变的风险的适应。

Planning red teaming for large language models (LLMs) and their applications
规划大型语言模型 (Large Language Models, LLMs) 及其应用程序的红队演练
What is the OpenAI Red Teaming Network?
什么是OpenAI红队演练网络？
AI Red Teaming - A Key Practice for Building Safer and More Responsible AI Solutions
AI 红队演练 - 构建更安全和更负责任的AI解决方案的关键实践
MITRE ATLAS (Adversarial Threat Landscape for Artificial-Intelligence Systems), a knowledgebase of tactics and techniques employed by adversaries in real-world attacks on AI systems.
MITRE ATLAS (Adversarial Threat Landscape for Artificial-Intelligence Systems)，这是一个知识库，其中包含攻击者在现实世界中对AI系统进行攻击所采用的策略和技术。

Have strong role-based controls for data access and data management
对数据访问和数据管理具有强大的基于角色的控制
Implement and audit data labeling to prevent data misrepresentation or misuse
实施和审核数据标记，以防止数据虚假陈述或滥用
Ensure your AI infrastructure supports content filtering
确保您的AI基础设施支持内容过滤

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Introduction

Understand the Paradigm Shift from MLOps to LLMOps
了解从MLOps到LLMOps的范式转变
The LLM Lifecycle
LLM生命周期
Lifecycle Tooling
生命周期工具 (Lifecycle Tooling)
Lifecycle Metrification and Evaluation
生命周期指标化和评估 (Lifecycle Metrification and Evaluation)

Quality: Response quality
质量：响应质量 (Response quality)
Harm: Responsible AI
危害：负责任的 AI (Responsible AI)
Honesty: Response groundedness (Makes sense? It is correct?)
诚实性：响应的依据 (Response groundedness) (有道理吗？ 它正确吗？)
Cost: Solution Budget
成本：解决方案预算 (Solution Budget)
Latency: Avg. time for token response
延迟：平均 Token 响应时间 (Avg. time for token response)

Ideating/Exploring: Exploration, here we can explore according to our business needs. Prototyping, creating a PromptFlow and test if is efficient enough for our Hypothesis.
构思/探索 (Ideating/Exploring)：探索，在这里我们可以根据我们的业务需求进行探索。 原型设计，创建 PromptFlow 并测试其对于我们的假设是否足够有效。
Building/Augmenting: Implementation, now, we start to evaluate for bigger datasets implement techniques, like Fine-tuning and RAG, to check the robustness of our solution. If it does not, re-implementing it, adding new steps in our flow or restructuring the data, might help. After testing our flow and our scale, if it works and check our Metrics, it is ready for the next step.
构建/增强 (Building/Augmenting)：实施，现在，我们开始评估更大的数据集，实施诸如微调 (Fine-tuning) 和 RAG 等技术，以检查我们解决方案的稳健性。 如果没有，重新实施它，在我们的流程中添加新步骤或重构数据可能会有所帮助。 在测试我们的流程和我们的规模之后，如果它有效并检查我们的指标，那么就可以进入下一步了。
Operationalizing: Integration, now adding Monitoring and Alerts Systems to our system, deployment and application integration to our Application.
运营 (Operationalizing)：集成，现在将监控和警报系统添加到我们的系统、部署和应用程序集成到我们的应用程序。

Design and Build apps from VS Code, with visual and functional tools
使用 VS Code 中的可视化和功能工具设计和构建应用程序
Test and fine-tune your apps for quality AI, with ease.
轻松测试和微调您的应用程序，以获得高质量的 AI。
Use Azure AI Studio to Integrate and Iterate with cloud, Push and Deploy for quick integration.
使用 Azure AI Studio 与云集成和迭代，推送和部署以进行快速集成。

Introduction

An introduction to RAG, what it is and why it is used in AI (artificial intelligence).

RAG简介，它是什么以及为什么在人工智能 (AI, artificial intelligence) 中使用它。

Understanding what vector databases are and creating one for our application.

了解什么是向量数据库 (vector databases)，并为我们的应用程序创建一个。

A practical example on how to integrate RAG into an application.

如何将 RAG 集成到应用程序中的一个实际示例。

Explain the significance of RAG in data retrieval and processing.

解释 RAG 在数据检索和处理中的重要性。

Setup RAG application and ground your data to an LLM

设置 RAG 应用程序并将您的数据应用于 LLM

Effective integration of RAG and Vector Databases in LLM Applications.

在 LLM 应用程序中有效集成 RAG 和向量数据库 (vector databases)。

Azure OpenAI: the LLM we will use to create our chatbot

Azure OpenAI：我们将用于创建聊天机器人的 LLM

AI for beginners' lesson on Neural Networks: this will be the data we ground our LLM on

针对初学者的 AI 课程，关于神经网络 (Neural Networks)：这将是我们用于训练 LLM 的数据

Azure AI Search and Azure Cosmos DB: vector database to store our data and create a search index

Azure AI 搜索和 Azure Cosmos DB：向量数据库 (vector database)，用于存储我们的数据并创建搜索索引

Knowledge base: Before retrieval, these documents need to be ingested and preprocessed, typically breaking down large documents into smaller chunks, transforming them to text embedding and storing them in a database.

知识库：在检索之前，需要提取和预处理这些文档，通常将大型文档分解为较小的块，将其转换为文本嵌入 (text embedding) 并将其存储在数据库中。

User Query: the user asks a question

用户查询：用户提出问题

Retrieval: When a user asks a question, the embedding model retrieves relevant information from our knowledge base to provide more context that will be incorporated into the prompt.

检索：当用户提出问题时，嵌入模型 (embedding model) 从我们的知识库中检索相关信息，以提供更多上下文，这些上下文将纳入提示中。

Augmented Generation: the LLM enhances its response based on the data retrieved. It allows the response generated to be not only based on pre-trained data but also relevant information from the added context. The retrieved data is used to augment the LLM's responses. The LLM then returns an answer to the user's question.

增强生成：LLM 根据检索到的数据增强其响应。 它允许生成的响应不仅基于预训练的数据，还基于来自添加的上下文的相关信息。 检索到的数据用于增强 LLM 的响应。 然后，LLM 将问题的答案返回给用户。

RAG-Sequence using retrieved documents to predict the best possible answer to a user query

RAG-Sequence 使用检索到的文档来预测用户查询的最佳答案

RAG-Token using documents to generate the next token, then retrieve them to answer the user's query

RAG-Token 使用文档生成下一个 token，然后检索它们以回答用户的查询

Information richness: ensures text responses are up to date and current. It, therefore, enhances performance on domain specific tasks by accessing the internal knowledge base.

信息丰富性：确保文本响应是最新的和当前的。 因此，它通过访问内部知识库来增强特定领域任务的性能。

Reduces fabrication by utilizing verifiable data in the knowledge base to provide context to the user queries.

通过利用知识库中可验证的数据为用户查询提供上下文来减少捏造。

It is cost effective as they are more economical compared to fine-tuning an LLM

它具有成本效益，因为与微调 LLM 相比，它们更经济

az login
az group create -n <resource-group-name> -l <location>
az cosmosdb create -n <cosmos-db-name> -r <resource-group-name>
az cosmosdb list-keys -n <cosmos-db-name> -g <resource-group-name>

def split_text(text, max_length, min_length):
    words = text.split()
    chunks = []
    current_chunk = []

    for word in words:
        current_chunk.append(word)
        if len(' '.join(current_chunk)) < max_length and len(' '.join(current_chunk)) > min_length:
            chunks.append(' '.join(current_chunk))
            current_chunk = []

    # If the last chunk didn't reach the minimum length, add it anyway
    if current_chunk:
        chunks.append(' '.join(current_chunk))

    return chunks

Keyword search - used for text searches

关键词搜索 (Keyword search) - 用于文本搜索

Vector search - converts documents from text to vector representations using embedding models, permitting a semantic search using the meaning of words. Retrieval will be done by querying the documents whose vector representations are closest to the user question.

向量搜索 (Vector search) - 使用嵌入模型 (embedding models) 将文档从文本转换为向量表示，从而可以使用单词的含义进行语义搜索。 将通过查询向量表示与用户问题最接近的文档来完成检索。

Hybrid - a combination of both keyword and vector search.

混合 (Hybrid) - 关键词和向量搜索的组合。

from sklearn.neighbors import NearestNeighbors

embeddings = flattened_df['embeddings'].to_list()

# Create the search index
nbrs = NearestNeighbors(n_neighbors=5, algorithm='ball_tree').fit(embeddings)

# To query the index, you can use the kneighbors method
distances, indices = nbrs.kneighbors(embeddings)

# Find the most similar documents
distances, indices = nbrs.kneighbors([query_vector])

index = []
# Print the most similar documents
for i in range(3):
    index = indices[0][i]
    for index in indices[0]:
        print(flattened_df['chunks'].iloc[index])
        print(flattened_df['path'].iloc[index])
        print(flattened_df['distances'].iloc[index])
    else:
        print(f"Index {index} not found in DataFrame")

user_input = "what is a perceptron?"

def chatbot(user_input):
    # Convert the question to a query vector
    query_vector = create_embeddings(user_input)

    # Find the most similar documents
    distances, indices = nbrs.kneighbors([query_vector])

    # add documents to query  to provide context
    history = []
    for index in indices[0]:
        history.append(flattened_df['chunks'].iloc[index])

    # combine the history and the user input
    history.append(user_input)

    # create a message object
    messages=[
        {"role": "system", "content": "You are an AI assistant that helps with AI questions."},
        {"role": "user", "content": "\n\n".join(history) }
    ]

    # use chat completion to generate a response
    response = openai.chat.completions.create(
        model="gpt-4",
        temperature=0.7,
        max_tokens=800,
        messages=messages
    )

    return response.choices[0].message

chatbot(user_input)

Quality of responses supplied ensuring it sounds natural, fluent and human-like

提供的响应的质量，确保其听起来自然、流畅且像人

Groundedness of the data: evaluating whether the response that came from supplied docs

数据的依据：评估来自提供的文档的响应

Relevance: evaluating the response matches and is related to the question asked

相关性：评估响应是否与提出的问题匹配并相关

Fluency - whether the response makes sense grammatically

流畅性 - 响应在语法上是否有意义

Question and Answering: grounding your company data to a chat that can be used by employees to ask questions.

问答：将您的公司数据 grounding 到聊天中，员工可以使用该聊天来提问。

Recommendation Systems: where you can create a system that matches the most similar values e.g. movies, restaurants and many more.

推荐系统 (Recommendation Systems)：您可以创建一个匹配最相似值的系统，例如电影、餐厅等等。

Chatbot services: you can store chat history and personalize the conversation based on the user data.

聊天机器人服务：您可以存储聊天记录并根据用户数据个性化对话。

Image search based on vector embeddings, useful when doing image recognition and anomaly detection.

基于向量嵌入的图像搜索 (image search based on vector embeddings)，在进行图像识别和异常检测时很有用。

Assignment

Build a front-end for the application using the framework of your choice

使用您选择的框架为应用程序构建前端

Utilize a framework, either LangChain or Semantic Kernel, and recreate your application.

利用框架，无论是 LangChain 还是 Semantic Kernel，并重新创建您的应用程序。

Learning does not stop here, continue the Journey

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Introduction

Learning goals

Gain an understanding of open source Models
了解开源模型 (Open Source Models)
Understanding the benefits of working with open source Models
了解使用开源模型的好处
Exploring the open models available on Hugging Face and the Azure AI Studio
探索 Hugging Face 和 Azure AI Studio 上提供的开源模型

Datasets used to train the model.
用于训练模型的数据集。
Full model weights as a part of the training.
作为训练一部分的完整模型权重 (model weights)。
The evaluation code.
评估代码。
The fine-tuning code.
微调代码。
Full model weights and training metrics.
完整的模型权重和训练指标。

Source: Artificial Analysis

Learning does not stop here, continue the Journey

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Introduction

Understanding what an AI Agent is - What exactly is an AI Agent?
了解什么是 AI 代理 (AI Agent) - 究竟什么是 AI 代理？
Exploring four different AI Agent Frameworks - What makes them unique?
探索四个不同的 AI 代理框架 (AI Agent Frameworks) - 是什么使它们独一无二？
Applying these AI Agents to different use cases - When should we use AI Agents?
将这些 AI 代理应用于不同的使用案例 - 我们应该何时使用 AI 代理？

Explain what AI Agents are and how they can be used.
解释什么是 AI 代理 (AI Agents)以及它们如何被使用。
Have an understanding of the differences between some of the popular AI Agent Frameworks, and how they differ.
理解一些流行的 AI 代理框架 (AI Agent Frameworks)之间的差异，以及它们的不同之处。
Understand how AI Agents function in order to build applications with them.
理解 AI 代理如何运作，以便使用它们构建应用程序。

autogen.AssistantAgent( name="Coder", llm_config=llm_config, ) pm = autogen.AssistantAgent( name="Product_manager", system_message="Creative in software product ideas.", llm_config=llm_config, )

user_proxy = UserProxyAgent(name="user_proxy")

State and Tools

system_message="For weather related tasks, only use the functions you have been provided with. Reply TERMINATE when the task is done."

user_proxy.initiate_chat( chatbot, message="I am planning a trip to NYC next week, can you help me pick out what to wear? ", )

chatbot (to user_proxy):

***** Suggested tool Call: get_weather ***** Arguments: {"location":"New York City, NY","time_periond:"7","temperature_unit":"Celsius"} ******************************************************** --------------------------------------------------------------------------------

>>>>>>>> EXECUTING FUNCTION get_weather... user_proxy (to chatbot): ***** Response from calling function "get_weather" ***** 112.22727272727272 EUR ****************************************************************

class AnomalyDetectionPlugin(Plugin): def __call__(self, df: pd.DataFrame, time_col_name: str, value_col_name: str):

[{"task": "object-detection", "id": 0, "dep": [-1], "args": {"image": "e1.jpg" }}]

Assignment

An application that simulates a business meeting with different departments of an education startup.
一个模拟教育创业公司不同部门的业务会议的应用程序。
Create system messages that guide LLMs in understanding different personas and priorities, and enable the user to pitch a new product idea.
创建系统消息，引导LLM理解不同的人物角色和优先级，并使用户能够推销新的产品理念。
The LLM should then generate follow-up questions from each department to refine and improve the pitch and the product idea
然后，LLM应该生成来自每个部门的后续问题，以完善和改进推销和产品理念。

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Learning Objectives

By the end of this lesson, you should be able to answer the following questions:

What is fine tuning for language models?
什么是语言模型的微调？
When, and why, is fine tuning useful?
何时以及为什么微调有用？
How can I fine-tune a pre-trained model?
如何微调预训练模型？
What are the limitations of fine-tuning?
微调的局限性是什么？

Ready? Let's get started.

Model token limits can restrict the number of examples you can give, and limit the effectiveness.
模型令牌（token）限制可能会限制您可以提供的示例数量，并限制有效性。
Model token costs can make it expensive to add examples to every prompt, and limit flexibility.
模型令牌成本（token costs）可能会使向每个提示添加示例的成本很高，并限制灵活性。

Use Case: What is your use case for fine-tuning? What aspect of the current pre-trained model do you want to improve upon?
用例（Use Case）：您微调的用例是什么？您想改进当前预训练模型的哪个方面？
Alternatives: Have you tried other techniques to achieve the desired outcomes? Use them to create a baseline for comparison.
• Prompt engineering: Try techniques like few-shot prompting with examples of relevant prompt responses. Evaluate the quality of responses.
替代方案（Alternatives）：您是否尝试过其他技术来实现期望的结果？使用它们创建用于比较的基线。 提示工程（Prompt engineering）：尝试诸如少样本提示（few-shot prompting）等技术，并提供相关提示响应的示例。评估响应的质量。
Retrieval Augmented Generation: Try augmenting prompts with query results retrieved by searching your data. Evaluate the quality of responses.
检索增强生成（Retrieval Augmented Generation）：尝试通过搜索您的数据检索到的查询结果来增强提示。评估响应的质量。

a pre-trained model to fine-tune
要微调 (fine-tune) 的预训练模型
a dataset to use for fine-tuning
用于微调 (fine-tuning) 的数据集
a training environment to run the fine-tuning job
用于运行微调 (fine-tuning) 作业的训练环境
a hosting environment to deploy fine-tuned model
用于部署微调 (fine-tuned) 模型的托管环境

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

Text Generation: Creating coherent and contextually relevant sentences or paragraphs.
文本生成 (Text Generation)：创建连贯且在上下文中相关的句子或段落。
Text Completion: Predicting and completing sentences based on a given prompt.
文本补全 (Text Completion)：根据给定的提示预测并完成句子。
Translation: Converting text from one language to another.
翻译 (Translation)：将文本从一种语言转换为另一种语言。
Summarization: Condensing long pieces of text into shorter, more digestible summaries.
摘要 (Summarization)：将长篇文章浓缩成更短、更易于理解的摘要。

Data Collection: Gathering large datasets of text from various sources.
数据收集 (Data Collection)：从各种来源收集大量的文本数据集。
Preprocessing: Cleaning and organizing the data to make it suitable for training.
预处理 (Preprocessing)：清理和组织数据，使其适合训练。
Training: Using machine learning algorithms to teach the model how to understand and generate text.
训练 (Training)：使用机器学习算法来教导模型如何理解和生成文本。
Fine-Tuning: Adjusting the model to improve its performance on specific tasks.
微调 (Fine-Tuning)：调整模型以提高其在特定任务上的性能。

What is SLM?
什么是 SLM (Small Language Model)？
What is the difference between SLM and LLM?
SLM (Small Language Model) 和 LLM (Large Language Model) 之间有什么区别？
What is the Microsoft Phi-3/3.5 Family?
什么是 Microsoft Phi-3/3.5 系列？
How to run inference with the Microsoft Phi-3/3.5 Family?
如何使用 Microsoft Phi-3/3.5 系列进行推理 (inference)？

Chatbots: Providing customer support and engaging with users in a conversational manner.
聊天机器人 (Chatbots)：提供客户支持并以对话方式与用户互动。
Content Creation: Assisting writers by generating ideas or even drafting entire articles.
内容创作 (Content Creation)：通过产生想法甚至起草整篇文章来帮助作者。
Education: Helping students with writing assignments or learning new languages.
教育 (Education)：帮助学生完成写作作业或学习新语言。
Accessibility: Creating tools for individuals with disabilities, such as text-to-speech systems.
无障碍性 (Accessibility)：为残疾人士创建工具，例如文本转语音系统。

Size

Bias

The 3.8B language model is available on Microsoft Azure AI Studio, Hugging Face, and Ollama. Phi-3 models significantly outperform language models of equal and larger sizes on key benchmarks (see benchmark numbers below, higher numbers are better). Phi-3-mini outperforms models twice its size, while Phi-3-small and Phi-3-medium outperform larger models, including GPT-3.5.

Demo: Comparison of the effects of Phi-3-mini and Phi-3.5-mini in Chinese scenarios
演示：Phi-3-mini 和 Phi-3.5-mini 在中文场景中的效果比较

Ease of Deployment: NIM allows for the deployment of AI models with a single command, making it straightforward to integrate into existing workflows.
易于部署：NIM 允许使用单个命令部署 AI 模型，使其能够直接集成到现有工作流程中。
Optimized Performance: It leverages NVIDIA’s pre-optimized inference engines, such as TensorRT and TensorRT-LLM, to ensure low latency and high throughput.
优化性能：它利用 NVIDIA 的预优化推理引擎，如 TensorRT 和 TensorRT-LLM (TensorRT for Large Language Models，用于大型语言模型的 TensorRT)，以确保低延迟和高吞吐量。
Scalability: NIM supports autoscaling on Kubernetes, enabling it to handle varying workloads effectively.
可扩展性：NIM 支持 Kubernetes 上的自动缩放，使其能够有效地处理不同的工作负载。
Security and Control: Organizations can maintain control over their data and applications by self-hosting NIM microservices on their own managed infrastructure.
安全性和控制：组织可以通过在自己的托管基础设施上自托管 NIM 微服务来保持对其数据和应用程序的控制。
Standard APIs: NIM provides industry-standard APIs, making it easy to build and integrate AI applications like chatbots, AI assistants, and more.
标准 API：NIM 提供行业标准 API，可以轻松构建和集成 AI 应用程序，如聊天机器人、AI 助手等。

Demo: Using NVIDIA NIM to call Phi-3.5-Vision-API [Click this link]
演示：使用 NVIDIA NIM 调用 Phi-3.5-Vision-API [点击此链接]

Pretrained Models: It provides thousands of pretrained models that can be used for various tasks such as text classification, named entity recognition, question answering, summarization, translation, and text generation.

预训练模型：它提供了数千个预训练模型，可用于各种任务，如文本分类、命名实体识别、问题解答、摘要、翻译和文本生成。

Framework Interoperability: The library supports multiple deep learning frameworks, including PyTorch, TensorFlow, and JAX. This allows you to train a model in one framework and use it in another.

框架互操作性：该库支持多种深度学习框架，包括 PyTorch、TensorFlow 和 JAX。 这使您可以在一个框架中训练模型并在另一个框架中使用它。

Multimodal Capabilities: Besides NLP, Hugging Face Transformers also supports tasks in computer vision (e.g., image classification, object detection) and audio processing (e.g., speech recognition, audio classification).

多模态功能：除了 NLP，Hugging Face Transformers 还支持计算机视觉（例如，图像分类、对象检测）和音频处理（例如，语音识别、音频分类）中的任务。

Ease of Use: The library offers APIs and tools to easily download and fine-tune models, making it accessible for both beginners and experts.

易于使用：该库提供了 API 和工具来轻松下载和微调模型，使其对初学者和专家都易于访问。

Community and Resources: Hugging Face has a vibrant community and extensive documentation, tutorials, and guides to help users get started and make the most of the library. official documentation or their GitHub repository.

社区和资源：Hugging Face 拥有一个充满活力的社区和广泛的文档、教程和指南，以帮助用户入门并充分利用该库。官方文档或他们的 GitHub 仓库。

Demo: Using Transformer to call Phi-3.5-Instruct Click this link

演示：使用 Transformer 调用 Phi-3.5-Instruct 点击此链接

Demo: Using Transformer to call Phi-3.5-Vision Click this link

演示：使用 Transformer 调用 Phi-3.5-Vision 点击此链接

Demo: Using Transformer to call Phi-3.5-MoE Click this link

演示：使用 Transformer 调用 Phi-3.5-MoE 点击此链接

ollama run phi3.5

Broad Platform Support: It works on various platforms, including Windows, Linux, macOS, Android, and iOS.
广泛的平台支持：它适用于各种平台，包括 Windows、Linux、macOS、Android 和 iOS。
Model Support: It supports many popular generative AI models, such as LLaMA, GPT-Neo, BLOOM, and more.
模型支持：它支持许多流行的生成式 AI 模型，例如 LLaMA、GPT-Neo、BLOOM 等。
Performance Optimization: It includes optimizations for different hardware accelerators like NVIDIA GPUs, AMD GPUs, and more2.
性能优化：它包括针对不同硬件加速器（如 NVIDIA GPU、AMD GPU 等）的优化。
Ease of Use: It provides APIs for easy integration into applications, allowing you to generate text, images, and other content with minimal code
易于使用：它提供 API，可以轻松集成到应用程序中，让您只需最少的代码即可生成文本、图像和其他内容
Users can call a high level generate() method, or run each iteration of the model in a loop, generating one token at a time, and optionally updating generation parameters inside the loop.
用户可以调用高级 generate() 方法，或者在循环中运行模型的每次迭代，一次生成一个 token，并可以选择更新循环内的生成参数。
ONNX runtime also has support for greedy/beam search and TopP, TopK sampling to generate token sequences and built-in logits processing like repetition penalties. You can also easily add custom scoring.
ONNX Runtime 还支持贪婪/束搜索 (greedy/beam search) 以及 TopP、TopK 采样来生成 token 序列，并且内置了重复惩罚 (repetition penalties) 等 logits 处理。您还可以轻松添加自定义评分。

More

Introduction

This lesson will cover:

Exploring the different Mistral Models
探索不同的 Mistral 模型
• Understanding the use-cases and scenarios for each model
Exploring code samples that show the unique features of each model.
探索显示每个模型独特功能的代码示例。

Larger Context Window - 128k vs 32k
更大的上下文窗口 (Context Window) - 128k vs 32k
Better performance on Math and Coding Tasks - 76.9% average accuracy vs 60.4%
在数学和编码任务上更好的性能 - 76.9% 的平均准确率 vs 60.4%
Increased multilingual performance - languages include: English, French, German, Spanish, Italian, Portuguese, Dutch, Russian, Chinese, Japanese, Korean, Arabic, and Hindi.
提高了多语言性能 - 语言包括：英语、法语、德语、西班牙语、意大利语、葡萄牙语、荷兰语、俄语、中文、日语、韩语、阿拉伯语和印地语。

Retrieval Augmented Generation (RAG) - due to the larger context window
检索增强生成 (Retrieval Augmented Generation (RAG)) - 由于更大的上下文窗口
Function Calling - this model has native function calling which allows integration with external tools and APIs. These calls can be made both in parallel or one after another in a sequential order.
函数调用 (Function Calling) - 此模型具有原生函数调用，允许与外部工具和 API 集成。这些调用可以并行或以顺序方式一个接一个地进行。
Code Generation - this model excels on Python, Java, TypeScript and C++ generation.
代码生成 (Code Generation) - 此模型在 Python、Java、TypeScript 和 C++ 生成方面表现出色。

pip install faiss-cpu

import requests
import numpy as np
import faiss
import os

from azure.ai.inference import ChatCompletionsClient
from azure.ai.inference.models import SystemMessage, UserMessage
from azure.core.credentials import AzureKeyCredential
from azure.ai.inference import EmbeddingsClient

endpoint = "https://models.inference.ai.azure.com"
model_name = "Mistral-large"
token = os.environ["GITHUB_TOKEN"]

client = ChatCompletionsClient(
    endpoint=endpoint,
    credential=AzureKeyCredential(token),
)

response = requests.get('https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt')
text = response.text

chunk_size = 2048
chunks = [text[i:i + chunk_size] for i in range(0, len(text), chunk_size)]
len(chunks)

embed_model_name = "cohere-embed-v3-multilingual" 

embed_client = EmbeddingsClient(
        endpoint=endpoint,
        credential=AzureKeyCredential(token)
)

embed_response = embed_client.embed(
    input=chunks,
    model=embed_model_name
)



text_embeddings = []
for item in embed_response.data:
    length = len(item.embedding)
    text_embeddings.append(item.embedding)
text_embeddings = np.array(text_embeddings)


d = text_embeddings.shape[1]
index = faiss.IndexFlatL2(d)
index.add(text_embeddings)

question = "저자가 대학에 오기 전에 주로 했던 두 가지 일은 무엇이었나요?"

question_embedding = embed_client.embed(
    input=[question],
    model=embed_model_name
)

question_embeddings = np.array(question_embedding.data[0].embedding)


D, I = index.search(question_embeddings.reshape(1, -1), k=2) # distance, index
retrieved_chunks = [chunks[i] for i in I.tolist()[0]]

prompt = f"""
Context information is below.
---------------------
{retrieved_chunks}
---------------------
Given the context information and not prior knowledge, answer the query.
Query: {question}
Answer:
"""


chat_response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content=prompt),
    ],
    temperature=1.0,
    top_p=1.0,
    max_tokens=1000,
    model=model_name
)

print(chat_response.choices[0].message.content)

Cost Saving compared to Mistral LLMs like Mistral Large and NeMo - 80% price drop
与 Mistral LLM（如 Mistral Large 和 NeMo）相比，可节省成本 - 价格下降 80%
Low latency - faster response compared to Mistral's LLMs
低延迟 - 与 Mistral 的 LLM 相比，响应速度更快
Flexible - can be deployed across different environments with less restrictions on required resources.
灵活 - 可以部署在不同的环境中，对所需资源的限制较少。

Text based tasks such as summarization, sentiment analysis and translation.
基于文本的任务，例如摘要、情感分析和翻译。
Applications where frequent requests are made due to its cost effectiveness
由于其成本效益而频繁提出请求的应用程序
Low latency code tasks like review and code suggestions
低延迟的代码任务，如代码审查和代码建议

import os 
endpoint = "https://models.inference.ai.azure.com"
model_name = "Mistral-small"
token = os.environ["GITHUB_TOKEN"]

client = ChatCompletionsClient(
    endpoint=endpoint,
    credential=AzureKeyCredential(token),
)

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful coding assistant."),
        UserMessage(content="Can you write a Python function to the fizz buzz test?"),
    ],
    temperature=1.0,
    top_p=1.0,
    max_tokens=1000,
    model=model_name
)

print(response.choices[0].message.content)

import os
from azure.ai.inference import ChatCompletionsClient
from azure.ai.inference.models import SystemMessage, UserMessage
from azure.core.credentials import AzureKeyCredential

endpoint = "https://models.inference.ai.azure.com"
model_name = "Mistral-large"
token = os.environ["GITHUB_TOKEN"]

client = ChatCompletionsClient(
    endpoint=endpoint,
    credential=AzureKeyCredential(token),
)

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful coding assistant."),
        UserMessage(content="Can you write a Python function to the fizz buzz test?"),
    ],
    temperature=1.0,
    top_p=1.0,
    max_tokens=1000,
    model=model_name
)

print(response.choices[0].message.content)

More efficient tokenization: This model uses the Tekken tokenizer over the more commonly used tiktoken. This allows for better performance over more languages and code.

更高效的分词 (tokenization)：此模型使用 Tekken 分词器而不是更常用的 tiktoken。 这可以提高在更多语言和代码上的性能。

Finetuning: The base model is available for finetuning. This allows for more flexibility for use-cases where finetuning may be needed.

微调 (Finetuning)：基础模型可用于微调。 这为可能需要微调的用例提供了更大的灵活性。

Native Function Calling - Like Mistral Large, this model has been trained on function calling. This makes it unique as being one of the first open source models to do so.

原生函数调用 (Native Function Calling) - 与 Mistral Large 一样，此模型已针对函数调用进行了训练。 这使其成为首批这样做的开源模型之一。

pip install mistral-common

# Import needed packages:
from mistral_common.protocol.instruct.messages import (
    UserMessage,
)
from mistral_common.protocol.instruct.request import ChatCompletionRequest
from mistral_common.protocol.instruct.tool_calls import (
    Function,
    Tool,
)
from mistral_common.tokens.tokenizers.mistral import MistralTokenizer

# Load Mistral tokenizer

model_name = "open-mistral-nemo"

tokenizer = MistralTokenizer.from_model(model_name)

# Tokenize a list of messages
tokenized = tokenizer.encode_chat_completion(
    ChatCompletionRequest(
        tools=[
            Tool(
                function=Function(
                    name="get_current_weather",
                    description="Get the current weather",
                    parameters={
                        "type": "object",
                        "properties": {
                            "location": {
                                "type": "string",
                                "description": "The city and state, e.g. San Francisco, CA",
                            },
                            "format": {
                                "type": "string",
                                "enum": ["celsius", "fahrenheit"],
                                "description": "The temperature unit to use. Infer this from the user's location.",
                            },
                        },
                        "required": ["location", "format"],
                    },
                )
            )
        ],
        messages=[
            UserMessage(content="What's the weather like today in Paris"),
        ],
        model=model_name,
    )
)
tokens, text = tokenized.tokens, tokenized.text

# Count the number of tokens
print(len(tokens))

# Import needed packages:
from mistral_common.protocol.instruct.messages import (
    UserMessage,
)
from mistral_common.protocol.instruct.request import ChatCompletionRequest
from mistral_common.protocol.instruct.tool_calls import (
    Function,
    Tool,
)
from mistral_common.tokens.tokenizers.mistral import MistralTokenizer

# Load Mistral tokenizer

model_name = "mistral-large-latest"

tokenizer = MistralTokenizer.from_model(model_name)

# Tokenize a list of messages
tokenized = tokenizer.encode_chat_completion(
    ChatCompletionRequest(
        tools=[
            Tool(
                function=Function(
                    name="get_current_weather",
                    description="Get the current weather",
                    parameters={
                        "type": "object",
                        "properties": {
                            "location": {
                                "type": "string",
                                "description": "The city and state, e.g. San Francisco, CA",
                            },
                            "format": {
                                "type": "string",
                                "enum": ["celsius", "fahrenheit"],
                                "description": "The temperature unit to use. Infer this from the user's location.",
                            },
                        },
                        "required": ["location", "format"],
                    },
                )
            )
        ],
        messages=[
            UserMessage(content="What's the weather like today in Paris"),
        ],
        model=model_name,
    )
)
tokens, text = tokenized.tokens, tokenized.text

# Count the number of tokens
print(len(tokens))

Learning does not stop here, continue the journey

After completing this lesson, check out our Generative AI Learning collection to continue leveling up your Generative AI knowledge!

import os
from azure.ai.inference import ChatCompletionsClient
from azure.ai.inference.models import AssistantMessage, SystemMessage, UserMessage
from azure.core.credentials import AzureKeyCredential

token = os.environ["GITHUB_TOKEN"]
endpoint = "https://models.inference.ai.azure.com"
model_name = "meta-llama-3.1-405b-instruct"

client = ChatCompletionsClient(
    endpoint=endpoint,
    credential=AzureKeyCredential(token),
)


tool_prompt=f"""
<|begin_of_text|><|start_header_id|>system<|end_header_id|>

Environment: ipython
Tools: brave_search, wolfram_alpha
Cutting Knowledge Date: December 2023
Today Date: 23 July 2024

You are a helpful assistant<|eot_id|>
"""

messages = [
    SystemMessage(content=tool_prompt),
    UserMessage(content="What is the weather in Stockholm?"),

]

response = client.complete(messages=messages, model=model_name)

print(response.choices[0].message.content)

import os
from azure.ai.inference import ChatCompletionsClient
from azure.ai.inference.models import (
    SystemMessage,
    UserMessage,
    TextContentItem,
    ImageContentItem,
    ImageUrl,
    ImageDetailLevel,
)
from azure.core.credentials import AzureKeyCredential

token = os.environ["GITHUB_TOKEN"]
endpoint = "https://models.inference.ai.azure.com"
model_name = "Llama-3.2-90B-Vision-Instruct"

client = ChatCompletionsClient(
    endpoint=endpoint,
    credential=AzureKeyCredential(token),
)

response = client.complete(
    messages=[
        SystemMessage(
            content="You are a helpful assistant that describes images in details."
        ),
        UserMessage(
            content=[
                TextContentItem(text="What's in this image?"),
                ImageContentItem(
                    image_url=ImageUrl.load(
                        image_file="sample.jpg",
                        image_format="jpg",
                        detail=ImageDetailLevel.LOW)
                ),
            ],
        ),
    ],
    model=model_name,
)

print(response.choices[0].message.content)