diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index cf0ad4b7b..744dd07e8 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -1,4 +1,4 @@ -// Adopting the default Github codespaces-jupyter template as starter +// Adopting the default GitHub codespaces-jupyter template as starter // https://github.com/github/codespaces-jupyter { "name": "Generative AI For Beginners", diff --git a/.github/markdown_checker.py b/.github/markdown_checker.py deleted file mode 100644 index 5ecccabd4..000000000 --- a/.github/markdown_checker.py +++ /dev/null @@ -1,262 +0,0 @@ -#!/usr/bin/env python3 -""" -Module providing automatic checks functionality to markdown files -following the some Guidelines -""" -import os -import argparse -import re - - -def main() -> None: - """Main program get inputs and run checks""" - - # get input arguments directory, function to run - in_arg = get_input_args() - - lessons = get_lessons_paths(in_arg.dir) - - # iterate over the files to validate the content - for lesson_folder_name, lessons_array in lessons.items(): - for lesson_file_name in lessons_array: - file_path = os.path.join( - in_arg.dir, - lesson_folder_name, - lesson_file_name) - if in_arg.dir == lesson_folder_name: - file_path = os.path.join(lesson_folder_name, lesson_file_name) - if "check_broken_paths" in in_arg.func: - formatted_output = check_broken_links(file_path, "path" , "broken") - if formatted_output: - print(formatted_output) - if "check_paths_tracking" in in_arg.func: - formatted_output = check_broken_links(file_path, "path" , "tracking") - if formatted_output: - print(formatted_output) - if "check_urls_tracking" in in_arg.func: - formatted_output = check_broken_links(file_path, "url" , "tracking") - if formatted_output: - print(formatted_output) - if "check_urls_locale" in in_arg.func: - formatted_output = check_broken_links(file_path, "url" , "locale") - if formatted_output: - print(formatted_output) - -# Helper Functions - -def get_lessons_paths(root_path: str) -> dict: - """function to compile a dictionary of directories - - Keyword arguments: - root_path -- directory to go through looking for md files - Return: formatted dictionary with directories as key and an array of files as values - """ - lessons = {} - # add root path to the dictionary - lessons[root_path] = [] - pass_list = ['CODE_OF_CONDUCT.md', 'CONTRIBUTING.md', 'SECURITY.md'] - # get lessons folders - for item in os.listdir(root_path): - if os.path.isdir(os.path.join(root_path, item)): - lessons[item] = [] - - # get lesson exercises (md, ipynb files) - for lesson, _ in lessons.items(): - if lesson != root_path: - for item in os.listdir(os.path.join(root_path, lesson)): - # check for translations directories - if os.path.isdir(os.path.join(root_path, lesson, item)): - for sub_item in os.listdir(os.path.join(root_path, lesson, item)): - if os.path.isdir(os.path.join(root_path, lesson, item, sub_item)): - for sub_item2 in os.listdir(os.path.join(root_path, lesson, item, sub_item)): - # check for .md and .ipynb files and store them - if sub_item2.lower().endswith(('.md', '.ipynb')) and sub_item2 not in pass_list: - lessons[lesson].append(os.path.join(item, sub_item, sub_item2)) - # check for .md and .ipynb files and store them - elif sub_item.lower().endswith(('.md', '.ipynb')) and sub_item not in pass_list: - lessons[lesson].append(os.path.join(item, sub_item)) - # check for .md and .ipynb files and store them - elif item.lower().endswith(('.md', '.ipynb')) and item not in pass_list: - lessons[lesson].append(item) - # get .md and .ipynb in root directory - for item in os.listdir(root_path): - if item.lower().endswith(('.md', '.ipynb')) and item not in pass_list: - lessons[root_path].append(item) - - # check to remove folders that don't have .md files in them - lessons = {key: values for key, values in lessons.items() if len(values) > 0} - - return lessons - -def check_broken_links(file_path : str, link_type : str , check_type: str) -> str: - """function that checks if urls and hyperlinks are broken - - Keyword arguments: - file_path -- a path to text file to check - link_type -- path or url - check_type -- broken or tracking or locale - Return: broken links and associated file path - """ - all_links = get_links_from_file(file_path) - - # check if file has links - if len(all_links) > 0: - formatted_output = f" FILE '{file_path}'\n" - if link_type == "path": - paths = get_paths_from_links(all_links) - if check_type == "broken" and len(paths) > 0: - broken_path = check_paths_exists(file_path, paths) - if len (broken_path) > 0: - formatted_output += f' has the following broken relative paths {broken_path}\n' - return formatted_output - elif check_type == "tracking" and len(paths) > 0: - tracking_id_paths = check_url_tracking(paths) - if len(tracking_id_paths) > 0: - formatted_output += f' has the following paths with no tracking id {tracking_id_paths}\n' - return formatted_output - elif link_type == "url": - urls = get_urls_from_links(all_links) - if check_type == "tracking" and len(urls) > 0: - tracking_id_urls = check_url_tracking(urls) - if len(tracking_id_urls) > 0: - formatted_output += f' has the following links with no tracking id {tracking_id_urls}\n' - return formatted_output - elif check_type == "locale" and len(urls) > 0: - country_locale_urls = check_url_locale(urls) - if len(country_locale_urls) > 0: - formatted_output += f' has the following links with country locale {country_locale_urls}\n' - return formatted_output - -def get_links_from_file(file_path: str) -> list: - """function to get an array of markdown links from a file - flags markdown links captures the part inside () that comes right after [] - """ - all_links = [] - with open(file_path, 'r', encoding="utf-8") as file: - data = file.read() - link_pattern = re.compile(r'\]\((.*?)\)| \)') - matches = re.finditer(link_pattern, data) - for matched_group in matches: - if matched_group.group(1): - all_links.append(matched_group.group(1)) - return all_links - -def get_urls_from_links(all_links: list) -> list: - """function to get an array of urls from a list""" - urls = [] - url_pattern = re.compile(r'https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9]{1,6}\b([-a-zA-Z0-9@:%_\+.~#?&\/\/=]*)') - allowed_list = ['github.com', 'microsoft.com', 'visualstudio.com', 'aka.ms', 'azure.com'] - for link in all_links: - matches = re.findall(url_pattern, link) - - if matches and any(allowed in link.lower() for allowed in allowed_list): - urls.append(link) - return urls - -def get_paths_from_links(all_links: list) -> list: - """function to get relative paths from a list - flags paths that start with ./ or ../ - """ - paths = [] - path_pattern = re.compile(r'(\.{1,2}\/)+([A-Za-z0-9-]+\/)*(.+\.[A-Za-z]+)') - - for link in all_links: - link = link.split(" ")[0] - matches = re.findall(path_pattern, link) - if matches: - paths.append(link) - return paths - -def check_paths_exists(file_path : str, paths : list) -> list: - """function checks if a path exist if not return non existent paths - flags any relative path that can't be accessed - """ - broken_path = [] - for path in paths: - path = re.sub(r'(\?|\&)(WT|wt)\.mc_id=.*', '', path) - if not os.path.exists(os.path.normpath(os.path.join(os.path.dirname(file_path), path))): - broken_path.append(path) - return broken_path - -def check_url_locale(urls : list) -> list: - """function checks if a url has country locale - flags urls that have ==> /en-us/ - """ - country_locale = [] - for url in urls: - locale_pattern = re.compile(r'\/[a-z]{2}-[a-z]{2}\/') - matches = re.findall(locale_pattern, url) - if matches: - country_locale.append(url) - return country_locale - -def check_url_tracking(urls : list) -> list: - """function checks if a url has tracking id - flags urls missing ==> (? or &) plus WT.mc_id= or wt.mc_id= - """ - tracking_id = [] - for url in urls: - tracking_pattern = re.compile(r'(\?|\&)(WT|wt)\.mc_id=') - matches = re.findall(tracking_pattern, url) - if not matches: - tracking_id.append(url) - return tracking_id - -def get_input_args() -> None: - """ - Retrieves and parses the 2 command line arguments provided by the user when - they run the program from a terminal window. This function uses Python's - argparse module to created and defined these 2 command line arguments. If - the user fails to provide some or all of the 2 arguments, then the default - values are used for the missing arguments. - Command Line Arguments: - 1. Tutorials Path as --dir - 2. Function to be executed as --func - This function returns these arguments as an ArgumentParser object. - Parameters: - None - simply using argparse module to create & store command line arguments - Returns: - parse_args() -data structure that stores the command line arguments object - """ - # Parse using ArgumentParser - parser = argparse.ArgumentParser() - - parser.add_argument('-d', '--dir', type = str, default = './', - help = 'path to the root directory', required=True) - - parser.add_argument('-f', '--func', type = str, required = True, - help = 'function to be executed', - choices=['check_broken_paths', - 'check_paths_tracking', - 'check_urls_tracking', - 'check_urls_locale']) - - return parser.parse_args() - - -# Call to main function to run the program -if __name__ == "__main__": - main() - -# DEPRECATED -def get_urls_from_file(file_path: str) -> list: - """function to get an array of urls from a file""" - urls = [] - with open(file_path, 'r', encoding="utf-8") as file: - data = file.read() - url_pattern = re.compile(r'https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9]{1,6}\b([-a-zA-Z0-9@:%_\+.~#?&\/\/=]*)') - matches = re.finditer(url_pattern, data) - for matched_group in matches: - urls.append(matched_group.group()) - return urls - -def get_paths_from_file(file_path: str) -> list: - """function to get relative paths from a file""" - paths = [] - with open(file_path, 'r', encoding="utf-8") as file: - data = file.read() - path_pattern = re.compile(r'(\.{1,2}\/)+([A-Za-z0-9-]+\/)*([A-Za-z0-9]+\.[A-Za-z]+)') - matches = re.finditer(path_pattern, data) - for matched_group in matches: - paths.append(matched_group.group()) - return paths diff --git a/.github/workflows/deploy-quiz-app.yml b/.github/workflows/deploy-quiz-app.yml index 7e0188289..7bca0a002 100644 --- a/.github/workflows/deploy-quiz-app.yml +++ b/.github/workflows/deploy-quiz-app.yml @@ -23,7 +23,7 @@ jobs: uses: Azure/static-web-apps-deploy@v1 with: azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }} - repo_token: ${{ secrets.GITHUB_TOKEN }} # Used for Github integrations (i.e. PR comments) + repo_token: ${{ secrets.GITHUB_TOKEN }} # Used for GitHub integrations (i.e. PR comments) action: "upload" ###### Repository/Build Configurations - These values can be configured to match your app requirements. ###### # For more information regarding Static Web App workflow configurations, please visit: https://aka.ms/swaworkflowconfig diff --git a/.github/workflows/validate-markdown.yml b/.github/workflows/validate-markdown.yml index e16497767..00807649c 100644 --- a/.github/workflows/validate-markdown.yml +++ b/.github/workflows/validate-markdown.yml @@ -24,21 +24,15 @@ jobs: uses: actions/checkout@v3 with: ref: ${{ github.event.pull_request.head.sha }} - - name: Setup Python - uses: actions/setup-python@v4 + - name: Check broken Paths + id: check-broken-paths + uses: john0isaac/action-check-markdown@v1.0.0 with: - python-version: '3.10' - - name: Install Dependencies - run: | - python -m pip install --upgrade pip - - name: Run Check broken paths - run: | - BROKEN_PATHS=$(python ./.github/markdown_checker.py --dir './' --func 'check_broken_paths') - echo "BROKEN_PATHS<> $GITHUB_ENV - echo "$BROKEN_PATHS" >> $GITHUB_ENV - echo "EOF" >> $GITHUB_ENV + command: check-broken-paths + directory: ./ + github-token: ${{ secrets.GITHUB_TOKEN }} - name: Leave broken paths comment - if: ${{ env.BROKEN_PATHS != '' }} + if: ${{ steps.check-broken-paths.outputs.is-valid == 1 }} uses: actions/github-script@v6 with: github-token: ${{ secrets.GITHUB_TOKEN }} @@ -56,9 +50,8 @@ jobs: ` }) - name: Update workflow run status - if: ${{ env.BROKEN_PATHS != '' }} + if: ${{ steps.check-broken-paths.outputs.is-valid == 1 }} run: exit 1 - check-paths-tracking: if: ${{ always() }} needs: check-broken-paths @@ -69,21 +62,15 @@ jobs: uses: actions/checkout@v3 with: ref: ${{ github.event.pull_request.head.sha }} - - name: Setup Python - uses: actions/setup-python@v4 - with: - python-version: '3.10' - - name: Install Dependencies - run: | - python -m pip install --upgrade pip - name: Run Check paths tracking - run: | - PATHS_TRACKING=$(python ./.github/markdown_checker.py --dir './' --func 'check_paths_tracking') - echo "PATHS_TRACKING<> $GITHUB_ENV - echo "$PATHS_TRACKING" >> $GITHUB_ENV - echo "EOF" >> $GITHUB_ENV + id: check-paths-tracking + uses: john0isaac/action-check-markdown@v1.0.0 + with: + command: check-paths-tracking + directory: ./ + github-token: ${{ secrets.GITHUB_TOKEN }} - name: Leave paths tracking comment - if: ${{ env.PATHS_TRACKING != '' }} + if: ${{ steps.check-paths-tracking.outputs.is-valid == 1 }} uses: actions/github-script@v6 with: github-token: ${{ secrets.GITHUB_TOKEN }} @@ -101,7 +88,7 @@ jobs: ` }) - name: Update workflow run status - if: ${{ env.PATHS_TRACKING != '' }} + if: ${{ steps.check-paths-tracking.outputs.is-valid == 1 }} run: exit 1 check-urls-tracking: @@ -114,21 +101,15 @@ jobs: uses: actions/checkout@v3 with: ref: ${{ github.event.pull_request.head.sha }} - - name: Setup Python - uses: actions/setup-python@v4 - with: - python-version: '3.10' - - name: Install Dependencies - run: | - python -m pip install --upgrade pip - name: Run Check URLs tracking - run: | - URLS_TRACKING=$(python ./.github/markdown_checker.py --dir './' --func 'check_urls_tracking') - echo "URLS_TRACKING<> $GITHUB_ENV - echo "$URLS_TRACKING" >> $GITHUB_ENV - echo "EOF" >> $GITHUB_ENV + id: check-urls-tracking + uses: john0isaac/action-check-markdown@v1.0.0 + with: + command: check-urls-tracking + directory: ./ + github-token: ${{ secrets.GITHUB_TOKEN }} - name: Leave URLs tracking comment - if: ${{ env.URLS_TRACKING != '' }} + if: ${{ steps.check-urls-tracking.outputs.is-valid == 1 }} uses: actions/github-script@v6 with: github-token: ${{ secrets.GITHUB_TOKEN }} @@ -146,7 +127,7 @@ jobs: ` }) - name: Update workflow run status - if: ${{ env.URLS_TRACKING != '' }} + if: ${{ steps.check-urls-tracking.outputs.is-valid == 1 }} run: exit 1 check-urls-locale: @@ -159,21 +140,15 @@ jobs: uses: actions/checkout@v3 with: ref: ${{ github.event.pull_request.head.sha }} - - name: Setup Python - uses: actions/setup-python@v4 - with: - python-version: '3.10' - - name: Install Dependencies - run: | - python -m pip install --upgrade pip - name: Run Check URLs Country Locale - run: | - URLS_LOCALE=$(python ./.github/markdown_checker.py --dir './' --func 'check_urls_locale') - echo "URLS_LOCALE<> $GITHUB_ENV - echo "$URLS_LOCALE" >> $GITHUB_ENV - echo "EOF" >> $GITHUB_ENV + id: check-urls-locale + uses: john0isaac/action-check-markdown@v1.0.0 + with: + command: check-urls-locale + directory: ./ + github-token: ${{ secrets.GITHUB_TOKEN }} - name: Leave URLs locale comment - if: ${{ env.URLS_LOCALE != '' }} + if: ${{ steps.check-urls-locale.outputs.is-valid == 1 }} uses: actions/github-script@v6 with: github-token: ${{ secrets.GITHUB_TOKEN }} @@ -191,5 +166,5 @@ jobs: ` }) - name: Update workflow run status - if: ${{ env.URLS_LOCALE != '' }} + if: ${{ steps.check-urls-locale.outputs.is-valid == 1 }} run: exit 1 diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 000000000..e69de29bb diff --git a/00-course-setup/README.md b/00-course-setup/README.md index 8fa7e23d7..608db0762 100644 --- a/00-course-setup/README.md +++ b/00-course-setup/README.md @@ -103,7 +103,7 @@ One of the best ways to keep your API keys secure when using GitHub Codespaces i The course has 6 concept lessons and 6 coding lessons. -For the coding lessons, we are using the Azure OpenAI Service. You will need access to the Azure OpenAI service and an API key to run this code. You can apply to get access by [completing this application](https://customervoice.microsoft.com/Pages/ResponsePage.aspx?id=v4j5cvGGr0GRqy180BHbR7en2Ais5pxKtso_Pz4b1_xUOFA5Qk1UWDRBMjg0WFhPMkIzTzhKQ1dWNyQlQCN0PWcu&culture=en-us&country=us&WT.mc_id=academic-105485-koreyst). +For the coding lessons, we are using the Azure OpenAI Service. You will need access to the Azure OpenAI service and an API key to run this code. You can apply to get access by [completing this application](https://azure.microsoft.com/products/ai-services/openai-service?WT.mc_id=academic-105485-koreyst). While you wait for your application to be processed, each coding lesson also includes a `README.md` file where you can view the code and outputs. @@ -121,7 +121,7 @@ The project team will also be on this Discord server to help any learners. ## Contribute -This course is an open-source initiative. If you see areas of improvement or issues, please create a [Pull Request](https://github.com/microsoft/generative-ai-for-beginners/pulls?WT.mc_id=academic-105485-koreyst) or log a [Github issue](https://github.com/microsoft/generative-ai-for-beginners/issues?WT.mc_id=academic-105485-koreyst). +This course is an open-source initiative. If you see areas of improvement or issues, please create a [Pull Request](https://github.com/microsoft/generative-ai-for-beginners/pulls?WT.mc_id=academic-105485-koreyst) or log a [GitHub issue](https://github.com/microsoft/generative-ai-for-beginners/issues?WT.mc_id=academic-105485-koreyst). The project team will be tracking all contributions and contributing to open source is an amazing way to build your career in Generative AI. @@ -131,7 +131,7 @@ Important: when translating text in this repo, please ensure that you do not use When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repositories using our CLA. -This project has adopted the Microsoft Open Source Code of Conduct. For more information read the Code of Conduct FAQ or contact [Email opencode](opencode@microsoft.com) with any additional questions or comments. +This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information read the Code of Conduct FAQ or contact [Email opencode](opencode@microsoft.com) with any additional questions or comments. ## Let's Get Started diff --git a/00-course-setup/translations/cn/README.md b/00-course-setup/translations/cn/README.md index b802cd6ac..5ea2b73e5 100644 --- a/00-course-setup/translations/cn/README.md +++ b/00-course-setup/translations/cn/README.md @@ -88,7 +88,7 @@ jupyterhub ## 贡献该内容 -本课程是一项开源计划。 如果您发现需要改进的地方或问题，请创建 [Pull Request](https://github.com/microsoft/generative-ai-for-beginners/pulls?WT.mc_id=academic-105485-koreyst) 或记录 [Github 问题](https://github.com/microsoft/generative-ai-for-beginners/issues?WT.mc_id=academic-105485-koreyst)。 +本课程是一项开源计划。 如果您发现需要改进的地方或问题，请创建 [Pull Request](https://github.com/microsoft/generative-ai-for-beginners/pulls?WT.mc_id=academic-105485-koreyst) 或记录 [GitHub 问题](https://github.com/microsoft/generative-ai-for-beginners/issues?WT.mc_id=academic-105485-koreyst)。 课程项目团队将跟踪所有贡献，为开源做出贡献是在生成人工智能领域建立职业生涯的绝佳方式。 diff --git a/00-course-setup/translations/pt-br/README.md b/00-course-setup/translations/pt-br/README.md new file mode 100644 index 000000000..67eb5d8f5 --- /dev/null +++ b/00-course-setup/translations/pt-br/README.md @@ -0,0 +1,138 @@ +# Iniciando com este curso + +Estamos muito animados por você iniciar este curso e ver que se inspira em criar aplicações com IA Generativa! + +Para tornar o seu tempo bem-sucedido(a), criamos esta página que descreve as etapas de configuração, requisitos técnicos e como obter ajuda quando precisar. + +## Etapas de Configuração + +Para começar este curso, você precisará concluir as seguintes etapas. + +### 1. Faça um Fork deste Repositório + +[Faça um fork deste repositório](https://github.com/microsoft/generative-ai-for-beginners/fork?WT.mc_id=academic-105485-koreyst) para a sua própria conta no GitHub para que possa alterar qualquer código e concluir os desafios. Você também pode [marcar com uma (🌟) este repositório](https://docs.github.com/en/get-started/exploring-projects-on-github/saving-repositories-with-stars?WT.mc_id=academic-105485-koreyst) para encontrar com mais facilidade esse repositório. + +### 2. Crie um Codespaces + +Para evitar problemas de dependência ao executar o código, recomendamos a execução deste curso em um Codespaces do GitHub. + +Isso pode ser criado selecionando a opção `Code` na sua versão `birfucada` deste repositório e selecionando a opção **Codespaces**. + +### 3. Armazenando Suas Chaves da API + +Manter suas chaves da API seguras e protegidas é importante quando você cria qualquer tipo de aplicação. Recomendamos que você não armazene suas chaves da API diretamente no código com o qual está trabalhando. Pois a inclusão dessas informações num repositório público pode resultar em custos indesejados e problemas a você. + +![Dialog showing buttons to create a codespace](../../images/who-will-pay.webp?WT.mc_id=academic-105485-koreyst) + +## Como Executar Localmente no seu Computador + +Para executar o código localmente no seu computador, você precisará ter alguma versão do [Python instalada](https://www.python.org/downloads?WT.mc_id=academic-105485-koreyst). + +Para utilizar o repositório, você precisará clonar primeiramente: + +```shell +git clone https://github.com/microsoft/generative-ai-for-beginners +cd generative-ai-for-beginners +``` + +Agora, você tem tudo configurado e pode começar a aprender e trabalhar com o código. + +### Instalando o miniconda (etapa opcional) + +Existem vantagens em instalar o **[miniconda](https://conda.io/en/latest/miniconda.html)** - que é uma instalação bastante leve que suporta o gerenciador de pacotes `conda` para diferentes **ambientes virtuais** do Python. O `conda` facilita a instalação e alternância entre diferentes versões e pacotes do Python e também a instalação de pacotes que não estão disponíveis via `pip`. + +Depois de instalar o miniconda, você precisará clonar o repositório (se ainda não o fez) e criar um ambiente virtual a ser usado neste curso: + +Antes de executar a etapa abaixo, tenha certeza de que você já possui um arquivo *environment.yml*. O arquivo *environment.yml* é usado para criar um ambiente conda com as dependências necessárias e que pode se parecer com isto: + +```yml +name: +channels: + - defaults +dependencies: +- python= +- openai +- python-dotenv +``` + +Você pode substituir `` pelo nome do seu ambiente conda e `` pela versão do Python que você deseja usar. Coloque o arquivo *environment.yml* criado na pasta *.devcontainer* do seu repositório. + +Agora que você criou um arquivo *environment.yml*, você pode criar um ambiente conda com o seguinte comando: + +```bash +conda env create --name ai4beg --file .devcontainer/environment.yml +conda activate ai4beg +``` + +Se você tiver problemas, consulte este link sobre a criação de [ambientes conda](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html). + +### Usando o Visual Studio Code com a Extensão do Python + +Provavelmente a melhor maneira de usar o currículo é abrindo no [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-105485-koreyst) com a [Extensão Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-105485-koreyst). + +> **Observação**: Uma vez que você clonar e abrir o diretório no VS Code, ele automaticamente vai sugerir que você instale as extensões do Python. Você também precisará instalar o `Miniconda` conforme descrito acima. + +> **Observação**: Se o VS Code sugerir que você reabra o repositório em um container, você precisará recusar isso para usar a instalação local do Python. + +### Usando o Jupyter no Navegador + +Você também pode usar o ambiente Jupyter diretamente do navegador em seu próprio computador. Na verdade, tanto o Jupyter clássico quanto o Jupyter Hub proporcionam um ambiente de desenvolvimento bastante conveniente com autocompletamento, destaque de código, etc. + +Para iniciar o Jupyter localmente, vá para o diretório do curso e execute: + +```bash +jupyter notebook +``` + +ou + +```bash +jupyterhub +``` + +Você pode navegar para qualquer um dos arquivos `.ipynb`, abre esses arquivos e comece a trabalhar. + +### Executando em um Contêiner + +Uma alternativa à instalação do Python seria executar o código em um contêiner. Como nosso repositório contém uma pasta especial chamada `.devcontainer`, que instrui como criar um contêiner para este repositório, o VS Code oferecerá a opção de reabrir o código em um contêiner. Isso requer a instalação do Docker e é mais complexo. Assim sendo, recomendado para usuários mais experientes. + +Uma das melhores maneiras de manter suas chaves da API seguras ao usar GitHub Codespaces é usando `Codespace Secrets`. Siga este guia sobre como [gerenciar segredos para seus Codespaces](https://docs.github.com/en/codespaces/managing-your-codespaces/managing-secrets-for-your-codespaces?WT.mc_id=academic-105485-koreyst). + +## Lições e Requisitos Técnicos + +O curso possui 6 lições conceituais e 6 lições incluem codificações. + +Para as lições de codificação, estamos usando o Serviço Azure OpenAI. Você precisará de acesso ao serviço do Azure OpenAI e de uma chave de API para executar o código. Você pode solicitar acesso ao [completar esta aplicação](https://customervoice.microsoft.com/Pages/ResponsePage.aspx?id=v4j5cvGGr0GRqy180BHbR7en2Ais5pxKtso_Pz4b1_xUOFA5Qk1UWDRBMjg0WFhPMkIzTzhKQ1dWNyQlQCN0PWcu&culture=en-us&country=us?WT.mc_id=academic-105485-koreyst). + +Enquanto aguarda o processamento da sua inscrição, cada lição que tenha codificação também inclui um arquivo `README.md` onde você pode visualizar o código e as suas respectivas saídas. + +## Usando o Serviço Azure OpenAI pela Primeira Vez + +Se esta for a primeira vez que você está trabalhando com o serviço Azure OpenAI, siga este guia sobre como [criar e implantar um recurso do Serviço Azure OpenAI](https://learn.microsoft.com/azure/ai-services/openai/how-to/create-resource?pivots=web-portal&WT.mc_id=academic-105485-koreyst). + +## Conheça Outros Aprendizes + +Criamos canais em nosso servidor oficial da [Comunidade de Inteligência Artificial no Discord](https://aka.ms/genai-discord?WT.mc_id=academic-105485-koreyst) para que você possa conhecer outros aprendizes. Esta é uma ótima maneira de se conectar com outros empreendedores, pessoas desenvolvedoras, estudantes e qualquer pessoa que queira se aprofundar sobre Inteligência Artificial Generativa. + +[![Participe do canal no Discord](https://dcbadge.vercel.app/api/server/ByRwuEEgH4)](https://aka.ms/genai-discord?WT.mc_id=academic-105485-koreyst) + +A equipe do projeto também estará presente neste servidor do Discord para ajudar à todos(as). + +## Contribua + +Este curso é uma iniciativa de Código Aberto. Se você identificar áreas de melhoria ou problemas, por favor crie um [Pull Request](https://github.com/microsoft/generative-ai-for-beginners/pulls?WT.mc_id=academic-105485-koreyst) ou registre uma [issue no Github](https://github.com/microsoft/generative-ai-for-beginners/issues?WT.mc_id=academic-105485-koreyst). + +A equipe do projeto acompanhará todas as contribuições. Sem contar que, contribuir para o código aberto é uma maneira incrível de construir sua carreira em Inteligência Artificial Generativa. + +A maioria das contribuições requer que você concorde com um Contrato de Licença de Contribuidor (CLA) declarando que você tem o direito e realmente nos concede os direitos de usar sua contribuição. Para mais detalhes, visite o site do [CLA, Contrato de Licença de Contribuidor](https://cla.microsoft.com?WT.mc_id=academic-105485-koreyst). + +Importante: ao traduzir texto neste repositório, certifique-se de não utilizar tradução automática. Verificaremos as traduções por meio da comunidade. Portanto, se ofereça voluntariamente para traduzir apenas em idiomas nos quais você seja proficiente. + +Quando você for enviar um Pull Request, um robô CLA automaticamente determinará se você precisa fornecer um CLA e decorará o PR adequadamente (por exemplo, etiqueta, comentário). Basta seguir as instruções fornecidas pelo robô. Você só precisará fazer isso uma vez em todos os repositórios que utilizam nosso CLA. + +Este projeto adotou o Código de Conduta de Código Aberto da Microsoft. Para obter mais informações, leia o FAQ do Código de Conduta ou entre em contato com [Email opencode](opencode@microsoft.com) com quaisquer perguntas ou comentários adicionais. + +## Vamos Começar? + +Agora que você concluiu as etapas necessárias para concluir este curso, vamos começar com a lição [Introdução à Inteligência Artificial Generativa e Grandes Modelos de Linguagens (LLMs)](../../../01-introduction-to-genai/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst). + diff --git a/01-introduction-to-genai/translations/cn/README.md b/01-introduction-to-genai/translations/cn/README.md index e4605cb6a..474c9d9ef 100644 --- a/01-introduction-to-genai/translations/cn/README.md +++ b/01-introduction-to-genai/translations/cn/README.md @@ -40,7 +40,7 @@ ## 我们是如何获得生成式人工智能的？ -尽管最近因生成人工智能模型的发布而引起了对人工智能技术的“炒作”，但人工智能已经有数十年的历史，最早的研究工作可以追溯到上世纪 60 年代。 我们现在正处于 AI 具有人类认知能力的阶段，例如 [OpenAI ChatGPT](https://openai.com/chatgpt?WT.mc_id=academic-105485-koreyst) 或 [Bing Chat](https://www.microsoft.com/en-us/edge/features/bing-chat?WT.mc_id=academic-105485-koreyst）也在用 GPT 模型进行对话。 +尽管最近因生成人工智能模型的发布而引起了对人工智能技术的“炒作”，但人工智能已经有数十年的历史，最早的研究工作可以追溯到上世纪 60 年代。 我们现在正处于 AI 具有人类认知能力的阶段，例如 [OpenAI ChatGPT](https://openai.com/chatgpt?WT.mc_id=academic-105485-koreyst) 或 [Bing Chat](https://www.microsoft.com/edge/features/bing-chat?WT.mc_id=academic-105485-koreyst）也在用 GPT 模型进行对话。 稍微回顾一下，人工智能的第一个原型是打字的聊天机器人，依赖于从一组专家系统中提取到计算机中的知识库。 知识库中的答案是由输入文本中出现的关键字触发的。 然而，很快大家就发现，这种使用打字聊天机器人的方法并不能很好地扩展。 diff --git a/01-introduction-to-genai/translations/pt-br/README.md b/01-introduction-to-genai/translations/pt-br/README.md new file mode 100644 index 000000000..eff60d7af --- /dev/null +++ b/01-introduction-to-genai/translations/pt-br/README.md @@ -0,0 +1,136 @@ +# Introdução à Inteligência Artificial Generativa e Grandes Modelos de Linguagem + +[![Introduction to Generative AI and Large Language Models](../../images/01-lesson-banner.png?WT.mc_id=academic-105485-koreyst)](https://youtu.be/vf_mZrn8ibc?WT.mc_id=academic-105485-koreyst) + +*(Clique na imagem acima para assistir ao vídeo desta lição)* + +A Inteligência Artificial Generativa é uma forma de inteligência artificial capaz de gerar texto, imagens e outros tipos de conteúdo. O que a faz uma tecnologia fantástica é que ela democratiza a IA. Além disso, qualquer pessoa pode usá-la com apenas uma pequena frase, uma sentença escrita em uma linguagem natural. Não é necessário aprender uma linguagem como Java ou SQL para realizar algo significativo. Tudo o que você precisa fazer é usar sua própria linguagem, declarar o que deseja e uma sugestão de um modelo de IA será gerada. As aplicações e o impacto disso são enormes: você pode escrever ou compreender relatórios, criar aplicações e muito mais, tudo em questão de segundos. + +Neste currículo, exploraremos como nossa startup aproveita a IA generativa para desbloquear novos cenários no mundo da educação e como lidamos com os desafios inevitáveis relacionados às implicações sociais de sua aplicação e às limitações tecnológicas. + +## Introdução + +Esta lição abordará: + +* Introdução ao cenário de negócios: nossa ideia de startup e missão. +* Inteligência Artificial Generativa e como chegamos ao cenário tecnológico atual. +* Funcionamento interno de um grande modelo de linguagem. +* Principais capacidades e casos de uso práticos de Grandes Modelos de Linguagem. + +## Objetivos de Aprendizado + +Após completar esta lição, você entenderá: + +* O que é a Inteligência Artificial Generativa e como os Grandes Modelos de Linguagem funcionam. +* Como você pode aproveitar os Grandes Modelos de Linguagem para diferentes casos de uso, com foco em cenários de educação. + +## Cenário: nossa startup educacional + +A Inteligência Artificial Generativa (IA) representa o auge da tecnologia de IA, ultrapassando os limites do que antes era considerado impossível. Modelos de IA generativa têm várias capacidades e aplicações. Porém, neste currículo, exploraremos como ela está revolucionando a educação por meio de uma startup fictícia. Nos referiremos a essa startup como *nossa startup*. `Nossa startup` atua no domínio da educação com a ambiciosa declaração de missão: + +> *Melhorar a acessibilidade na aprendizagem, em escala global, garantindo acesso equitativo à educação e proporcionando experiências de aprendizagem personalizadas a cada aluno(a), de acordo com suas necessidades*. + +A equipe de nossa startup está ciente de que não será capaz de alcançar esse objetivo sem aproveitar uma das ferramentas mais poderosas dos tempos modernos - Grandes Modelos de Linguagem (LLMs). + +A IA generativa deve revolucionar a maneira como aprendemos e ensinamos hoje, com os(as) alunos(as) tendo à disposição professores(as) virtuais 24 horas por dia, que fornecem vastas quantidades de informações e exemplos, e professores(as) capazes de alavancar ferramentas inovadoras para avaliar seus/suas alunos(as) e fornecer feedback. + +![Five young students looking at a monitor - image by DALLE2](../../images/students-by-DALLE2.png?WT.mc_id=academic-105485-koreyst) + +Para começar, vamos definir alguns conceitos e terminologia básica que usaremos ao longo do currículo. + +## Como surgiu a IA Generativa? + +Apesar da extraordinária *hype* criada recentemente com o anúncio de modelos de IA generativa, essa tecnologia está em desenvolvimento há décadas, com os primeiros esforços de pesquisa datando dos anos 60. Agora estamos em um ponto em que a IA possui capacidades cognitivas humanas como conversação, como mostrado por exemplo, no [OpenAI ChatGPT](https://openai.com/chatgpt?WT.mc_id=academic-105485-koreyst) ou no [Bing Chat](https://www.microsoft.com/edge/features/bing-chat?WT.mc_id=academic-105485-koreyst), que também utiliza um modelo GPT para a pesquisa na web e conversas do Bing. + +Voltando um pouco, os primeiros protótipos de IA consistiam em chatbots datilografados, baseando-se em uma base de conhecimento extraída de um grupo de especialistas e representada em um computador. As respostas na base de conhecimento eram acionadas por palavras-chave que apareciam no texto de entrada. +No entanto, logo ficou claro que tal abordagem, usando chatbots datilografados, não se escalava bem. + +### Uma abordagem estatística para a IA: Aprendizado de Máquina + +Um ponto de virada ocorreu durante os anos 90, com a aplicação de uma abordagem estatística à análise de texto. Isso levou ao desenvolvimento de novos algoritmos - conhecidos com o nome de aprendizado de máquina - capazes de aprender padrões a partir de dados, sem serem programados explicitamente. Essa abordagem permite que uma máquina simule a compreensão da linguagem humana: um modelo estatístico é treinado em pares de texto e rótulo, permitindo que o modelo classifique um texto de entrada desconhecido com um rótulo predefinido que representa a intenção da mensagem. + +### Redes neurais e assistentes virtuais modernos + +Em tempos mais recentes, a evolução tecnológica do hardware, capaz de lidar com maiores quantidades de dados e cálculos mais complexos, encorajou a pesquisa nos campos de IA, levando ao desenvolvimento de algoritmos avançados de aprendizado de máquina - chamados de redes neurais ou algoritmos de aprendizado profundo. + +As redes neurais (ou as Redes Neurais Recorrentes - `RNNs`) aprimoraram significativamente o processamento de linguagem natural, permitindo a representação do significado do texto de uma maneira mais significativa, valorizando o contexto de uma palavra em uma frase. + +Essa é a tecnologia que impulsionou os assistentes virtuais nascidos na primeira década do novo século, muito proficientes na interpretação da linguagem humana, identificando uma necessidade e executando uma ação para satisfazê-la - como responder com um script predefinido ou consumir um serviço de terceiros. + +### Atualmente, a IA Generativa + +Foi assim que chegamos à IA Generativa de hoje, que pode ser vista como um subconjunto de aprendizado profundo. + +![IA, ML, AP e IA Generativa](../../images/AI-diagram.png?WT.mc_id=academic-105485-koreyst) + +Depois de décadas de pesquisa no campo da IA, uma nova arquitetura de modelo - chamada *Transformer* - superou os limites das `RNNs`. Sendo capaz de receber sequências de texto muito mais longas como entrada. Os `Transformers` são baseados no mecanismo de atenção, permitindo que o modelo dê pesos diferentes às entradas que recebe, *prestando mais atenção* onde as informações mais relevantes estão concentradas, independentemente de sua ordem na sequência de texto. + +A maioria dos modelos recentes da IA generativa - também conhecidos como Grandes Modelos de Linguagem (LLMs), trabalham com entradas e saídas textuais e que, são de fato, baseados nessa arquitetura. O que é interessante sobre esses modelos - treinados em uma enorme quantidade de dados não rotulados de diversas fontes, como: livros, artigos e sites - é que eles podem ser adaptados para uma ampla variedade de tarefas e gerar texto gramaticalmente correto com uma semelhança de criatividade. Portanto, não apenas aumentaram incrivelmente a capacidade de uma máquina *entender* um texto de entrada. Mas também habilitaram sua capacidade de gerar uma resposta original em linguagem humana. + +## Como os Grandes Modelos de Linguagem funcionam? + +No próximo capítulo, vamos explorar diferentes tipos de modelos de IA generativa. Por enquanto, vamos dar uma olhada em como os grandes modelos de linguagem funcionam, com foco nos modelos do OpenAI GPT (`Generative Pre-trained Transformer`). + +* **Tokenizador, texto para números**: Grandes Modelos de Linguagem, recebem um texto como entrada e geram um texto como saída. No entanto, sendo modelos estatísticos, eles funcionam muito melhor com números do que sequências de texto. É por isso que cada entrada no modelo é processada por um `tokenizador` antes de ser usada pelo modelo principal. Um `token` é um pedaço de texto - consistindo em um número variável de caracteres, portanto, a principal tarefa do tokenizador é dividir a entrada em uma matriz de tokens. Em seguida, cada token é mapeado com um índice de token, que é a codificação inteira do trecho de texto original. + +![Example of tokenization](../../images/tokenizer-example.png?WT.mc_id=academic-105485-koreyst) + +* **Previsão de tokens de saída**: Dados `n` tokens como entrada (com o máximo `n` variando de um modelo para outro), o modelo é capaz de prever um token como saída. Esse token é então incorporado à entrada da próxima iteração em um padrão de janela expansiva. Possibilitando assim, uma melhor experiência do usuário em obter uma (ou várias) sentenças como resposta. Isso explica por que, se você já brincou com o ChatGPT, pode ter notado que às vezes parece que ele para no meio de uma frase. + +* **Processo de seleção, distribuição de probabilidade**: O token de saída é escolhido pelo modelo de acordo com a probabilidade de ocorrer após a sequência de texto atual. Isso ocorre porque o modelo prevê uma distribuição de probabilidade sobre todos os possíveis *próximos tokens* calculados com base em seu treinamento. No entanto, nem sempre o token com a maior probabilidade é escolhido na distribuição resultante. Um grau de aleatoriedade é adicionado a essa escolha, de forma que o modelo age de maneira não determinística - não obtemos a mesma saída exata para a mesma entrada. Esse grau de aleatoriedade é adicionado para simular o processo de pensamento criativo e pode ser ajustado usando um parâmetro do modelo chamado temperatura. + +## Como nossa startup pode aproveitar os Grandes Modelos de Linguagem? + +Agora que temos uma melhor compreensão de como os grandes modelos de linguagem funcionam, vamos ver alguns exemplos práticos das tarefas mais comuns que eles podem realizar muito bem, com foco em nosso cenário de negócios. +Dissemos que a principal capacidade de um Grande Modelo de Linguagem é: *gerar um texto do zero, a partir de uma entrada textual, escrita em linguagem natural*. + +Mas que tipo de entrada e saída textual? +A entrada de um grande modelo de linguagem é conhecida como `prompt`. Enquanto a saída é conhecida como `completion`, termo que se refere ao mecanismo do modelo de gerar o próximo token para completar a entrada atual. Vamos nos aprofundar no que é um prompt e como projetá-lo de maneira a obter o máximo de nosso modelo. Agora, vamos apenas dizer que um prompt pode incluir: + +* Uma **instrução** especificando o tipo de saída que esperamos do modelo. Essa instrução às vezes pode incorporar alguns exemplos ou alguns dados adicionais. + + 1. Resumo de um artigo, livro, análises de produtos e muito mais. Juntamente com a extração de insights de dados não estruturados. + ![Exemplo de resumo](../../images/summarization-example.png?WT.mc_id=academic-105485-koreyst) + + 2. Ideação criativa e design de um artigo, uma redação, uma tarefa ou mais. + ![Exemplo de escrita criativa](../../images/creative-writing-example.png?WT.mc_id=academic-105485-koreyst) + +* Uma **pergunta** feita na forma de uma conversa com um agente. + ![Exemplo de conversa](../../images/conversation-example.png?WT.mc_id=academic-105485-koreyst) + +* Um trecho de **texto a ser completado** que implicitamente é um pedido de assistência na escrita. + ![Exemplo de conclusão de texto](../../images/text-completion-example.png?WT.mc_id=academic-105485-koreyst) + +* Um trecho de **código** juntamente com a solicitação de explicá-lo e documentá-lo ou um comentário pedindo para gerar um trecho de código que execute uma tarefa específica. + ![Exemplo de programação](../../images/coding-example.png?WT.mc_id=academic-105485-koreyst) + +Os exemplos acima são bastante simples e não pretendem ser uma demonstração exaustiva das capacidades dos Grandes Modelos de Linguagem. Eles apenas querem mostrar o potencial de uso da IA generativa, em particular, mas não limitado ao contexto educacional. + +Além disso, a saída de um modelo de IA generativa não é perfeita e, às vezes, a criatividade do modelo pode funcionar contra ele, resultando em uma saída que é uma combinação de palavras que o usuário humano pode interpretar como uma mistificação da realidade ou pode ser ofensiva. A IA Generativa não é inteligente - pelo menos na definição mais abrangente de inteligência, incluindo o raciocínio crítico e criativo ou a inteligência emocional; ela não é determinística e não é confiável, uma vez que alucinações, como referências, conteúdo e declarações errôneas, podem ser combinadas com informações corretas e apresentadas de maneira persuasiva e confiante. Nas próximas lições, lidaremos com todas essas limitações e veremos o que podemos fazer para mitigá-las. + +# Tarefa + +Sua tarefa é estudar mais sobre [IA Generativa](https://en.wikipedia.org/wiki/Generative_artificial_intelligence?WT.mc_id=academic-105485-koreyst) e tentar identificar uma área onde você adicionaria IA Generativa hoje mas que ainda não a possui. Como o impacto seria diferente de fazer as coisas do "jeito antigo"? Você pode fazer algo que não era possível antes ou que seria mais rápido? Escreva um resumo de 300 palavras sobre como sua startup da IA dos sonhos seria e inclua cabeçalhos como: + +- "Problema" +- "Como eu usaria a IA" +- "Impacto" +- E, como opção, um plano de negócios. + +Se você fizer essa tarefa, poderá até estar pronto para se inscrever no [Microsoft's Incubator](https://www.microsoft.com/startups?WT.mc_id=academic-105485-koreyst) para fundadores de startups. Eles oferecem créditos para Azure, OpenAI, mentoria e muito mais. Confira agora mesmo! + +## Verificação de conhecimento + +O que é verdade sobre Grandes Modelos de Linguagem? + +1. Você obtém a mesma resposta exata toda vez. +2. Eles fazem as coisas perfeitamente. São ótimos em somar números, produzir código funcional etc. +3. A resposta pode variar, mesmo ao usar o mesmo prompt. Além disso, eles são ótimos em fornecer um primeiro rascunho de algo, seja texto ou código. Mas você precisa melhorar os resultados. + +**Resposta:** 3, um `LLM` é *não-determinístico*. A resposta varia, em você controlar sua variação por meio de uma configuração de `temperatura`. Além disso, você não deve esperar que ele faça as coisas perfeitamente. Ele está aqui para fazer o trabalho pesado para você, o que muitas vezes significa que você obtém uma boa primeira tentativa de algo que precisa melhorar gradualmente. + +## Ótimo trabalho! A Jornada Continua + +Deseja aprender mais sobre diferentes conceitos de IA Generativa? Acesse a [página de Aprendizado Contínuo](../../../13-continued-learning/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) para encontrar outros ótimos recursos sobre este tópico. + +Vá para a Lição 2, onde veremos como [Explorar e comparar diferentes tipos de LLM](../../../02-exploring-and-comparing-different-llms/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst)! diff --git a/02-exploring-and-comparing-different-llms/translations/pt-br/README.md b/02-exploring-and-comparing-different-llms/translations/pt-br/README.md new file mode 100644 index 000000000..731a3298a --- /dev/null +++ b/02-exploring-and-comparing-different-llms/translations/pt-br/README.md @@ -0,0 +1,200 @@ +# Explorando e comparando diferentes LLMs + +[![Exploring and comparing different LLMs](../../images/02-lesson-banner.png?WT.mc_id=academic-105485-koreyst)](https://youtu.be/J1mWzw0P74c?WT.mc_id=academic-105485-koreyst) + +> *Clique na imagem acima para ver o vídeo desta lição* + +Na lição anterior, vimos como a IA generativa está mudando o cenário tecnológico, como os Grandes Modelos de Linguagens (LLMs) funcionam e como uma empresa - como nossa startup - pode aplicá-los aos seus casos de uso e crescer! Neste capítulo, estamos procurando comparar e contrastar diferentes tipos de modelos de linguagem grandes, LLMs para entender seus prós e contras. + +O próximo passo na jornada de nossa startup é explorar o cenário atual dos Grandes Modelos de Linguagem (LLMs) e entender quais são adequados para nosso caso de uso. + +## Introdução + +Esta lição abordará: + +- Diferentes tipos de LLMs no cenário atual. +- Testar, iterar e comparar diferentes modelos para seu caso de uso no Azure. +- Como implantar um LLM. + +## Objetivos de aprendizagem + +Após a conclusão desta lição, você será capaz de: + +- Selecionar o modelo certo para seu caso de uso. +- Entender como testar, iterar e melhorar o desempenho do seu modelo. +- Saber como as empresas implantam modelos. + +## Entenda diferentes tipos de LLMs + +Os Grandes Modelos de Linguagem (LLMs) podem ter várias categorizações com base em sua arquitetura, dados de treinamento e caso de uso. Entender essas diferenças ajudará nossa startup a selecionar o modelo certo para o cenário e entender como testar, iterar e melhorar o desempenho. + +Existem muitos tipos diferentes de modelos LLM, sua escolha de modelo depende do que você pretende usá-los, seus dados, quanto você está pronto para pagar e muito mais. + +Dependendo se você pretende usar os modelos para geração de texto, áudio, vídeo ou imagem você pode optar por um tipo diferente de modelo. + +- **Reconhecimento de áudio e fala**: para esse fim, os modelos do tipo Whisper são uma ótima escolha. Pois são de propósito geral e destinados ao reconhecimento de fala. Ele é treinado em áudio diversificado e pode realizar reconhecimento de fala multilíngue. Saiba mais sobre [modelos do tipo Whisper aqui](https://platform.openai.com/docs/models/whisper?WT.mc_id=academic-105485-koreyst). + +- **Geração de Imagem**: para geração de imagem, DALL-E e Midjourney são duas escolhas muito conhecidas. DALL-E é oferecido pelo Azure OpenAI. [Leia mais sobre DALL-E aqui](https://platform.openai.com/docs/models/dall-e?WT.mc_id=academic-105485-koreyst) e também no Capítulo 9 deste currículo. + +- **Geração de texto**: a maioria dos modelos é treinada na geração de texto e você tem uma grande variedade de escolhas, desde GPT-3.5 até GPT-4. Eles vêm a custos diferentes, sendo o GPT-4 o mais caro. Vale a pena dar uma olhada no [Azure Open AI playground](https://oai.azure.com/portal/playground?WT.mc_id=academic-105485-koreyst) para avaliar quais modelos se adequam melhor às suas necessidades em termos de capacidade e custo. + +Escolher um modelo significa que você obtém algumas capacidades básicas, que podem não ser suficientes. Muitas vezes, você tem dados específicos da empresa que precisa informar ao LLM. Existem algumas opções diferentes sobre como abordar isso, abordaremos mais sobre isso nas próximas seções. + +### Modelos de base versus LLMs + +O termo Modelo de Fundação foi [criado por pesquisadores de Stanford](https://arxiv.org/abs/2108.07258?WT.mc_id=academic-105485-koreyst) e definido como um modelo de IA que segue alguns critérios, como: + +- **Eles são treinandos usando aprendizado não supervisionado ou aprendizado auto-supervisionado**, o que significa que são treinados em dados multimodais não rotulados e não requerem anotação humana ou rotulagem de dados para seu processo de treinamento. + +- **Eles são modelos muito grandes**, baseados em redes neurais muito profundas treinadas em bilhões de parâmetros. + +- **Normalmente, eles são destinados a servir como uma ‘base’ para outros modelos**, o que significa que podem ser usados como ponto de partida para outros modelos serem construídos em cima, o que pode ser feito por ajuste fino. + +![Foundation Models versus LLMs](../../images/FoundationModel.png?WT.mc_id=academic-105485-koreyst) + +Fonte da imagem: [Essential Guide to Foundation Models and Large Language Models | by Babar M Bhatti | Medium +](https://thebabar.medium.com/essential-guide-to-foundation-models-and-large-language-models-27dab58f7404?WT.mc_id=academic-105485-koreyst) + +Para esclarecer ainda mais essa distinção, vamos usar o ChatGPT como exemplo. Para criar a primeira versão do ChatGPT, um modelo chamado GPT-3.5 serviu como modelo fundamental. Isso significa que a OpenAI utilizou alguns dados específicos de conversação para criar uma versão ajustada do GPT-3.5 que foi especializada em se sair bem em cenários de conversação, como chatbots. + +![Foundation Model](../../images/Multimodal.png?WT.mc_id=academic-105485-koreyst) + +Fonte da imagem: [2108.07258.pdf (arxiv.org)](https://arxiv.org/pdf/2108.07258.pdf?WT.mc_id=academic-105485-koreyst) + +### Modelos de Código Aberto versus Modelos Proprietários + +Outra maneira de categorizar os Modelos de Linguagem de Grande Escala (LLMs) é se eles são de código aberto ou proprietários. + +Os modelos de código aberto são modelos que são disponibilizados ao público e podem ser usados por qualquer pessoa. Eles são frequentemente disponibilizados pela empresa que os criou ou pela comunidade de pesquisa. Esses modelos podem ser inspecionados, modificados e personalizados para diversos casos de uso em LLMs. No entanto, nem sempre são otimizados para uso em produção e podem não ser tão eficientes quanto os modelos proprietários. Além disso, o financiamento para modelos de código aberto pode ser limitado, e eles podem não ser mantidos a longo prazo ou não ser atualizados com as pesquisas mais recentes. Exemplos de modelos de código aberto populares incluem [Alpaca](https://crfm.stanford.edu/2023/03/13/alpaca.html?WT.mc_id=academic-105485-koreyst), [Bloom](https://sapling.ai/llm/bloom?WT.mc_id=academic-105485-koreyst) e [LLaMA](https://sapling.ai/llm/llama?WT.mc_id=academic-105485-koreyst). + +Os modelos proprietários são modelos de propriedade de uma empresa e não são disponibilizados ao público. Esses modelos são frequentemente otimizados para uso em produção. No entanto, não podem ser inspecionados, modificados ou personalizados para diferentes casos de uso. Além disso, nem sempre estão disponíveis gratuitamente e podem exigir uma assinatura ou pagamento para uso. Além disso, os usuários não têm controle sobre os dados usados para treinar o modelo, o que significa que devem confiar ao proprietário do modelo o compromisso com a privacidade dos dados e o uso responsável da IA. Exemplos de modelos proprietários populares incluem [modelos da OpenAI](https://platform.openai.com/docs/models/overview?WT.mc_id=academic-105485-koreyst), [Google Bard](https://sapling.ai/llm/bard?WT.mc_id=academic-105485-koreyst) ou [Claude 2](https://www.anthropic.com/index/claude-2?WT.mc_id=academic-105485-koreyst). + +### Embeddings versus Geração de Imagem versus Geração de Texto e Código + +Os LLMs também podem ser categorizados com base na saída que geram. + +Os `embeddings` são um conjunto de modelos que podem converter texto em uma forma numérica, chamada `embedding`, que é uma representação numérica do texto de entrada. Os `embeddings` facilitam a compreensão das relações entre palavras ou frases por máquinas e podem ser usadas como entradas por outros modelos, como modelos de classificação ou modelos de agrupamento que têm um melhor desempenho com dados numéricos. Modelos de incorporação são frequentemente usados para aprendizado por transferência, onde um modelo é construído para uma tarefa substituta para a qual há uma abundância de dados, e em seguida, os pesos do modelo (`embeddings`) são reutilizados para outras tarefas subsequentes. Um exemplo desta categoria é [Embeddings no OpenAI](https://platform.openai.com/docs/models/embeddings?WT.mc_id=academic-105485-koreyst). + +![Embedding](../../images/Embedding.png?WT.mc_id=academic-105485-koreyst) + +Modelos de geração de imagem são modelos que geram imagens. Esses modelos são frequentemente usados para edição de imagens, síntese de imagens e tradução de imagens. Modelos de geração de imagem são frequentemente treinados em grandes conjuntos de dados de imagens, como [LAION-5B](https://laion.ai/blog/laion-5b/?WT.mc_id=academic-105485-koreyst), e podem ser usados para gerar novas imagens ou editar imagens existentes com técnicas de inpainting, super-resolução e colorização. Exemplos incluem [DALL-E-3](https://openai.com/dall-e-3?WT.mc_id=academic-105485-koreyst) e [modelos do Stable Diffusion](https://github.com/Stability-AI/StableDiffusion?WT.mc_id=academic-105485-koreyst). + +![Image Generation](../../images/Image.png?WT.mc_id=academic-105485-koreyst) + +Modelos de geração de texto e código são modelos que geram texto ou código. Esses modelos são frequentemente usados para resumir texto, traduzir e responder a perguntas. Modelos de geração de texto são frequentemente treinados em grandes conjuntos de dados de texto, como [BookCorpus](https://www.cv-foundation.org/openaccess/content_iccv_2015/html/Zhu_Aligning_Books_and_ICCV_2015_paper.html?WT.mc_id=academic-105485-koreyst), e podem ser usados para gerar novo texto ou responder a perguntas. Modelos de geração de código, como [CodeParrot](https://huggingface.co/codeparrot?WT.mc_id=academic-105485-koreyst), são frequentemente treinados em grandes conjuntos de dados de código, como o GitHub, e podem ser usados para gerar novo código ou corrigir bugs em código existente. + +![Text and code generation](../../images/Text.png?WT.mc_id=academic-105485-koreyst) + +### Encoder-Decoder versus Decoder-only + +Para falar sobre os diferentes tipos de arquiteturas de Grandes Modelos de Linguagem (LLMs), vamos usar uma analogia. + +Imagine que seu gerente te deu uma tarefa de escrever um questionário para os alunos. Você tem dois colegas; um supervisiona a criação do conteúdo e o outro supervisiona a revisão. + +O criador de conteúdo é como um modelo somente `Decoder`, ele pode olhar para o tópico e ver o que você já escreveu e então ele pode escrever um curso com base nisso. Eles são muito bons em escrever conteúdo envolvente e informativo, mas não são muito bons em entender o tópico e os objetivos de aprendizado. Alguns exemplos de modelos Decodificadores são os modelos da família GPT, como o GPT-3. + +O revisor é como um modelo somente `Encoder`, eles olham para o curso escrito e as respostas, percebendo a relação entre eles e entendendo o contexto, mas não são bons em gerar conteúdo. Um exemplo de modelo somente Codificador seria o BERT. + +Imagine que também podemos ter alguém que possa criar e revisar o questionário, este é um modelo `Encoder-Decoder`. Alguns exemplos seriam `BART` e `T5`. + +### Serviço versus Modelo + +Agora, vamos falar sobre a diferença entre um serviço e um modelo. Um serviço é um produto oferecido por um Provedor de Serviços em Nuvem e é frequentemente uma combinação de modelos, dados e outros componentes. Um modelo é o componente central de um serviço e é frequentemente um modelo fundamental, como um LLM. + +Os serviços são frequentemente otimizados para uso em produção e muitas vezes são mais fáceis de usar do que os modelos, por meio de uma interface gráfica de usuário. No entanto, os serviços nem sempre estão disponíveis gratuitamente e podem exigir uma assinatura ou pagamento para uso, em troca de aproveitar os recursos e equipamentos do proprietário do serviço, otimizando despesas e escalando facilmente. Um exemplo de serviço é o [Serviço do Azure OpenAI](https://learn.microsoft.com/azure/ai-services/openai/overview?WT.mc_id=academic-105485-koreyst), que oferece um plano de tarifas pay-as-you-go, o que significa que os usuários são cobrados de acordo com o quanto usam o serviço. Além disso, o serviço do Azure OpenAI oferece segurança de nível empresarial e um framework de IA responsável sobre as capacidades dos modelos. + +Os modelos são apenas as Redes Neurais, com parâmetros, pesos e outros. Isso permite que as empresas os executem localmente. No entanto, elas precisariam comprar equipamentos, criar uma estrutura para escalar e adquirir uma licença ou usar um modelo de código aberto. Um modelo como o `LLaMA` está disponível para uso, exigindo poder computacional para executar o modelo. + +## Como testar e iterar com diferentes modelos para entender o desempenho no Azure + +Depois que nossa equipe explorou o cenário atual dos LLMs e identificou alguns bons candidatos para seus cenários, o próximo passo é testá-los em seus dados e carga de trabalho. Isso é um processo iterativo, feito por meio de experimentos e medições. +A maioria dos modelos mencionados nos parágrafos anteriores (modelos da OpenAI, modelos de código aberto como `Llama2` e `Hugging Face transformers`) está disponível no [Foundation Models](https://learn.microsoft.com/azure/machine-learning/concept-foundation-models?WT.mc_id=academic-105485-koreyst) no [Azure Machine Learning studio](https://ml.azure.com/?WT.mc_id=academic-105485-koreyst). + +[Azure Machine Learning](https://azure.microsoft.com/products/machine-learning/?WT.mc_id=academic-105485-koreyst) é um serviço em nuvem projetado para Cientistas de Dados e Engenheiros de Machine Learning que gerenciam o ciclo completo de Aprendizado de Máquina (treinamento, teste, implantação e gerenciamento de MLOps) em uma única plataforma. O Machine Learning Studio oferece uma interface gráfica de usuário para este serviço e permite ao usuário: + +- Encontrar o Foundation Model de interesse no catálogo, filtrando por tarefa, licença ou nome. Também é possível importar novos modelos que ainda não estejam incluídos no catálogo. +- Analisar o cartão do modelo, incluindo uma descrição detalhada e exemplos de código, e testá-lo com o widget de Inferência de Amostra, fornecendo um prompt de amostra para testar o resultado. + +![Cartão do Modelo](../../images/Llama1.png?WT.mc_id=academic-105485-koreyst) + +- Avaliar o desempenho do modelo com métricas de avaliação objetivas em uma carga de trabalho específica e um conjunto de dados específico fornecido como entrada. + +![Avaliação do Modelo](../../images/Llama2.png?WT.mc_id=academic-105485-koreyst) + +- Ajustar o modelo com dados de treinamento personalizados para melhorar o desempenho do modelo em uma carga de trabalho específica, aproveitando as capacidades de experimentação e rastreamento do Aprendizado de Máquina do Azure. + +![Ajuste do Modelo](../../images/Llama3.png?WT.mc_id=academic-105485-koreyst) + +- Implante o modelo pré-treinado original ou a versão ajustada a um ponto de extremidade remoto em tempo real ou por lote, para permitir que aplicativos o consumam. + +![Implantação do Modelo](../../images/Llama4.png?WT.mc_id=academic-105485-koreyst) + +## Melhorando os Resultados dos LLMs + +Exploramos com nossa equipe de startup diferentes tipos de Modelos de Linguagem de Grande Escala (LLMs) e uma Plataforma em Nuvem (Azure Machine Learning) que nos permite comparar diferentes modelos, avaliá-los em dados de teste, melhorar o desempenho e implantá-los em pontos de extremidade de inferência. + +Mas quando eles devem considerar o ajuste fino de um modelo em vez de usar um pré-treinado? Existem outras abordagens para melhorar o desempenho do modelo em cargas de trabalho específicas? + +Existem várias abordagens que uma empresa pode usar para obter os resultados desejados de um LLM, você pode selecionar diferentes tipos de modelos com diferentes graus de treinamento. + +Implantar um LLM em produção, com diferentes níveis de complexidade, custo e qualidade. Aqui estão algumas abordagens diferentes: + +- **Engenharia de prompts com contexto**: a ideia é fornecer contexto suficiente ao formular o prompt para garantir que você obtenha as respostas de que precisa. + +- **Geração Aprimorada com Recuperação, RAG**: seus dados podem existir em um banco de dados ou ponto de extremidade da web, por exemplo. Para garantir que esses dados, ou um subconjunto deles, estejam incluídos no momento do prompt, você pode buscar os dados relevantes e torná-los parte do prompt do usuário. + +- **Modelo ajustado fino**: nesse caso, você treinou o modelo ainda mais com seus próprios dados, o que torna o modelo mais preciso e responsivo às suas necessidades, mas pode ser custoso. + +![Implantação de LLMs](../../images/Deploy.png?WT.mc_id=academic-105485-koreyst) + +Fonte da imagem: [Quatro Maneiras de Empresas Implatarem LLMs | Blog Fiddler AI](https://www.fiddler.ai/blog/four-ways-that-enterprises-deploy-llms?WT.mc_id=academic-105485-koreyst) + +### Engenharia de Prompts com Contexto + +Os LLMs pré-treinados funcionam muito bem em tarefas de linguagem natural generalizadas, mesmo quando chamados com um prompt curto, como uma frase a ser completada ou uma pergunta - o chamado "aprendizado de zero-shot". + +No entanto, quanto mais o usuário puder estruturar sua consulta, com uma solicitação detalhada e exemplos (o Contexto) mais precisa e próxima das expectativas do usuário será a resposta. Nesse caso, falamos de "aprendizado de um único exemplo" se o prompt incluir apenas um exemplo e "aprendizado de alguns exemplos" se incluir vários exemplos. +A Engenharia de Prompts com contexto é a abordagem mais econômica para começar. + +### Recuperação de Geração Aumentada (RAG) + +Os LLMs têm a limitação de que só podem usar os dados que foram usados durante seu treinamento para gerar uma resposta. Isso significa que eles não sabem nada sobre os fatos que ocorreram após seu processo de treinamento e não podem acessar informações não públicas (como dados de uma empresa). +Isso pode ser superado por meio do `RAG`, uma técnica que amplia o prompt com dados externos na forma de trechos de documentos, considerando limites de comprimento do prompt. Isso é suportado por ferramentas de banco de dados vetoriais (como [Azure Vector Search](https://learn.microsoft.com/azure/search/vector-search-overview?WT.mc_id=academic-105485-koreyst)) que recuperam trechos úteis de várias fontes de dados predefinidas e os adicionam ao Contexto do prompt. + +Essa técnica é muito útil quando uma empresa não possui dados suficientes, tempo suficiente ou recursos para ajustar finamente um LLM, mas ainda deseja melhorar o desempenho em uma carga de trabalho específica e reduzir os riscos de alucinações. Ou seja, mistificação da realidade ou conteúdo prejudicial. + +### Modelo Ajustado Fino + +O ajuste fino é um processo que alavanca a aprendizagem por transferência para 'adaptar' o modelo a uma tarefa subsequente ou para resolver um problema específico. Diferentemente do aprendizado de alguns exemplos e do RAG, ele resulta na geração de um novo modelo, com pesos e vieses atualizados. Isso requer um conjunto de exemplos de treinamento consistindo de uma única entrada (o prompt) e sua saída associada (a conclusão). +Essa seria a abordagem preferida se: + +- **Usando modelos ajustados finamente**: Uma empresa deseja usar modelos menos capazes ajustados finamente (como modelos de incorporação) em vez de modelos de alto desempenho, resultando em uma solução mais econômica e rápida. + +- **Considerando a latência**: A latência é importante para um caso de uso específico, portanto, não é possível usar prompts muito longos ou o número de exemplos que devem ser aprendidos a partir do modelo não se encaixa no limite de comprimento do prompt. + +- **Mantendo-se atualizado**: Uma empresa possui muitos dados de alta qualidade e rótulos de verdade fundamentais e os recursos necessários para manter esses dados atualizados ao longo do tempo. + +### Modelo Treinado + +Treinar um LLM a partir do zero é, sem dúvida, a abordagem mais difícil e complexa de adotar, exigindo enormes quantidades de dados, recursos qualificados e poder computacional adequado. Essa opção deve ser considerada apenas em um cenário em que uma empresa possui um caso de uso específico de domínio e uma grande quantidade de dados centrados no domínio. + +## Verificação de Conhecimento + +Qual poderia ser uma boa abordagem para melhorar os resultados de completude do LLM? + +1. Engenharia de prompts com contexto +1. RAG +1. Modelo ajustado fino + +R: 3 Pois, se você tem o tempo, os recursos e dados de alta qualidade, o ajuste fino é a melhor opção para se manter atualizado. No entanto, se você está procurando melhorar as coisas e está com pouco tempo, vale a pena considerar o RAG primeiro. + +## 🚀 Desafio + +Saiba mais sobre como você pode [usar o RAG](https://learn.microsoft.com/azure/search/retrieval-augmented-generation-overview?WT.mc_id=academic-105485-koreyst) para o seu negócio. + +## Ótimo Trabalho, Continue com Seu Aprendizado + +Deseja aprender mais sobre diferentes conceitos de IA Generativa? Acesse a [página de aprendizado contínuo](../../../13-continued-learning/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) para encontrar outros ótimos recursos sobre este tópico. + +Vamos para a Lição 3, onde veremos como podemos [Criar IA Generativa de forma Responsável](../../../03-using-generative-ai-responsibly/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst)! + diff --git a/03-using-generative-ai-responsibly/translations/pt-br/README.md b/03-using-generative-ai-responsibly/translations/pt-br/README.md new file mode 100644 index 000000000..651d0a328 --- /dev/null +++ b/03-using-generative-ai-responsibly/translations/pt-br/README.md @@ -0,0 +1,134 @@ +# Usando a IA Generativa de Forma Responsável + +[![Usando a IA Generativa de Forma Responsável](../../images/03-lesson-banner.png?WT.mc_id=academic-105485-koreyst)]() + +> **Vídeo em Breve** + +É fácil se encantar com a IA e a IA generativa em particular. Mas é preciso considerar como você a usará de forma responsável. Você precisa considerar coisas como como garantir que a saída seja justa, não prejudicial e muito mais. Este capítulo tem como objetivo fornecer o contexto mencionado, o que considerar e como tomar medidas ativas para melhorar o uso de sua IA. + +## Introdução + +Esta lição abordará: + +- Por que você deve priorizar a IA Responsável ao criar aplicações de IA Generativa. +- Princípios fundamentais da IA Responsável e como eles se relacionam com a IA Generativa. +- Como colocar esses princípios de IA Responsável em prática por meio de estratégias e ferramentas. + +## Metas de Aprendizado + +Após completar esta lição, você saberá: + +- A importância da IA Responsável ao criar aplicações de IA Generativa. +- Quando pensar e aplicar os princípios fundamentais da IA Responsável ao criar aplicações de IA Generativa. +- Quais ferramentas e estratégias estão disponíveis para você colocar o conceito de IA Responsável em prática. + +## Princípios de IA Responsável + +A empolgação em torno da IA Generativa nunca foi tão alta. Essa empolgação trouxe muitos novas pessoas desenvolvedoras, atenção e financiamento para esse espaço. Embora isso seja muito positivo para quem deseja construir produtos e empresas usando a IA Generativa, também é importante que procedamos de forma responsável. + +Ao longo deste curso, estamos nos concentrando em criar nossa startup e nosso produto de educação em IA. Usaremos os princípios da IA Responsável: Justiça, Inclusão, Confiabilidade/Segurança, Segurança e Privacidade, Transparência e Responsabilidade. Com esses princípios, exploraremos como eles se relacionam com o nosso uso da IA Generativa em nossos produtos. + +## Por Que Você Deve Priorizar a IA Responsável + +Ao criar um produto, adotar uma abordagem centrada no ser humano, mantendo o melhor interesse de seus usuários em mente, sempre leva aos melhores resultados. + +A singularidade da IA Generativa está em seu poder de criar respostas úteis, informações, orientações e conteúdo para os usuários. Isso pode ser feito sem muitas etapas manuais, o que pode levar a resultados muito impressionantes. Sem um planejamento adequado e estratégias, também pode infelizmente levar a alguns resultados prejudiciais para seus usuários, seu produto e a sociedade como um todo. + +Vamos dar uma olhada em alguns (mas não todos) desses resultados potencialmente prejudiciais: + +### Alucinações + +Alucinações é um termo usado para descrever quando um LLM produz conteúdo que é completamente sem sentido ou algo que sabemos ser factualmente incorreto com base em outras fontes de informação. + +Vamos dar, por exemplo, a criação de um recurso para nossa startup que permite aos estudantes fazer perguntas históricas a um modelo. Um estudante faz a pergunta `Quem foi o único sobrevivente do Titanic?` + +O modelo produz uma resposta como a que está abaixo: + +![Prompt dizendo "Quem foi o único sobrevivente do Titanic"](../../../03-using-generative-ai-responsibly/images/2135-ChatGPT(1)_11zon.webp?WT.mc_id=academic-105485-koreyst) + +> *(Fonte: [Flying bisons](https://flyingbisons.com?WT.mc_id=academic-105485-koreyst))* + +Esta é uma resposta muito confiante e completa. Infelizmente, está incorreta. Mesmo com uma quantidade mínima de pesquisa, alguém descobriria que houve mais de um sobrevivente do Titanic. Para um estudante que está começando a pesquisar esse tópico, essa resposta pode ser persuasiva o suficiente para não ser questionada e tratada como fato. As consequências disso podem levar ao sistema de IA sendo pouco confiável e impactar negativamente a reputação de nossa startup. + +Com cada iteração de qualquer LLM dado, vimos melhorias de desempenho na minimização de alucinações. Mesmo com essa melhoria, nós, como construtores e usuários de aplicativos, ainda precisamos estar cientes dessas limitações. + +### Conteúdo Prejudicial + +Nós cobrimos na seção anterior quando um LLM produz respostas incorretas ou sem sentido. Outro risco que precisamos estar cientes é quando um modelo responde com conteúdo prejudicial. + +Conteúdo prejudicial pode ser definido como: + +- Fornecer instruções ou incentivar autolesão ou dano a certos grupos. +- Conteúdo odioso ou humilhante. +- Orientar o planejamento de qualquer tipo de ataque ou atos violentos. +- Fornecer instruções sobre como encontrar conteúdo ilegal ou cometer atos ilegais. +- Exibir conteúdo sexualmente explícito. + +Para nossa startup, queremos garantir que tenhamos as ferramentas e estratégias certas em vigor para impedir que esse tipo de conteúdo seja visto pelos estudantes. + +### Falta de Equidade + +A equidade é definida como "garantir que um sistema de IA esteja livre de viés e discriminação e que trate todos de forma justa e igual". No mundo da IA Generativa, queremos garantir que visões de mundo excludentes de grupos marginalizados não sejam reforçadas pela saída do modelo. + +Esses tipos de saídas não são apenas destrutivos para a criação de experiências de produtos positivas para nossos usuários. Mas também causam mais danos à sociedade. Como criadores de aplicações, devemos sempre ter em mente uma base de usuários ampla e diversificada ao criar soluções com IA Generativa. + +## Como Usar a IA Generativa de Forma Responsável + +Agora que identificamos a importância da IA Generativa Responsável, vamos ver 4 etapas que podemos seguir para construir nossas soluções de IA de forma responsável: + +![Ciclo de Mitigação](../../images/mitigate-cycle.png?WT.mc_id=academic-105485-koreyst) + +### Medir Danos Potenciais + +Na área de testes de software, testamos as ações esperadas de um usuário em um aplicativo. Da mesma forma, testar um conjunto diversificado de prompts que os usuários provavelmente usarão é uma boa maneira de medir o dano potencial. + +Como nossa startup está criando um produto de educação, seria bom preparar uma lista de prompts relacionados à educação. Isso poderia ser para cobrir um certo assunto, fatos históricos e prompts sobre a vida dos estudantes. + +### Mitigar Danos Potenciais + +Agora é hora de encontrar maneiras de prevenir ou limitar o dano potencial causado pelo modelo e suas respostas. Podemos analisar isso em 4 camadas diferentes: + +![Camadas de Mitigação](../../images/mitigation-layers.png?WT.mc_id=academic-105485-koreyst) + +- **Modelo**: escolher o modelo certo para o caso de uso certo. Modelos maiores e mais complexos, como o GPT-4, podem causar mais risco de conteúdo prejudicial quando aplicados a casos de uso menores e mais específicos. Usar seus dados de treinamento para ajuste fino também reduz o risco de conteúdo prejudicial. + +- **Sistema de Segurança**: um sistema de segurança é um conjunto de ferramentas e configurações na plataforma que serve o modelo e ajuda a mitigar o dano. Um exemplo disso é o sistema de filtragem de conteúdo no serviço Azure OpenAI. Os sistemas também devem detectar ataques de jailbreak e atividades indesejadas, como solicitações de bots. + +- **Metaprompt**: metaprompts e fundamentação são maneiras de direcionar ou limitar o modelo com base em determinados comportamentos e informações. Isso poderia ser o uso de entradas do sistema para definir certos limites do modelo. Além disso, fornecer saídas mais relevantes para o escopo ou domínio do sistema. + + Também pode ser o uso de técnicas como a Recuperação de Geração Aumentada (RAG) para fazer com que o modelo obtenha informações apenas de uma seleção de fontes confiáveis. Há uma lição posterior neste curso para [criar aplicações de busca](../../../08-building-search-applications/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) + +- **Experiência do Usuário**: a camada final é onde o usuário interage diretamente com o modelo por meio da interface de nosso aplicativo de alguma forma. Dessa forma, podemos projetar a UI/UX para limitar o usuário quanto aos tipos de entradas que podem enviar ao modelo, bem como ao texto ou imagens exibidos ao usuário. Ao implantar o aplicativo de IA, também devemos ser transparentes sobre o que nossa aplicação de IA Generativa pode e não pode fazer. + +Temos uma lição inteira dedicada a [Projetar UX para Aplicações de IA](../../../12-designing-ux-for-ai-applications/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) + +- **Avaliar o modelo**: trabalhar com LLMs pode ser desafiador porque nem sempre temos controle sobre os dados em que o modelo foi treinado. Independentemente disso, sempre devemos avaliar o desempenho e as saídas do modelo. Ainda é importante medir a precisão, similaridade, fundamentação e relevância do modelo de saída. Isso ajuda a fornecer transparência e confiança aos interessados e usuários. + +### Operar uma Solução de IA Generativa Responsável + +Criar uma prática operacional em torno de suas aplicações de IA é a etapa final. Isso inclui a parceria com outras partes de nossa startup, como Jurídico e Segurança, para garantir que estejamos em conformidade com todas as políticas regulatórias. Antes do lançamento, também queremos criar planos em torno da entrega, tratamento de incidentes e retorno para evitar qualquer dano crescente aos nossos usuários. + +## Ferramentas + +Embora o trabalho de desenvolver soluções de IA Responsável possa parecer muito, porém é um trabalho que vale a pena. À medida que a área de IA Generativa cresce, mais ferramentas para ajudar os desenvolvedores a integrar eficientemente a responsabilidade em seus fluxos de trabalho amadurecerão. Por exemplo, o [Azure AI Content Safety](https://learn.microsoft.com/azure/ai-services/content-safety/overview?WT.mc_id=academic-105485-koreyst ) pode ajudar a detectar conteúdo e imagens prejudiciais por meio de uma solicitação de API. + +## Verificação de Conhecimento + +Quais são algumas coisas das quais você precisa se preocupar para garantir o uso responsável da IA? + +1. Que a resposta esteja correta. +2. Uso prejudicial, para que a IA não seja usada para fins criminosos. +3. Garantir que a IA esteja livre de viés e discriminação. + +R: 2 e 3 estão corretas. A IA Responsável ajuda a considerar como mitigar efeitos prejudiciais e vieses, entre outros. + +## 🚀 Desafio + +Leia sobre o [Azure AI Content Safety](https://learn.microsoft.com/azure/ai-services/content-safety/overview?WT.mc_id=academic-105485-koreyst) e veja o que você pode adotar para o seu uso. + +## Ótimo Trabalho, Continue Sua Aprendizagem + +Quer aprender mais sobre como construir com IA Generativa de forma responsável? Acesse a [página de aprendizado contínuo](../../../13-continued-learning/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) para encontrar outros ótimos recursos sobre esse tópico. + +Vamos agora para a Lição 4, onde exploraremos os [Fundamentos da Engenharia de Prompt](../../../04-prompt-engineering-fundamentals/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst)! + diff --git a/04-prompt-engineering-fundamentals/translations/pt-br/README.md b/04-prompt-engineering-fundamentals/translations/pt-br/README.md new file mode 100644 index 000000000..0839b86bc --- /dev/null +++ b/04-prompt-engineering-fundamentals/translations/pt-br/README.md @@ -0,0 +1,402 @@ +# Fundamentos de Engenharia de Prompt + +[![Prompt Engineering Fundamentals](../../images/04-lesson-banner.png?WT.mc_id=academic-105485-koreyst)](https://youtu.be/r2ItK3UMVTk?WT.mc_id=academic-105485-koreyst) + +A forma como você escreve seu prompt para o LLM importa. Um prompt cuidadosamente elaborado pode alcançar um resultado melhor do que um que não é. Mas o que são esses conceitos, prompt, Engenharia de Prompt e como posso melhorar o que envio para o LLM? Perguntas como essas são o que este capítulo e o próximo estão procurando responder. + +_A IA Generativa_ é capaz de criar novo conteúdo (por exemplo, texto, imagens, áudio, código etc.) em resposta a solicitações do usuário. Isso é alcançado usando _Modelos de Linguagem Grandes_ (LLMs) como a série GPT ("Generative Pre-trained Transformer") da OpenAI, que são treinados para usar linguagem natural e código. + +Os usuários agora podem interagir com esses modelos usando paradigmas familiares como chat, sem precisar de nenhuma experiência técnica ou treinamento. Os modelos são _baseados em prompt_ - os usuários enviam uma entrada de texto (prompt) e recebem a resposta da IA (completação). Eles podem então "conversar com a IA" de forma iterativa, em conversas de várias rodadas, refinando seu prompt até que a resposta atenda às suas expectativas. + +"Prompts" agora se tornam a principal _interface de programação_ para aplicativos de IA generativa, indicando aos modelos o que fazer e influenciando a qualidade das respostas retornadas. "Engenharia de Prompt" é um campo de estudo em rápido crescimento que se concentra no _design e otimização_ de prompts para fornecer respostas consistentes e de qualidade em escala. + +## Metas de Aprendizado + +Nesta lição, aprenderemos o que é Engenharia de Prompt, por que isso é importante e como podemos criar prompts mais eficazes para um modelo e objetivo de aplicativo específicos. Compreenderemos os conceitos centrais e as melhores práticas para a Engenharia de Prompt - e conheceremos um ambiente interativo de Jupyter Notebooks "sandbox" onde podemos ver esses conceitos aplicados a exemplos reais. + +Ao final desta lição, seremos capazes de: + +1. Explicar o que é Engenharia de Prompt e por que isso importa. +2. Descrever os componentes de um prompt e como eles são usados. +3. Aprender melhores práticas e técnicas para a Engenharia de Prompt. +4. Aplicar técnicas aprendidas a exemplos reais, usando um endpoint da OpenAI. + +## Sandbox de Aprendizado + +A Engenharia de Prompt é atualmente mais uma arte do que uma ciência. A melhor maneira de aprimorar nossa intuição é _praticar mais_ e adotar uma abordagem de tentativa e erro que combine experiência no domínio de aplicação com técnicas recomendadas e otimizações específicas do modelo. + +O Jupyter Notebook que acompanha esta lição, fornece um ambiente _sandbox_ onde você pode experimentar o que aprende - à medida que avança ou como parte do desafio de código no final. Para executar os exercícios, você precisará de: + +1. Uma chave de API da OpenAI - o endpoint de serviço para um LLM implantado. + +2. Um tempo de execução Python - no qual o Notebook pode ser executado. + +Nós instrumentamos este repositório com um _contêiner de desenvolvimento_ (_dev container_) que vem com um tempo de execução Python 3. Abra simplesmente o repositório no GitHub Codespaces ou no seu Docker Desktop localmente para ativar o tempo de execução automaticamente. Em seguida, abra o notebook e selecione o kernel Python 3.x para preparar o Notebook para execução. + +O notebook padrão está configurado para uso com uma chave de API da OpenAI. Basta copiar o arquivo `.env.copy` na raiz da pasta para `.env` e atualizar a linha `OPENAI_API_KEY=` com sua chave de API - e você estará pronto. + +O notebook vem com exercícios _iniciais_, mas você é incentivado a adicionar suas próprias seções de _Markdown_ (descrição) e _Código_ (solicitações de prompt) para experimentar mais exemplos ou ideias - e construir sua intuição para o design de prompt. + +## Nossa Startup + +Agora, vamos falar sobre como _esse tópico_ se relaciona com a missão de nossa startup de [trazer inovação de IA para a educação](https://educationblog.microsoft.com/2023/06/collaborating-to-bring-ai-innovation-to-education?WT.mc_id=academic-105485-koreyst). Queremos criar aplicações de aprendizado personalizado impulsionados por IA. Então, vamos pensar em como diferentes usuários da nossa aplicação podem "projetar" prompts: + +- **Administradores** podem pedir à IA para _analisar dados do currículo para identificar lacunas na cobertura_. A IA pode resumir os resultados ou visualizá-los com código. +- **Educadores** podem pedir à IA para _gerar um plano de aula para um público-alvo e tópico_. A IA pode criar o plano personalizado em um formato especificado. +- **Alunos** podem pedir à IA para _ajudá-los em uma disciplina difícil_. A IA pode orientar os alunos com lições, dicas e exemplos adaptados ao seu nível. + +Isso é apenas a ponta do iceberg. Confira [Prompts For Education](https://github.com/microsoft/prompts-for-edu/tree/main?WT.mc_id=academic-105485-koreyst) - uma biblioteca de prompts de código aberto curada por especialistas em educação - para ter uma visão mais ampla das possibilidades! _Experimente executar alguns desses prompts na sandbox ou usando o OpenAI Playground para ver o que acontece!_ + + + +## O que é Engenharia de Prompt? + +Começamos esta lição definindo **Engenharia de Prompt** como o processo de _projetar e otimizar_ entradas de texto (prompts) para fornecer respostas consistentes e de qualidade (completions) para um objetivo de aplicativo e modelo específicos. Podemos pensar nisso como um processo de 2 etapas: + +- _projetar_ o prompt inicial para um modelo e objetivo específicos +- _refinar_ iterativamente o prompt para melhorar a qualidade da resposta + +Isso é necessariamente um processo de tentativa e erro que requer intuição do usuário e esforço para obter resultados ótimos. Então, por que é importante? Para responder a essa pergunta, primeiro precisamos entender três conceitos: + +- _Tokenização_ = como o modelo "enxerga" o prompt +- _Base LLMs_ = como o modelo fundamental "processa" um prompt +- _Instruction-Tuned LLMs_ = como o modelo agora pode ver "tarefas" + +### Tokenização + +Um LLM vê prompts como uma _sequência de tokens_ onde diferentes modelos (ou versões de um modelo) podem tokenizar o mesmo prompt de maneiras diferentes. Como os LLMs são treinados em tokens (não em texto bruto), a forma como os prompts são tokenizados tem um impacto direto na qualidade da resposta gerada. + +Para ter uma intuição de como a tokenização funciona, experimente ferramentas como o [OpenAI Tokenizer](https://platform.openai.com/tokenizer?WT.mc_id=academic-105485-koreyst) mostrado abaixo. Copie seu prompt e veja como ele é convertido em tokens, prestando atenção em como caracteres de espaço em branco e pontuações são tratados. Note que este exemplo mostra um LLM mais antigo (GPT-3) - então, tentar isso com um modelo mais recente pode produzir um resultado diferente. + +![Tokenization](../../images/04-tokenizer-example.png?WT.mc_id=academic-105485-koreyst) + +### Conceito: Modelos Fundamentais + +Uma vez que um prompt é tokenizado, a função principal do ["Base LLM"](https://blog.gopenai.com/an-introduction-to-base-and-instruction-tuned-large-language-models-8de102c785a6?WT.mc_id=academic-105485-koreyst) (ou modelo fundamental) é prever o token nessa sequência. Como os LLMs são treinados em conjuntos massivos de dados de texto, eles têm uma boa compreensão das relações estatísticas entre tokens e podem fazer essa previsão com alguma confiança. + +> Observação: eles não compreendem o _significado_ das palavras no prompt ou token; eles apenas veem um padrão que podem "completar" com sua próxima previsão. Eles podem continuar prevendo a sequência até serem interrompidos pela intervenção do usuário ou alguma condição preestabelecida. + +Desejam ver como a conclusão baseada em prompts funciona? Insira o prompt acima no [_Chat Playground_](https://oai.azure.com/playground?WT.mc_id=academic-105485-koreyst) do Azure OpenAI Studio com as configurações padrão. O sistema está configurado para tratar prompts como solicitações de informação - então, você deve ver uma conclusão que atende a esse contexto. + +Mas e se o usuário quiser ver algo específico que atenda a alguns critérios ou objetivos de tarefa? É aqui que os LLMs _instruídos_ entram em cena. + +![Base LLM Chat Completion](../../images/04-playground-chat-base.png?WT.mc_id=academic-105485-koreyst) + +### Conceito: LLMs Instruídos + +Um [LLM Instruído](https://blog.gopenai.com/an-introduction-to-base-and-instruction-tuned-large-language-models-8de102c785a6?WT.mc_id=academic-105485-koreyst) começa com o modelo fundamental e o ajusta com exemplos ou pares de entrada/saída (por exemplo, "mensagens" de várias rodadas) que podem conter instruções claras - e a resposta da IA tenta seguir essa instrução. + +Isso usa técnicas como Aprendizado por Reforço com Feedback Humano (ARFH) que podem treinar o modelo a _seguir instruções_ e _aprender com feedback_ para que produza respostas mais adequadas a aplicações práticas e mais relevantes para objetivos do usuário. + +Vamos experimentar - revisite o prompt acima, mas agora altere a _mensagem do sistema_ para fornecer a seguinte instrução como contexto: + +> _Summarize content you are provided with for a second-grade student. Keep the result to one paragraph with 3-5 bullet points._ + +Veja como o resultado agora está ajustado para refletir o objetivo desejado e o formato? Um educador pode agora usar diretamente essa resposta em seus slides para aquela aula. + +![Instruction Tuned LLM Chat Completion](../../images/04-playground-chat-instructions.png?WT.mc_id=academic-105485-koreyst) + +## Por que precisamos de Engenharia de Prompt? + +Agora que sabemos como os prompts são processados pelos LLMs, vamos falar sobre _por que_ precisamos de Engenharia de Prompt. A resposta está no fato de que os LLMs atuais apresentam uma série de desafios que tornam as _completions confiáveis e consistentes_ mais difíceis de alcançar sem esforço na criação e otimização do prompt. Por exemplo: + +1. **As respostas do modelo são estocásticas.** O _mesmo prompt_ provavelmente produzirá respostas diferentes com modelos ou versões diferentes do modelo. E pode até mesmo produzir resultados diferentes com o _mesmo modelo_ em momentos diferentes. _Técnicas de Wngenharia de Prompt podem nos ajudar a minimizar essas variações fornecendo melhores diretrizes_. + +1. **Os modelos podem criar respostas imaginárias.** Os modelos são pré-treinados com conjuntos de dados _grandes, mas finitos_, o que significa que eles não têm conhecimento sobre conceitos fora desse escopo de treinamento. Como resultado, podem produzir completions imprecisas, imaginárias ou diretamente contraditórias aos fatos conhecidos. _Técnicas de Engenharia de Prompt ajudam os usuários a identificar e mitigar alucinações, por exemplo, pedindo à IA por citações ou raciocínio_. + +1. **As capacidades dos modelos variarão.** Modelos ou gerações de modelos mais recentes terão capacidades mais ricas, mas também trarão peculiaridades e compensações únicas em termos de custo e complexidade. _A Engenharia de Prompt pode nos ajudar a desenvolver melhores práticas e fluxos de trabalho que abstraem diferenças e se adaptam aos requisitos específicos do modelo de maneira escalável e contínua_. + +Vamos ver isso em ação no OpenAI ou Azure OpenAI Playground: + +- Use o mesmo prompt com diferentes implantações de LLM (por exemplo, OpenAI, Azure OpenAI, Hugging Face) - você viu as variações? +- Use o mesmo prompt repetidamente com a _mesma_ implantação de LLM (por exemplo, Azure OpenAI Playground) - como essas variações diferiram? + +### Exemplo de Alucinações + +Quer ter uma ideia de como as alucinações funcionam? Pense em um prompt que instrua a IA a gerar conteúdo para um tópico inexistente (para garantir que não seja encontrado no conjunto de dados de treinamento). Por exemplo - eu tentei este prompt: +> **Prompt:** generate a lesson plan on the Martian War of 2076. + +Uma busca na web mostrou que havia relatos fictícios (por exemplo, séries de televisão ou livros) sobre guerras marcianas - mas nenhuma em 2076. O bom senso também nos diz que 2076 está _no futuro_ e, portanto, não pode ser associado a um evento real. + +Então, o que acontece quando executamos este prompt com diferentes provedores de LLM? + +> **Resposta 1**: OpenAI Playground (GPT-35) + +![Resposta 1](../../images/04-fabrication-aoai.png?WT.mc_id=academic-105485-koreyst) + +> **Resposta 2**: Azure OpenAI Playground (GPT-35) + +![Response 2](../../images/04-fabrication-aoai.png?WT.mc_id=academic-105485-koreyst) + +> **Resposta 3**: : Hugging Face Chat Playground (LLama-2) + +![Response 3](../../images/04-fabrication-huggingchat.png?WT.mc_id=academic-105485-koreyst) + +Como esperado, cada modelo (ou versão do modelo) produz respostas ligeiramente diferentes devido ao comportamento estocástico e variações nas capacidades do modelo. Por exemplo, um modelo tem como alvo uma audiência do 8º ano, enquanto o outro assume um estudante do ensino médio. Mas os três modelos geraram respostas que poderiam convencer um usuário desinformado de que o evento era real. + +Técnicas de engenharia de prompt como _metaprompting_ e _configuração de temperatura_ podem reduzir as alucinações do modelo em certa medida. Novas _arquiteturas_ de engenharia de prompt também incorporam novas ferramentas e técnicas de maneira contínua no fluxo do prompt, para mitigar ou reduzir alguns desses efeitos. + +## Estudo de Caso: GitHub Copilot + +Vamos concluir esta seção entendendo como a engenharia de prompt é utilizada em soluções do mundo real ao analisar um Estudo de Caso: [GitHub Copilot](https://github.com/features/copilot?WT.mc_id=academic-105485-koreyst). + +O GitHub Copilot é seu "Programador de Par IA" - ele converte prompts de texto em conclusões de código e está integrado ao seu ambiente de desenvolvimento (por exemplo, Visual Studio Code) para uma experiência do usuário sem interrupções. Como documentado na série de blogs abaixo, a versão mais antiga era baseada no modelo OpenAI Codex - com os engenheiros percebendo rapidamente a necessidade de ajustar o modelo e desenvolver técnicas melhores de engenharia de prompt para melhorar a qualidade do código. Em julho, eles [apresentaram um modelo de IA aprimorado que vai além do Codex](https://github.blog/2023-07-28-smarter-more-efficient-coding-github-copilot-goes-beyond-codex-with-improved-ai-model/?WT.mc_id=academic-105485-koreyst) para sugestões ainda mais rápidas. + +Leia as postagens na ordem para seguir a jornada de aprendizado deles. + +- **Maio de 2023** | [GitHub Copilot está Melhorando na Compreensão do Seu Código](https://github.blog/2023-05-17-how-github-copilot-is-getting-better-at-understanding-your-code/?WT.mc_id=academic-105485-koreyst) +- **Maio de 2023** | [Dentro do GitHub: Trabalhando com os LLMs por trás do GitHub Copilot](https://github.blog/2023-05-17-inside-github-working-with-the-llms-behind-github-copilot/?WT.mc_id=academic-105485-koreyst). +- **Junho de 2023** | [Como Escrever Melhores Prompts para o GitHub Copilot](https://github.blog/2023-06-20-how-to-write-better-prompts-for-github-copilot/?WT.mc_id=academic-105485-koreyst). +- **Julho de 2023** | [.. GitHub Copilot vai além do Codex com modelo de IA aprimorado](https://github.blog/2023-07-28-smarter-more-efficient-coding-github-copilot-goes-beyond-codex-with-improved-ai-model/?WT.mc_id=academic-105485-koreyst) +- **Julho de 2023** | [Guia do Desenvolvedor para Engenharia de Prompt e LLMs](https://github.blog/2023-07-17-prompt-engineering-guide-generative-ai-llms/?WT.mc_id=academic-105485-koreyst) +- **Setembro de 2023** | [Como construir um aplicativo empresarial LLM: Lições do GitHub Copilot](https://github.blog/2023-09-06-how-to-build-an-enterprise-llm-application-lessons-from-github-copilot/?WT.mc_id=academic-105485-koreyst) + +Você também pode navegar pelo [blog de Engenharia deles](https://github.blog/category/engineering/?WT.mc_id=academic-105485-koreyst) para mais postagens como [esta](https://github.blog/2023-09-27-how-i-used-github-copilot-chat-to-build-a-reactjs-gallery-prototype/?WT.mc_id=academic-105485-koreyst) que mostra como esses modelos e técnicas são _aplicados_ para impulsionar aplicações do mundo real. + +--- + + + +## Construção de Prompt + +Vimos por que a Engenharia de Prompt é importante - agora vamos entender como os prompts são _construídos_ para que possamos avaliar diferentes técnicas para um design de prompt mais eficaz. + +### Prompt Básico + +Vamos começar com o prompt básico: uma entrada de texto enviada ao modelo sem nenhum outro contexto. Aqui está um exemplo - quando enviamos as primeiras palavras do hino nacional dos EUA para a [API de Completions da OpenAI](https://platform.openai.com/docs/api-reference/completions?WT.mc_id=academic-105485-koreyst), ela instantaneamente _completa_ a resposta com as próximas linhas, ilustrando o comportamento básico de previsão. + +| Prompt (Input) | Completion (Output) | +|:---|:---| +| Oh say can you see | It sounds like you're starting the lyrics to "The Star-Spangled Banner," the national anthem of the United States. The full lyrics are ... | + +### Prompt Complexo + +Agora, vamos adicionar contexto e instruções a esse prompt básico. A [API de Completions de Chat](https://learn.microsoft.com/azure/ai-services/openai/how-to/chatgpt?WT.mc_id=academic-105485-koreyst) nos permite construir um prompt complexo como uma coleção de _mensagens_ com: + +- Pares de entrada/saída refletindo a entrada do _usuário_ e a resposta do _assistente_. +- Mensagem do sistema definindo o contexto para o comportamento ou personalidade do assistente. + +A solicitação agora está na forma abaixo, onde a _tokenização_ captura efetivamente informações relevantes do contexto e da conversa. Agora, alterar o contexto do sistema pode ter um impacto significativo na qualidade dos completamentos, assim como as entradas do usuário fornecidas. + +```python +response = openai.ChatCompletion.create( + model="gpt-3.5-turbo", + messages=[ + {"role": "system", "content": "Você é um assistente prestativo."}, + {"role": "user", "content": "Quem ganhou a série mundial em 2020?"}, + {"role": "assistant", "content": "O Los Angeles Dodgers venceu a Série Mundial em 2020."}, + {"role": "user", "content": "Onde foi jogado?"} + ] +) +``` + +### Prompt de Instrução + +Nos exemplos acima, o prompt do usuário era uma simples consulta de texto que pode ser interpretada como uma solicitação de informações. Com prompts de _instrução_, podemos usar esse texto para especificar uma tarefa de maneira mais detalhada, fornecendo orientações melhores para a IA. Aqui está um exemplo: + +| Prompt (Input) | Completion (Output) | Instruction Type | +|:---|:---|:---| +| Write a description of the Civil War | _returned a simple paragraph_ | Simple| +|Write a description of the Civil War. Provide key dates and events and describe their significance | _returned a paragraph followed by a list of key event dates with descriptions_| Complex | +|Write a description of the Civil War in 1 paragraph. Provide 3 bullet points with key dates and their significance. Provide 3 more bullet points with key historical figures and their contributions. Return the output as a JSON file | _returns more extensive details in a text box, formatted as JSON that you can copy-paste to a file and validate as needed_| Complex. Formatted. | + +## Conteúdo Primário + +Nos exemplos acima, o prompt ainda era bastante aberto, permitindo que o LLM decidisse qual parte de seu conjunto de dados pré-treinado era relevante. Com o padrão de design de _conteúdo primário_, o texto de entrada é dividido em duas partes: + +- uma instrução (ação) +- conteúdo relevante (que influencia a ação) + +Aqui está um exemplo em que a instrução é: "resuma isso em 2 frases". + + +| Prompt (Input) | Completion (Output) | +|:---|:---| +| Jupiter is the fifth planet from the Sun and the largest in the Solar System. It is a gas giant with a mass one-thousandth that of the Sun, but two-and-a-half times that of all the other planets in the Solar System combined. Jupiter is one of the brightest objects visible to the naked eye in the night sky, and has been known to ancient civilizations since before recorded history. It is named after the Roman god Jupiter.[19] When viewed from Earth, Jupiter can be bright enough for its reflected light to cast visible shadows,[20] and is on average the third-brightest natural object in the night sky after the Moon and Venus.
**Summarize this in 2 short sentences** | Jupiter, the fifth planet from the Sun, is the largest in the Solar System and is known for being one of the brightest objects in the night sky. Named after the Roman god Jupiter, it's a gas giant whose mass is two-and-a-half times that of all other planets in the Solar System combined. | + +O segmento de conteúdo primário pode ser usado de várias maneiras para impulsionar instruções mais eficazes: + +- **Exemplos** - em vez de dizer explicitamente ao modelo o que fazer com uma instrução explícita, dê a ele exemplos do que fazer e deixe-o inferir o padrão. +- **Dicas** - siga a instrução com uma "dica" que prepara o completamento, orientando o modelo para respostas mais relevantes. +- **Modelos** - são 'receitas' repetíveis de prompts com espaços reservados (variáveis) que podem ser personalizados com dados para casos de uso específicos. + +Vamos explorar esses conceitos na prática. + +### Usando Exemplos + +Esta é uma abordagem em que você usa o conteúdo primário para "alimentar o modelo" com alguns exemplos da saída desejada para uma determinada instrução e permite que ele infera o padrão para a saída desejada. Com base no número de exemplos fornecidos, podemos ter prompting de `zero-shot`, `one-shot`, `few-shot`, etc. + +O prompt agora consiste em três componentes: + +- Uma descrição da tarefa +- Alguns exemplos da saída desejada +- O início de um novo exemplo (que se torna uma descrição implícita da tarefa) + + + | Learning Type | Prompt (Input) | Completion (Output) | + |:---|:---|:---| + | Zero-shot | "The Sun is Shining". Translate to Spanish | "El Sol está brillando".| + | One-shot | "The Sun is Shining" => ""El Sol está brillando".
"It's a Cold and Windy Day" => | "Es un día frío y ventoso". | + | Few-shot | The player ran the bases => Baseball
The player hit an ace => Tennis
The player hit a six => Cricket
The player made a slam-dunk => | Basketball | + | | | | + + +Observe como tivemos que fornecer instruções explícitas ("Traduza para o espanhol") no prompting de `zero-shot`, mas isso é inferido no exemplo de `one-shot`. O exemplo `few-shot` mostra como adicionar mais exemplos permite que os modelos façam inferências mais precisas sem instruções adicionais. + +### Dicas de Prompt + +Outra técnica para usar conteúdo primário é fornecer _dicas_ em vez de exemplos. Neste caso, estamos dando ao modelo um empurrão na direção certa ao _iniciá-lo_ com um trecho que reflete o formato da resposta desejada. O modelo então "pega a dica" para continuar nessa linha. + + +| Number of Cues | Prompt (Input) | Completion (Output) | +|:---|:---|:---| +| 0 | Jupiter is the fifth planet from the Sun and the largest in the Solar System. It is a gas giant with a mass one-thousandth that of the Sun, but two-and-a-half times that of all the other planets in the Solar System combined. Jupiter is one of the brightest objects visible to the naked eye in the night sky, and has been known to ancient civilizations since before recorded history.
**Summarize This** | Jupiter is the largest planet in our Solar System and the fifth one from the Sun. It is a gas giant with a mass 1/1000th of the Sun's, but it is heavier than all the other planets combined. Ancient civilizations have known about Jupiter for a long time, and it is easily visible in the night sky..| +| 1 | Jupiter is the fifth planet from the Sun and the largest in the Solar System. It is a gas giant with a mass one-thousandth that of the Sun, but two-and-a-half times that of all the other planets in the Solar System combined. Jupiter is one of the brightest objects visible to the naked eye in the night sky, and has been known to ancient civilizations since before recorded history.
**Summarize This**
What we learned is that Jupiter | is the fifth planet from the Sun and the largest in the Solar System. It is a gas giant with a mass one-thousandth that of the Sun, but two-and-a-half times that of all the other planets combined. It is easily visible to the naked eye and has been known since ancient times. | +| 2 | Jupiter is the fifth planet from the Sun and the largest in the Solar System. It is a gas giant with a mass one-thousandth that of the Sun, but two-and-a-half times that of all the other planets in the Solar System combined. Jupiter is one of the brightest objects visible to the naked eye in the night sky, and has been known to ancient civilizations since before recorded history.
**Summarize This**
Top 3 Facts We Learned: | 1. Jupiter is the fifth planet from the Sun and the largest in the Solar System.
2. It is a gas giant with a mass one-thousandth that of the Sun...
3. Jupiter has been visible to the naked eye since ancient times ... | +| | | | + +Observe como tivemos que fornecer uma instrução explícita ("Resuma Isso") no exemplo de zero dicas, mas isso é inferido no exemplo de uma dica. O exemplo de duas dicas mostra como adicionar mais dicas permite que os modelos façam inferências mais precisas sem instruções adicionais. + +### Modelos de Prompt + +Um modelo de prompt é uma _receita pré-definida para um prompt_ que pode ser armazenada e reutilizada conforme necessário, para proporcionar experiências do usuário mais consistentes em escala. Em sua forma mais simples, é apenas uma coleção de exemplos de prompt como [este da OpenAI](https://platform.openai.com/examples?WT.mc_id=academic-105485-koreyst) que fornece tanto os componentes interativos do prompt (mensagens do usuário e do sistema) quanto o formato de solicitação impulsionado por API - para suportar a reutilização. + +Em sua forma mais complexa, como [este exemplo em LangChain](https://python.langchain.com/docs/modules/model_io/prompts/prompt_templates/?WT.mc_id=academic-105485-koreyst), contém _placeholders_ que podem ser substituídos por dados de diversas fontes (entrada do usuário, contexto do sistema, fontes de dados externas etc.) para gerar um prompt dinamicamente. Isso nos permite criar uma biblioteca de prompts reutilizáveis que podem ser usados para impulsionar experiências do usuário consistentes **programaticamente** em escala. + +Finalmente, o real valor dos modelos está na capacidade de criar e publicar _bibliotecas de prompts_ para domínios de aplicação verticais - onde o modelo de prompt é agora _otimizado_ para refletir o contexto ou exemplos específicos do domínio da aplicação que tornam as respostas mais relevantes e precisas para o público-alvo. + +A [Prompts For Edu](https://github.com/microsoft/prompts-for-edu?WT.mc_id=academic-105485-koreyst) é um ótimo exemplo dessa abordagem, criando uma biblioteca de prompts para o domínio da educação com ênfase em objetivos-chave como planejamento de aulas, design de currículo, tutoria de estudantes etc. + +## Conteúdo de Suporte + +Se pensarmos na criação do prompt como tendo uma instrução (tarefa) e um alvo (conteúdo principal), então o _conteúdo secundário_ é como um contexto adicional que fornecemos para **influenciar a saída de alguma forma**. Pode ser parâmetros de ajuste, instruções de formatação, taxonomias de tópicos etc. que podem ajudar o modelo a _adequar_ sua resposta para atender aos objetivos ou expectativas desejados do usuário. + +Por exemplo: Dado um catálogo de cursos com metadados extensivos (nome, descrição, nível, tags de metadados, instrutor etc.) de todos os cursos disponíveis no currículo: + +- podemos definir uma instrução para "resumir o catálogo de cursos para o outono de 2023" +- podemos usar o conteúdo principal para fornecer alguns exemplos da saída desejada +- podemos usar o conteúdo secundário para identificar as 5 principais "tags" de interesse. + +Agora, o modelo pode fornecer um resumo no formato mostrado pelos poucos exemplos - mas se um resultado tiver várias tags, pode priorizar as 5 tags identificadas no conteúdo secundário. + +--- + + + +## Melhores Práticas para Prompts + +Agora que sabemos como os prompts podem ser _construídos_, podemos começar a pensar em como _projetá-los_ para refletir as melhores práticas. Podemos pensar nisso em duas partes - ter a _mentalidade_ certa e aplicar as _técnicas_ certas. + +### Mentalidade de Engenharia de Prompt + +A Engenharia de Prompt é um processo de tentativa e erro, então tenha em mente três fatores amplos: + +1. **Entender o Domínio é Importante.** A precisão e relevância da resposta é uma função do _domínio_ no qual a aplicação ou usuário opera. Aplique sua intuição e experiência de domínio para **personalizar técnicas** ainda mais. Por exemplo, defina _personalidades específicas do domínio_ em seus prompts de sistema, ou use _modelos específicos do domínio_ em seus prompts de usuário. Forneça conteúdo secundário que reflita contextos específicos do domínio, ou use _cues e exemplos específicos do domínio_ para orientar o modelo em direção a padrões de uso familiares. + +2. **Entender o Modelo é Importante.** Sabemos que os modelos são estocásticos por natureza. Mas as implementações do modelo também podem variar em termos do conjunto de dados de treinamento que eles usam (conhecimento pré-treinado), as capacidades que eles fornecem (por exemplo, via API ou SDK) e o tipo de conteúdo para o qual são otimizados (por exemplo, código vs. imagens vs. texto). Compreenda as forças e limitações do modelo que você está usando e use esse conhecimento para _priorizar tarefas_ ou construir _modelos personalizados_ otimizados para as capacidades do modelo. + +3. **Iteração e Validação São Importantes.** Os modelos estão evoluindo rapidamente, e as técnicas de engenharia de prompt também. Como especialista no domínio, você pode ter outros contextos ou critérios _específicos de sua_ aplicação, que podem não se aplicar à comunidade em geral. Use ferramentas e técnicas de engenharia de prompt para "iniciar" a construção do prompt, depois itere e valide os resultados usando sua própria intuição e experiência de domínio. Registre suas percepções e crie uma **base de conhecimento** (por exemplo, bibliotecas de prompts) que pode ser usada como uma nova linha de base por outras pessoas, para iterações mais rápidas no futuro. + +## Melhores Práticas + +Agora, vamos dar uma olhada nas práticas recomendadas comuns pela [Open AI](https://help.openai.com/en/articles/6654000-best-practices-for-prompt-engineering-with-openai-api?WT.mc_id=academic-105485-koreyst) e pelos praticantes da [Azure OpenAI](https://learn.microsoft.com/azure/ai-services/openai/concepts/prompt-engineering#best-practices?WT.mc_id=academic-105485-koreyst). + + +| What | Why | +|:---|:---| +| Evaluate the latest models. | New model generations are likely to have improved features and quality - but may also incur higher costs. Evaluate them for impact, then make migration decisions. | +| Separate instructions & context | Check if your model/provider defines _delimiters_ to distinguish instructions, primary and secondary content more clearly. This can help models assign weights more accurately to tokens. | +|Be specific and clear | Give more details about the desired context, outcome, length, format, style etc. This will improve both the quality and consistency of responses. Capture recipes in reusable templates. | +|Be descriptive, use examples |Models may respond better to a "show and tell" approach. Start with a `zero-shot` approach where you give it an instruction (but no examples) then try `few-shot` as a refinement, providing a few examples of the desired output. Use analogies.| +| Use cues to jumpstart completions | Nudge it towards a desired outcome by giving it some leading words or phrases that it can use as a starting point for the response.| +|Double Down | Sometimes you may need to repeat yourself to the model. Give instructions before and after your primary content, use an instruction and a cue, etc. Iterate & validate to see what works.| +| Order Matters | The order in which you present information to the model may impact the output, even in the learning examples, thanks to recency bias. Try different options to see what works best.| +|Give the model an “out” | Give the model a _fallback_ completion response it can provide if it cannot complete the task for any reason. This can reduce chances of models generating false or hallucinatory responses. | +| | | + +Como em qualquer prática recomendada, lembre-se de que _seus resultados podem variar_ com base no modelo, na tarefa e no domínio. Use essas práticas como ponto de partida e itere para encontrar o que funciona melhor para você. Reavalie constantemente seu processo de engenharia de prompt à medida que novos modelos e ferramentas se tornam disponíveis, com foco na escalabilidade do processo e na qualidade das respostas. + + + +## Tarefa + +Parabéns! Você chegou ao final da lição! É hora de colocar alguns desses conceitos e técnicas à prova com exemplos reais! + +Para a nossa tarefa, usaremos um Jupyter Notebook com exercícios que você pode completar interativamente. Você também pode estender o Notebook com suas próprias células de Markdown e código para explorar ideias e técnicas por conta própria. + +### Para começar, faça um fork do repositório, depois + +- (Recomendado) Inicie o GitHub Codespaces +- (Opcional) Clone o repositório em seu dispositivo local e use-o com o Docker Desktop +- (Opcional) Abra o Notebook com seu ambiente de execução de notebook preferido. + +### Em seguida, configure suas variáveis de ambiente + +- Copie o arquivo `.env.copy` na raiz do repositório para `.env` e preencha o valor `OPENAI_API_KEY`. Você pode encontrar sua chave de API em seu [OpenAI Dashboard](https://beta.openai.com/account/api-keys?WT.mc_id=academic-105485-koreyst). + +### Em seguida, abra o Jupyter Notebook + +- Selecione o kernel de execução. Se estiver usando as opções 1 ou 2, basta selecionar o kernel Python 3.10.x padrão fornecido pelo contêiner de desenvolvimento. + +Você está pronto para executar os exercícios. Lembre-se de que não há respostas _certas ou erradas_ aqui - apenas explorando opções por tentativa e erro e construindo intuição sobre o que funciona para um determinado modelo e domínio de aplicação. + +_Por esse motivo, não há segmentos de Solução de Código nesta lição. Em vez disso, o Notebook terá células de Markdown intituladas "Minha Solução:" que mostram um exemplo de saída para referência._ + + + +## Verificação de Conhecimento + +Qual das seguintes opções seria uma boa instrução seguindo as melhores práticas razoáveis? + +1. Mostre-me uma imagem de um carro vermelho. +2. Mostre-me uma imagem de um carro vermelho da marca Volvo e modelo XC90 estacionado à beira de um penhasco com o sol se pondo. +3. Mostre-me uma imagem de um carro vermelho da marca Volvo e modelo XC90. + +**Resposta:** 2, é a melhor instrução, pois fornece detalhes sobre "o que" e vai para especificidades (não apenas qualquer carro, mas uma marca e modelo específicos) e também descreve o ambiente geral. A opção 3 é a próxima melhor, pois também contém muita descrição. + +## 🚀 Desafio + +Veja se você consegue aproveitar a técnica de "dica" com a instrução: Complete a frase "Mostre-me uma imagem de um carro vermelho da marca Volvo e ". O que ela responde e como você melhoraria? + +## Ótimo Trabalho! Continue Sua Aprendizagem + +Quer aprender mais sobre diferentes conceitos de Engenharia de Instruções? Vá para a [página de aprendizado contínuo](../../../13-continued-learning/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) para encontrar outros ótimos recursos sobre este tema. + +Agora, vamos para a Lição 5, onde exploraremos [técnicas avançadas de instrução](../../../05-advanced-prompts/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst)! diff --git a/05-advanced-prompts/README.md b/05-advanced-prompts/README.md index 29c448218..2d6891b6a 100644 --- a/05-advanced-prompts/README.md +++ b/05-advanced-prompts/README.md @@ -61,7 +61,7 @@ There are some basic techniques that we can use to prompt an LLM. Let's explore - **Few shot prompting**, this is the most basic form of prompting. It's a single prompt with a few examples. - **Chain-of-thought**, this type of prompting tells the LLM how to break down a problem into steps. - **Generated knowledge**, to improve the response of a prompt, you can provide generated facts or knowledge additionally to your prompt. -- **Least to most**, like chain-of-though, 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**, 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. - **Self-refine**, this technique is about critiquing the LLM's output and then asking it to improve. - **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. diff --git a/05-advanced-prompts/translations/pt-br/README.md b/05-advanced-prompts/translations/pt-br/README.md new file mode 100644 index 000000000..711d574ab --- /dev/null +++ b/05-advanced-prompts/translations/pt-br/README.md @@ -0,0 +1,664 @@ +# Criando prompts avançados + +[![Creating Advanced Prompts](../../images/05-lesson-banner.png?WT.mc_id=academic-105485-koreyst)](https://youtu.be/32GBH6BTWZQ?WT.mc_id=academic-105485-koreyst) + +Vamos recapitular algumas aprendizagens do capítulo anterior: + +> A _engenharia_ de prompts é o processo pelo qual **guiamos o modelo em direção a respostas mais relevantes** fornecendo instruções ou contexto mais úteis. + +Também existem duas etapas para escrever prompts: a construção do prompt, fornecendo contexto relevante, e a segunda parte é a _otimização_, como melhorar gradualmente o prompt. + +Neste ponto, temos uma compreensão básica de como escrever prompts, mas precisamos aprofundar. Neste capítulo, você passará de experimentar vários prompts para entender por que um prompt é melhor que outro. + +## Introdução + +Neste capítulo, abordaremos os seguintes tópicos: + +- Amplie seu conhecimento de engenharia de prompts aplicando diferentes técnicas aos seus prompts. +- Configure seus prompts para variar a saída. + +## Metas de aprendizado + +Após concluir esta lição, você será capaz de: + +- Aplicar técnicas de engenharia de prompts que melhorem o resultado dos seus prompts. +- Realizar prompts que sejam variados ou determinísticos. + +## Engenharia de prompts + +A engenharia de prompts é o processo de criar prompts que produzirão o resultado desejado. Há mais na engenharia de prompts do que simplesmente escrever um prompt de texto. A engenharia de prompts não é uma disciplina de engenharia; é mais um conjunto de técnicas que você pode aplicar para obter o resultado desejado. + +### Um exemplo de prompt + +Vamos pegar um prompt básico como este: + +> Generate 10 questions on geography. + +Neste prompt, você está aplicando na verdade um conjunto de diferentes técnicas de prompt. + +Vamos analisar isso. + +- **Contexto**, você especifica que deve ser sobre "geografia". +- **Limitação da saída**, você não quer mais do que 10 perguntas. + +### Limitações de prompts simples + +Você pode ou não obter o resultado desejado. Você terá suas perguntas geradas, mas a geografia é um tópico amplo e você pode não obter o que deseja devido às seguintes razões: + +- **Tópico amplo**, você não sabe se será sobre países, capitais, rios e assim por diante. +- **Formato**, e se você quisesse que as perguntas fossem formatadas de uma maneira específica? + +Como você pode ver, há muito a considerar ao criar prompts. + +Até agora, vimos um exemplo simples de prompt, mas a IA generativa é capaz de muito mais para ajudar pessoas em várias funções e indústrias. Vamos explorar algumas técnicas básicas a seguir. + +### Técnicas de prompting + +Primeiro, precisamos entender que o prompting é uma propriedade _emergente_ de um LLM, o que significa que não é uma característica incorporada ao modelo, mas sim algo que descobrimos conforme usamos o modelo. + +Existem algumas técnicas básicas que podemos usar para fazer um prompt em um LLM. Vamos explorá-las. + +- **Prompt de poucas tentativas**, esta é a forma mais básica de prompt. É um prompt único com alguns exemplos. +- **Corrente de pensamento**, este tipo de prompt diz ao LLM como dividir um problema em etapas. +- **Conhecimento gerado**, para melhorar a resposta de um prompt, você pode fornecer fatos ou conhecimentos gerados adicionalmente ao seu prompt. +- **Do menos para o mais**, assim como a corrente de pensamento, esta técnica consiste em dividir um problema em uma série de etapas e depois pedir que essas etapas sejam realizadas em ordem. +- **Auto-aperfeiçoamento**, esta técnica consiste em criticar a saída do LLM e depois pedir que ele melhore. +- **Prompt maieutico**. O que você deseja aqui é garantir que a resposta do LLM esteja correta e pedir que ele explique várias partes da resposta. Isso é uma forma de auto-aperfeiçoamento. + +### Prompt de Poucas Tentativas + +Este estilo de prompt é muito simples, pode consistir em um único prompt e possivelmente alguns exemplos. Essa técnica é provavelmente o que você está usando ao começar a aprender sobre LLMs. Aqui está um exemplo: + +- Prompt: "O que é Álgebra?" +- Resposta: "Álgebra é uma ramificação da matemática que estuda símbolos matemáticos e as regras para manipular esses símbolos." + +### Prompt - Corrente de Pensamento (chain-of-thought prompting) + +O prompt corrente de pensamento é uma técnica muito interessante, pois envolve levar o LLM por uma série de etapas. A ideia é instruir o LLM de tal forma que ele entenda como fazer algo. Considere o seguinte exemplo, com e sem corrente de pensamento: + + - Prompt: "Alice tem 5 maçãs, joga 3 maçãs, dá 2 para Bob e Bob devolve uma, quantas maçãs Alice tem?" + - Resposta: 5 + +O LLM responde com 5, o que está incorreto. A resposta correta é 1 maçã, dada a seguinte operação (5 -3 -2 + 1 = 1). + +Então, como podemos ensinar o LLM a fazer isso corretamente? + +Vamos tentar a corrente de pensamento. Aplicar a corrente de pensamento significa: + +1. Dar ao LLM um exemplo semelhante. +1. Mostrar o cálculo e como calculá-lo corretamente. +1. Fornecer o prompt original. + +Veja como: + +- Prompt: "Lisa tem 7 maçãs, joga 1 maçã, dá 4 maçãs para Bart e Bart devolve uma: + 7 -1 = 6 + 6 -4 = 2 + 2 +1 = 3 + Alice tem 5 maçãs, joga 3 maçãs, dá 2 para Bob e Bob devolve uma, quantas maçãs Alice tem?" + Resposta: 1 + +Note como escrevemos prompts substancialmente mais longos com outro exemplo, um cálculo e, em seguida, o prompt original, e chegamos à resposta correta, que é 1. + +Como você pode ver, a corrente de pensamento é uma técnica muito poderosa. + +### Conhecimento Gerado + +Muitas vezes, ao criar uma solicitação, você deseja fazê-lo usando os dados de sua própria empresa. Você quer que parte da solicitação seja da empresa e a outra parte seja a solicitação real que você está interessado. + +Como exemplo, é assim que sua solicitação pode parecer se você estiver no ramo de seguros: + + ```text + {{company}}: {{company_name}} + {{products}}: + {{products_list}} + Please suggest an insurance given the following budget and requirements: + Budget: {{budget}} + Requirements: {{requirements}} + ``` + +Acima, você vê como a solicitação é construída usando um modelo. No modelo, há várias variáveis, indicadas por `{{variável}}`, que serão substituídas por valores reais de uma API da empresa. + +Aqui está um exemplo de como a solicitação pode parecer depois que as variáveis foram substituídas pelo conteúdo de sua empresa: + + ```text + 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 + ``` + +Executando esta solicitação em um Modelo de Linguagem com Aprendizado Profundo (LLM), o resultado será algo como: + + ```output + , 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 + ``` + +Como você pode ver, também sugere o seguro de vida, o que não deveria acontecer. Este resultado é uma indicação de que precisamos otimizar a solicitação tornando-a mais clara sobre o que é permitido. Após alguma _tentativa e erro_, chegamos à seguinte solicitação: + + ```text + 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 + ``` + +Observe como adicionar _tipo_ e _custo_ e também usar a palavra-chave _restringir_ ajuda o LLM a entender o que queremos. + +Agora obtemos a seguinte resposta: + + ```output + Given the budget and requirements, we suggest the Car, Cheap insurance product which costs 500 USD per month. + ``` + +O objetivo deste exemplo foi mostrar que, mesmo que estejamos usando uma técnica básica como _conhecimento gerado_, ainda precisamos otimizar o prompt na maioria dos casos para obter o resultado desejado. + +### Least-to-most + +The idea with Least-to-most prompting is to break down a bigger problem into subproblems. That way, you help guide the LLM on how to "conquer" the bigger problem. A good example could be for data science where you can ask the LLM to divide up a problem like so: + +> Prompt: How to perform data science in 5 steps? + +With your AI assistant answering with: + +1. Collect data +1. Clean data +1. Analyze data +1. Plot data +1. Present data + +### Self-refine, critique the results + +With generative AIs and LLMs, you can't trust the output. You need to verify it. After all, the LLM is just presenting you what's the next most likely thing to say, not what's correct. Therefore, a good idea is to ask the LLM to critique itself, which leads us to the self-refine technique. + +How it works is that you follow the following steps: + +1. Initial prompt asking the LLM to solve a problem +1. LLM answers +1. You critique the answer and ask the AI to improve +1. LLM answers again, this time considering the critique and suggest solutions it came up with + +You can repeat this process as many times as you want. + +Here's an example using this technique: + +### Menos para mais + +A ideia com a técnica do prompt "Menos para mais" é decompor um problema maior em subproblemas. Dessa forma, você ajuda a orientar o LLM sobre como "conquistar" o problema maior. Um bom exemplo pode ser em ciência de dados, onde você pode pedir ao LLM para dividir um problema da seguinte maneira: + +> Prompt: How to perform data science in 5 steps? + +Com seu assistente de IA respondendo: + +1. Coletar dados +1. Limpar dados +1. Analisar dados +1. Plotar dados +1. Apresentar dados + +### Autoaperfeiçoamento, crítica dos resultados + +Com AIs generativas e LLMs, você não pode confiar na saída. É preciso verificá-la. Afinal, o LLM está apenas apresentando o que é mais provável dizer a seguir, não o que está correto. Portanto, uma boa ideia é pedir ao LLM que faça uma autocrítica, o que nos leva à técnica de autoaperfeiçoamento. + +Como funciona é como você segue os seguintes passos: + +1. Prompt inicial pedindo ao LLM para resolver um problema +1. LLM responde +1. Você critica a resposta e pede à IA para melhorar +1. LLM responde novamente, desta vez considerando a crítica e sugerindo soluções que elaborou + +Você pode repetir esse processo quantas vezes quiser. + +Aqui está um exemplo usando essa técnica: + +> Prompt: "Create a Python Web API with routes products and customers" + +Resposta da IA: + + ```python + import flask + app = Flask(__name__) + + @app.route('/products') + def products(): + return 'Products' + + @app.route('/customers') + def customers(): + return 'Customers' + ``` + +> Prompt: suggest 3 improvements of the above code + +Resposta da IA: + + ```text + 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'. + ``` + + ```python + 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() + ``` + +Como você pode ver, a resposta da IA acima está aprimorando o primeiro código sugerido, graças à crítica da primeira resposta. + +### Maieutic prompting + +Maieutic prompting is a technique that is similar to self-refine but it's more about asking the LLM to explain itself. The goal is to reduce inconsistencies in the LLM's output so to ensure it arrives at the correct answer. The workflow to follow is: + +1. Ask the LLM to answer a question +1. For each part of the answer, ask the LLM to explain it more in depth. +1. If there are inconsistencies, discard the parts that are inconsistent. + +Repeat 2 and 3 until you've gone through all the parts and you're satisfied with the answer. + +Here's an example prompt: + +### Prompt de Maiêutico + +O prompt de maiêutico é uma técnica semelhante ao autoaperfeiçoamento, mas trata-se mais de pedir ao LLM para se explicar. O objetivo é reduzir inconsistências na saída do LLM para garantir que ele chegue à resposta correta. O fluxo de trabalho a ser seguido é: + +1. Peça ao LLM para responder a uma pergunta. +1. Para cada parte da resposta, peça ao LLM para explicá-la mais detalhadamente. +1. Se houver inconsistências, descarte as partes inconsistentes. + +Repita os passos 2 e 3 até passar por todas as partes e ficar satisfeito com a resposta. + +Aqui está um exemplo de um prompt: + +> prompt: How can I create a crisis plan to mitigate a pandemic in 5 steps? +LLM answer: + + ```text + 1. Identify the risks + 1. Identify the stakeholders + 1. Identify the resources + 1. Identify the actions + 1. Identify the communication channels + ``` + +São identificadas 5 etapas, mas podemos determinar se isso está correto? Vamos pedir ao LLM para explicar cada etapa: + +> prompt: Explain the first step in more detail, what are the risks in detail with a pandemic? + + ```text + The risks are the following: + + - Loss of life + - Loss of business + - Loss of reputation + - Loss of customers + - Loss of employees + ``` + +Neste ponto, queremos ter certeza de que o LLM está correto, por isso pedimos que explique o primeiro risco com mais detalhes e esperamos que seja consistente com a resposta acima: + +> prompt: In a Pandemic, which is the biggest risk and why? + + ```text + The biggest risk is loss of life because it's the most important thing to protect. + ``` + +> What are the two biggest risks in a pandemic? + + ```text + The two biggest risks are loss of life and loss of business. + ``` + +Neste ponto, o LLM é consistente e menciona "vida" e "negócios" como os dois principais riscos. Podemos agora prosseguir para o próximo passo e sentir confiança razoável. No entanto, não devemos confiar cegamente no LLM; sempre devemos verificar a saída. + +## Varie sua saída + +Os LLMs são, por natureza, não-determinísticos, o que significa que você obterá resultados diferentes cada vez que executar o mesmo prompt. Tente o seguinte prompt, por exemplo: + +> "Generate code for a Python Web API" + + ```text + # 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() + ``` + +Execute o mesmo prompt novamente e você observará que vai gerar uma resposta ligeiramente diferente: + + ```text + #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 '''

Books API

+

A prototype API for retrieving books.

''' + + #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() + ``` + +> Então, a saída diferente é um problema? + +Depende do que você está tentando fazer. Se você deseja uma resposta específica, é um problema. Se você está bem com uma saída variada como "Gerar 3 perguntas sobre geografia", então não é um problema. + +### Usando a temperatura para variar sua saída + +Ok! Então, decidimos que queremos limitar a saída para ser mais previsível, ou seja, mais determinística. Como fazemos isso? + +Temperatura é um valor entre 0 e 1, onde 0 é o mais determinístico e 1 é o mais variado. O valor padrão é 0.7. Vamos ver o que acontece com duas execuções do mesmo prompt com temperatura definida como 0.1: + +> "Generate code for a Python Web API" + + ```python + #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() + + ``` + +Execute o prompt novamente e você verá este resultado: + + ```python + #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() + + ``` + +Há apenas uma pequena diferença entre essas duas saídas. Vamos fazer o contrário desta vez, vamos definir a temperatura para 0.9: + + ```python + # 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() + + ``` + +e a segunda tentativa em 0,9 como valor de temperatura: + + ```python + 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 '''

Welcome to our book API!

''' + + @app.route('/api/v1/resources/books + + ``` + +Como você pode ver, os resultados não poderiam ser mais variados. + +> Observe que, existem mais parâmetros que você pode alterar para variar a saída, como top-k, top-p, penalidade de repetição, penalidade de comprimento e penalidade de diversidade, mas estes estão fora do escopo deste currículo. + +## Boas práticas + +Há muitas práticas que você pode aplicar para tentar obter o que deseja. Você encontrará seu próprio estilo à medida que usar mais e mais prompts. + +Além das técnicas que cobrimos, existem algumas boas práticas a serem consideradas ao solicitar um LLM. + +Aqui estão algumas boas práticas a serem consideradas: + +- **Especifique o contexto**: O contexto é importante. Quanto mais você puder especificar, como domínio, tópico, etc., será muito melhor. +- **Limite a saída**: Se você deseja um número específico de itens ou um comprimento específico, especifique. +- **Especifique tanto o que, quanto e como**: Lembre-se de mencionar tanto o que você deseja quanto como deseja. Por exemplo: _Crie uma API da Web em Python com rotas para produtos e clientes, dividindo-a em 3 arquivos_. +- **Use modelos**: Muitas vezes, você desejará enriquecer suas solicitações com dados da sua empresa. Use modelos para fazer isso. Os modelos podem ter variáveis que você substitui por dados reais. +- **Escreva corretamente**: Os LLMs podem fornecer uma resposta correta. Mas, se você escrever corretamente, obterá uma resposta melhor. + +## Tarefa + +Aqui está o código em Python que mostra como criar uma API simples usando o Flask: + + ```python + 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() + ``` + +Use um assistente de IA como o GitHub Copilot ou o ChatGPT e aplique a técnica de "auto-aperfeiçoamento" para melhorar o código. + +## Solução + +Por favor, tente resolver a tarefa adicionando prompts adequados ao código. + +> [!DICA] +> Formule um prompt para pedir que ele melhor. É uma boa ideia limitar quantas melhorias devem ter. Você também pode pedir para melhorar de uma certa maneira, por exemplo, arquitetura, desempenho, segurança, etc. + +[Solution](../../solution.py?WT.mc_id=academic-105485-koreyst) + +## Verificação de conhecimento + +Por que eu usaria a técnica de prompt de corrente de pensamento? Mostre-me 1 resposta correta e 2 respostas incorretas. + +Para ensinar o LLM a resolver um problema. +B, Para ensinar o LLM a encontrar erros no código. +C, Para instruir o LLM a propor diferentes soluções. + +Resposta correta: A, 1, porque o prompt de corrente de pensamento trata de mostrar ao LLM como resolver um problema, fornecendo uma série de passos e problemas semelhantes e como foram resolvidos. + +## 🚀 Desafio + +Você acabou de usar a técnica de auto-aperfeiçoamento na atribuição. Pegue qualquer programa que você criou e considere quais melhorias você gostaria de aplicar a ele. Agora, use a técnica de auto-aperfeiçoamento para aplicar as alterações propostas. O que você achou do resultado, melhor ou pior? + +## Ótimo trabalho! Continue seu aprendizado + +Após concluir esta lição, confira nossa [coleção de aprendizado de IA generativa](https://aka.ms/genai-collection?WT.mc_id=academic-105485-koreyst) para continuar a aprimorar seus conhecimentos sobre IA generativa! + +Agora, vamos para a Lição 6, onde aplicaremos nosso conhecimento de Engenharia de Prompt, [construindo aplicativos de geração de texto](../../../06-text-generation-apps/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) \ No newline at end of file diff --git a/06-text-generation-apps/app-recipe.py b/06-text-generation-apps/app-recipe.py index 9db5ab958..5eb8cef9f 100644 --- a/06-text-generation-apps/app-recipe.py +++ b/06-text-generation-apps/app-recipe.py @@ -23,8 +23,10 @@ # 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 {filter}: " + completion = client.completions.create(model=deployment, prompt=prompt, max_tokens=600, temperature = 0.1) + # print response print("Recipes:") print(completion.choices[0].text) diff --git a/06-text-generation-apps/translations/pt-br/README.md b/06-text-generation-apps/translations/pt-br/README.md new file mode 100644 index 000000000..2049e3a9a --- /dev/null +++ b/06-text-generation-apps/translations/pt-br/README.md @@ -0,0 +1,668 @@ +# Desenvolvendo Aplicativos de Geração de Texto + +[![Building Text Generation Applications](../../images/06-lesson-banner.png?WT.mc_id=academic-105485-koreyst)](https://youtu.be/5jKHzY6-4s8?WT.mc_id=academic-105485-koreyst) + +> *(Clique na imagem acima para assistir ao vídeo desta lição)* + +Você viu até agora neste currículo que existem conceitos básicos como prompts e até mesmo uma disciplina inteira chamada "engenharia de prompts". Muitas ferramentas com as quais você pode interagir, como ChatGPT, Office 365, Microsoft Power Platform e muito mais, suportam o uso de prompts para realizar algo. + +Para que você adicione tal experiência a um aplicação, você precisa entender conceitos como prompts, conclusões e escolher uma biblioteca para trabalhar. É exatamente isso que você aprenderá neste capítulo. + +## Introdução + +Nesse capítulo, você aprenderá: + +- Aprender sobre a biblioteca openai e seus conceitos básicos. +- Criar uma aplicação de geração de texto usando openai. +- Entender como usar conceitos como prompt, temperatura e tokens para construir um aplicativo de geração de texto. + +## Objetivos de aprendizagem + +No final desta lição, você será capaz de: + +- Explicar o que é uma aplicação de geração de texto. +- Criar uma aplicação de geração de texto usando openai. +- Configurar sua aplicação para usar mais ou menos tokens e também alterar a temperatura, para uma saída variada. + +## O que é uma aplicação de geração de texto? + +Normalmente quando você desenvolve uma aplicaçaõ, ele tem algum tipo de interface como a seguinte: + +- Baseado em comando. Aplicações de console são aplicativos típicos onde você digita um comando e ele executa uma tarefa. Por exemplo, `git` é um aplicativo baseado em comando. +- Interface do usuário (UI). Alguns aplicativos têm interfaces gráficas do usuário (GUIs) onde você clica em botões, insere texto, seleciona opções e muito mais. + +### Console e Aplições de UI são limitadas + +Compare com um aplicativo baseado em comandos onde você digita um comando: + +- **É limitado**: Você não pode simplesmente digitar qualquer comando, apenas aqueles que o aplicativo suporta. +- **Específico de idioma**: Alguns aplicativos suportam vários idiomas, mas por padrão, o aplicativo é construído para um idioma específico, mesmo que você possa adicionar mais suporte a idiomas. + +### Benefícios de aplicativos de geração de texto + +Então, como uma aplicativo de geração de texto é diferente? + +Em um aplicativo de geração de texto, você tem mais flexibilidade, não está limitado a um conjunto de comandos ou a um idioma específico de entrada. Em vez disso, você pode usar linguagem natural para interagir com o aplicativo. Outro benefício é que, como você já está interagindo com uma fonte de dados que foi treinada em um vasto corpus de informações, ao contrário de um aplicativo tradicional que pode ser limitado ao que está em um banco de dados. + +### O que posso criar com um aplicativo de geração de texto? + +Existem muitas coisas que você pode construir. Por exemplo: + +- **Um chatbot**: Um chatbot que responde a perguntas sobre tópicos, como sua empresa e seus produtos, pode ser uma boa opção. +- **Assistente**: Modelos de linguagem são ótimos para coisas como resumir texto, obter insights a partir de texto, produzir texto como currículos e mais. +- **Assistente de código**: Dependendo do modelo de linguagem que você usa, é possível construir um assistente de código que o ajuda a escrever código. Por exemplo, você pode usar um produto como o GitHub Copilot, bem como o ChatGPT, para ajudá-lo a escrever código. + +## Como posso começar? + +Bem, você precisa encontrar uma maneira de integrar um modelo de linguagem grande (LLM), o que geralmente envolve as seguintes duas abordagens: + +- **Usar uma API**: Aqui, você está construindo solicitações web com seu prompt e obtendo texto gerado de volta. +- **Usar uma biblioteca**: As bibliotecas ajudam a encapsular as chamadas de API e facilitam o uso delas. + +## Bibliotecas/SDKs + +Existem algumas bibliotecas bem conhecidas para trabalhar com Grandes Modelos de Linguagem (LLMs), como: + +- **openai**: Esta biblioteca facilita a conexão com seu modelo e o envio de prompts. + +Em seguida, existem bibliotecas que operam em um nível mais alto, como: + +- **Langchain**: Langchain é bem conhecida e oferece suporte ao Python. +- **Semantic Kernel**: Semantic Kernel é uma biblioteca da Microsoft que oferece suporte às linguagens C#, Python e Java. + +## Primeiro aplicativo usando openai + +Vamos ver como podemos criar nosso primeiro aplicativo, quais bibliotecas precisamos, quanto é necessário e etc. + +### Instalando o openai + +Existem muitas bibliotecas por aí para interagir com o OpenAI ou o Azure OpenAI. É possível usar várias linguagens de programação, como C#, Python, JavaScript, Java e outras. Optamos por usar a biblioteca `openai` em Python, então vamos usar o `pip` para instalá-la. + +```bash +pip install openai +``` + +### Criando o Recurso + +Você precisa realizar as seguintes etapas: + +- Criar uma conta no Azure [https://azure.microsoft.com/free/](https://azure.microsoft.com/free/?WT.mc_id=academic-105485-koreyst). +- Obter acesso ao Azure Open AI. Vá para [https://learn.microsoft.com/azure/ai-services/openai/overview#how-do-i-get-access-to-azure-openai](https://learn.microsoft.com/azure/ai-services/openai/overview#how-do-i-get-access-to-azure-openai?WT.mc_id=academic-105485-koreyst) e solicite acesso. + + > [!OBSERVAÇÃO] + > Até o presente momento, você precisa solicitar acesso ao Azure Open AI. + +- Instale Python +- Ter criado um recurso de serviço Azure OpenAI. Consulte este guia para saber como [criar um recurso](https://learn.microsoft.com/azure/ai-services/openai/how-to/create-resource?pivots=web-portal?WT.mc_id=academic-105485-koreyst). + +### Localize a chave da API e o endpoint + +Neste ponto, você precisa informar à biblioteca `openai` qual chave de API usar. Para encontrar sua chave de API, vá para a seção "Chaves e Endpoint" de seu recurso Azure Open AI e copie o valor de "Chave 1". + +![Keys and Endpoint resource blade in Azure Portal](https://learn.microsoft.com/azure/ai-services/openai/media/quickstarts/endpoint.png?WT.mc_id=academic-105485-koreyst) + +Agora que você tem essas informações copiadas, vamos instruir as bibliotecas a usá-las. + +> [!OBSERVAÇÃO] +> Vale a pena separar sua chave API do seu código. Você pode fazer isso usando variáveis de ambiente. +> +> - Defina a variável de ambiente em: `OPENAI_API_TYPE` para a chave da sua API. +> `export OPENAI_API_KEY='sk-...'` + +### Configurando o recurso do Azure no código + +If you're using Azure Open AI, here's how you setup configuration: + +Se você estiver usando o Azure Open AI, veja como configurar: + +```python +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") +``` + +Aqui estamos definindo o seguinte: + +- `api_type` para `azure`. Isso diz à biblioteca para usar o Azure Open AI e não o OpenAI. +- `api_key`, esta é a sua chave API encontrada no Portal do Azure. +- `api_version`, esta é a versão da API que você deseja usar. No momento da escrita, a versão mais recente é `2023-05-15`. +- `api_base`, este é o endpoint da API. Você pode encontrá-lo no Portal do Azure ao lado de sua chave API. + +> [!OBSERVAÇÃO] +> `os.getenv` é uma função que lê variáveis de ambiente. Você pode usá-lo para ler variáveis de ambiente como `OPENAI_API_KEY` e `API_BASE`. Defina essas variáveis de ambiente em seu terminal ou usando uma biblioteca como `dotenv`. + +## Gerando texto + +Uma maneira de gerar texto é usar a classe `Completion`. Aqui está um exemplo: + +```python +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) +``` + +No código acima, criamos um `completion object` e passamos o modelo que queremos usar e o prompt. Em seguida, imprimimos o texto gerado. + +### Chat completions + +Até agora, você viu como usamos `Completion` para gerar texto. Mas há outra classe chamada `ChatCompletion` que é mais adequada para chatbots. Aqui está um exemplo de uso: + +```python +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) +``` + +Aprenderemos mais sobre essa funcionalidade em um capítulo futuro. + +## Exercício - seu primeiro aplicativo de geração de texto + +Agora que aprendemos a configurar o openai, é hora de criar o seu primeiro aplicativo de geração de texto. Para criar seu aplicativo, siga estas etapas: + +1. Crie um ambiente virtual e instale o openai: + + ```bash + python -m venv venv + source venv/bin/activate + pip install openai + ``` + + > [!OBSERVAÇÃO] + > Se você estiver usando o Windows, digite `venv\Scripts\activate` em vez de `source venv/bin/activate`. + + > [!OBSERVAÇÃO] + > Localize sua chave Azure Open AI acessando [https://portal.azure.com/](https://portal.azure.com/?WT.mc_id=academic-105485-koreyst) e pesquise por `Open AI` e selecione o `recurso Open AI` e depois selecione `Chaves e Endpoint` e copie o valor `Chave 1`. + +1. Crie um arquivo *app.py* e dê a ele o seguinte código: + + ```python + import openai + + openai.api_key = "" + + openai.api_type = 'azure' + openai.api_version = '2023-05-15' + openai.api_base = "" + deployment_name = "" + + # add your completion code + prompt = "Complete the following: Once upon a time there was a" + + # make completion + completion = openai.Completion.create(engine= deployment_name, model="davinci-002", prompt=prompt) + + # print response + print(completion.choices[0].text) + ``` + + > [!OBSERVAÇÃO] + > Se você estiver usando o Azure Open AI, precisará definir o `api_type` como `azure` e definir o `api_key` como sua chave Azure Open AI. + + Você deve ver uma saída como a seguinte: + + ```output + very unhappy _____. + + Once upon a time there was a very unhappy mermaid. + ``` + +## Diferentes tipos de prompts, para diferentes coisas + +Agora que você viu como gerar texto usando um prompt, você até tem um programa em execução que pode modificar e alterar para gerar diferentes tipos de texto. + +Prompts podem ser usados para todas as formas de tarefas. Por exemplo: + +- **Gerar um tipo de texto**: Por exemplo, você pode gerar um poema, perguntas para um quiz, etc. +- **Procurar informações**: Você pode usar prompts para procurar informações, como no exemplo a seguir: 'O que significa CORS no desenvolvimento web?'. +- **Gerar código**: Você pode usar prompts para gerar código, por exemplo, desenvolvendo uma expressão regular usada para validar e-mails ou até mesmo gerar um programa inteiro, como um aplicativo web? + +## Um caso de uso mais prático: um gerador de receitas + +Imagine que você tenha ingredientes em casa e quer cozinhar algo. Para isso, você precisa de uma receita. Uma maneira de encontrar receitas é usar um mecanismo de busca ou você poderia usar um LLM para fazer isso. + +Você poderia escrever um prompt assim: + +> "Me forneça 5 receitas para um prato com os seguintes ingredientes: frango, batatas e cenouras. Por receita, liste todos os ingredientes utilizados" + +Dado o prompt acima, você pode obter uma resposta semelhante a: + +```output +1. Frango Assado com Vegetais: + - Ingredientes: + - 4 coxas de frango + - 2 batatas, cortadas em cubos + - 2 cenouras, cortadas em cubos + - 2 colheres de sopa de azeite de oliva + - 2 dentes de alho, picados + - 1 colher de chá de tomilho seco + - 1 colher de chá de orégano seco + - Sal e pimenta a gosto + +2. Ensopado de Frango e Batata: + - Ingredientes: + - 2 colheres de sopa de azeite de oliva + - 1 cebola, picada + - 2 dentes de alho, picados + - 2 peitos de frango, cortados em cubos + - 2 batatas, cortadas em cubos + - 2 cenouras, cortadas em cubos + - 1 colher de chá de orégano seco + - 1 colher de chá de tomilho seco + - 1 xícara de caldo de galinha + - Sal e pimenta a gosto + +3. Assado de Frango e Batata: + - Ingredientes: + - 2 colheres de sopa de azeite de oliva + - 2 peitos de frango, cortados em cubos + - 2 batatas, cortadas em cubos + - 2 cenouras, cortadas em cubos + - 1 cebola, picada + - 2 dentes de alho, picados + - 1 colher de chá de orégano seco + - 1 colher de chá de tomilho seco + - 1 xícara de caldo de galinha + - Sal e pimenta a gosto + +4. Sopa de Frango e Batata: + - Ingredientes: + - 2 colheres de sopa de azeite de oliva + - 1 cebola, picada + - 2 dentes de alho, picados + - 2 peitos de frango, cortados em cubos + - 2 batatas, cortadas em cubos + - 2 cenouras, cortadas em cubos + - 1 colher de chá de orégano seco + - 1 colher de chá de tomilho seco + - 4 xícaras de caldo de galinha + - Sal e pimenta a gosto + +5. Hash de Frango e Batata: + - Ingredientes: + - 2 colheres de sopa de azeite de oliva + - 2 peitos de frango, cortados em cubos + - 2 batatas, cortadas em cubos + - 2 cenouras, cortadas em cubos + - 1 cebola, picada + - 2 dentes de alho, picados + - 1 colher de chá de orégano + +``` + +Essa saída é ótima, eu sei o quê cozinhar. Neste ponto, o que poderia ser útil são melhorias: + +- Filtre os ingredientes que não gosto ou sou alérgico. +- Me forneça uma lista de compras, caso eu não tenha todos os ingredientes em casa. + +Para os casos acima, vamos adicionar um prompt adicional: + +> "Por favor, remova receitas com alho, pois sou alérgico e substitua por outra coisa. Além disso, por favor, me forneça uma lista de compras para as receitas, considerando que já tenho frango, batatas e cenouras em casa." + +Agora você tem um novo resultado, a saber: + +```output +1. Frango Assado com Vegetais: + - Ingredientes: + - 4 coxas de frango + - 2 batatas, cortadas em cubos + - 2 cenouras, cortadas em cubos + - 2 colheres de sopa de azeite de oliva + - 1 colher de chá de tomilho seco + - 1 colher de chá de orégano seco + - Sal e pimenta a gosto + +2. Ensopado de Frango e Batata: + - Ingredientes: + - 2 colheres de sopa de azeite de oliva + - 1 cebola, picada + - 2 peitos de frango, cortados em cubos + - 2 batatas, cortadas em cubos + - 2 cenouras, cortadas em cubos + - 1 colher de chá de orégano seco + - 1 colher de chá de tomilho seco + - 1 xícara de caldo de galinha + - Sal e pimenta a gosto + +3. Frango e Batata Assados: + - Ingredientes: + - 2 colheres de sopa de azeite de oliva + - 2 peitos de frango, cortados em cubos + - 2 batatas, cortadas em cubos + - 2 cenouras, cortadas em cubos + - 1 cebola, picada + - 1 colher de chá de orégano seco + - 1 colher de chá de tomilho seco + - 1 xícara de caldo de galinha + - Sal e pimenta a gosto + +4. Sopa de Frango e Batata: + - Ingredientes: + - 2 colheres de sopa de azeite de oliva + - 1 cebola, picada + - 2 peitos de frango, cortados em cubos + - 2 batatas, cortadas em cubos + - 2 cenouras, cortadas em cubos + - 1 colher de chá de orégano seco + - 1 colher de chá de tomilho seco + - 4 xícaras de caldo de galinha + - Sal e pimenta a gosto + +5. Hash de Frango e Batata: + - Ingredientes: + - 2 colheres de sopa de azeite de oliva + - 2 peitos de frango, cortados em cubos + - 2 batatas, cortadas em cubos + - 2 cenouras, cortadas em cubos + - 1 cebola, picada + - 1 colher de chá de orégano + +Lista de Compras: +- Azeite de oliva +- Cebola +- Tomilho +- Orégano +- Sal +- Pimenta +``` + +Aqui estão as cinco receitas, sem mencionar alho, e também uma lista de compras considerando o que você já tem em casa. + +## Execírcio - crie um gerador de receitas + +Agora que temos um cenário, vamos escrever o código para corresponder ao cenário demonstrado. Para fazer isso, siga estas etapas: + + +1. Use o arquivo *app.py* existente como ponto de partida +1. Localize a variável `prompt` e altere seu código para o seguinte: + + ```python + prompt = "Me forneça 5 receitas de um prato com os seguintes ingredientes: frango, batata e cenoura. Por receita, liste todos os ingredientes usados" + ``` + + Se você executar o código agora, deverá ver uma saída semelhante a: + + ```output + - Ensopado de Frango com Batata e Cenoura: 3 colheres de sopa de azeite, 1 cebola picada, 2 dentes de alho picados, 1 cenoura descascada e picada, 1 batata descascada e picada, 1 folha de louro, 1 raminho de tomilho, 1/2 colher de chá de sal , 1/4 colher de chá de pimenta preta, 1 1/2 xícara de caldo de galinha, 1/2 xícara de vinho branco seco, 2 colheres de sopa de salsa fresca picada, 2 colheres de sopa de manteiga sem sal, 1 1/2 libra de coxas de frango desossadas e sem pele, cortadas em 1- pedaços de polegada + + - Frango Assado no Forno com Batata e Cenoura: 3 colheres de sopa de azeite extra-virgem, 1 colher de sopa de mostarda Dijon, 1 colher de sopa de alecrim fresco picado, 1 colher de sopa de tomilho fresco picado, 4 dentes de alho picados, 1 1/2 libra de batatas vermelhas pequenas, esquartejado, 1 1/2 libra de cenoura, cortada em quartos longitudinalmente, 1/2 colher de chá de sal, 1/4 colher de chá de pimenta preta, 1 (4 libras) de frango inteiro + + - Caçarola de frango, batata e cenoura: spray de cozinha, 1 cebola grande picada, 2 dentes de alho picados, 1 cenoura descascada e ralada, 1 batata descascada e ralada, 1/2 colher de chá de folhas secas de tomilho, 1/4 colher de chá sal, 1/4 colher de chá de pimenta preta, 2 xícaras de caldo de galinha desnatado e com baixo teor de sódio, 1 xícara de ervilhas congeladas, 1/4 xícara de farinha de trigo, 1 xícara de leite com baixo teor de gordura a 2%, 1/4 xícara de parmesão ralado queijo + + - Jantar de frango e batata em uma panela: 2 colheres de sopa de azeite, 1 quilo de coxas de frango desossadas e sem pele, cortadas em pedaços de 2,5 cm, 1 cebola grande picada, 3 dentes de alho picados, 1 cenoura descascada e picada, 1 batata, descascado e picado, 1 folha de louro, 1 raminho de tomilho, 1/2 colher de chá de sal, 1/4 colher de chá de pimenta preta, 2 xícaras de caldo de galinha, 1/2 xícara de vinho branco seco + + - Caril de Frango, Batata e Cenoura: 1 colher de sopa de óleo vegetal, 1 cebola grande picada, 2 dentes de alho picados, 1 cenoura descascada e picada, 1 batata descascada e picada, 1 colher de chá de coentro moído, 1 colher de chá de cominho moído, 1/2 colher de chá de açafrão em pó, 1/2 colher de chá de gengibre em pó, 1/4 colher de chá de pimenta caiena, 2 xícaras de caldo de galinha, 1/2 xícara de vinho branco seco, 1 lata (15 onças) de grão de bico, escorrido e enxaguado, 1/2 xícara de passas, 1/2 xícara de coentro fresco picado + ``` + + > [!OBSERVAÇÃO] + > seu LLM é não determinístico, então você pode obter resultados diferentes sempre que executar o programa. + + Ótimo! Vamos ver como podemos melhorar as coisas. Para melhorar as coisas, queremos ter certeza de que o código é flexível, para que os ingredientes e o número de receitas possam ser melhorados e alterados. + +1. Vamos alterar o código da seguinte maneira: + + ```python + 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" + ``` + + Execute o código e teste, e vejamos o resultado: + + ```output + 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 + ``` + +### Melhore adicionando filtro e lista de compras + +Agora nós temos um aplicativo funcionando capaz de produzir receitas e é flexível, pois depende de entradas do usuário, tanto no número de receitas quanto nos ingredientes usados. + +Para melhorar ainda mais, queremos adicionar o seguinte: + +- **Filtrar ingredientes**: Queremos ser capazes de filtrar ingredientes que não gostamos ou somos alérgicos. Para realizar essa alteração, podemos editar nosso prompt existente e adicionar uma condição de filtro ao final, assim: + + ```python + 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}" + ``` + + Acima adicionamos `{filter}` ao final do prompt e também capturamos o valor do filtro do usuário. + + Um exemplo de entrada da execução do programa pode ser assim: + + ```output + 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. + ``` + + Como você pode ver, todas as receitas com leite foram filtradas. Mas, se você for intolerante à lactose, talvez queira filtrar também as receitas com queijo, então é preciso ser claro. + +- **Produze uma lista de compras**. Queremos produzir uma lista de compras, considerando o que já temos em casa. + + Para esta funcionalidade, poderíamos tentar resolver tudo em um prompt ou poderíamos dividi-lo em dois prompts. Vamos tentar a última abordagem. Aqui estamos sugerindo adicionar um prompt adicional, mas para que isso funcione, precisamos adicionar o resultado do prompt anterior como contexto para o prompt posterior. + + ```python + old_prompt_result = completion.choices[0].text + 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}" + completion = openai.Completion.create(engine=deployment_name, prompt=new_prompt, max_tokens=1200) + + # print response + print("Shopping list:") + print(completion.choices[0].text) + ``` + + Observe o seguinte: + + 1. Nós estamos criando um novo prompt adicionando o resultado do primeiro prompt ao novo prompt: + + ```python + new_prompt = f"{old_prompt_result} {prompt}" + ``` + + 1. Nós fizemos uma nova requisição, mas também considerando o número de tokens que solicitamos no primeiro prompt, então desta vez dizemos que `max_tokens` é 1200. + + ```python + completion = openai.Completion.create(engine=deployment_name, prompt=new_prompt, max_tokens=1200) + ``` + + Dando uma olhada neste código, chegamos agora à seguinte saída: + + ```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 + ``` + +## Melhorando a nossa configuração + +O que temos até agora é um código que funciona, mas há algumas alterações que devemos fazer para melhorar ainda mais as coisas. Algumas coisas que devemos fazer são: + +- **Separar `secrets` do código**, como a chave da API. Segredos não pertencem ao código e devem ser armazenados em um local seguro. Para separar segredos do código, podemos usar variáveis de ambiente e bibliotecas como `python-dotenv` para carregá-los de um arquivo. Veja como isso ficaria no código: + + 1. Crie um arquivo `.env` com o seguinte conteúdo: + + ```bash + OPENAI_API_KEY=sk-... + ``` + + > Observação: para o Azure, você precisa definir as seguintes variáveis de ambiente: + + ```bash + OPENAI_API_TYPE=azure + OPENAI_API_VERSION=2023-05-15 + OPENAI_API_BASE= + ``` + + No código, você carregaria as variáveis de ambiente assim: + + ```python + from dotenv import load_dotenv + + load_dotenv() + + openai.api_key = os.environ["OPENAI_API_KEY"] + ``` + +- **Uma palavra sobre o comprimento do token**. Devemos considerar quantos tokens precisamos para gerar o texto que queremos. Tokens custam dinheiro, então, sempre que possível, devemos tentar ser econômicos com o número de tokens que usamos. Por exemplo, podemos formular o prompt para que possamos usar menos tokens? + + Para alterar os tokens usados, você pode usar o parâmetro `max_tokens`. Por exemplo, se você quiser usar 100 tokens, você faria: + + ```python + completion = openai.Completion.create(model="davinci-002", prompt=prompt, max_tokens=100) + ``` + +- **Experimentando com a temperatura**. A temperatura é algo que não mencionamos até agora. Porém, é um contexto importante para o desempenho de nosso programa. Quanto maior o valor da temperatura, mais aleatório será o resultado. Por outro lado, quanto menor o valor da temperatura, mais previsível será o resultado. Considere se você deseja ou não variação na saída. + + Para alterar a temperatura, você pode usar o parâmetro `temperature`. Por exemplo, se você quiser usar uma temperatura de 0.5, você faria: + + ```python + completion = openai.Completion.create(model="davinci-002", prompt=prompt, temperature=0.5) + ``` + + > Observação: quanto mais próximo de 1.0, mais variada será a saída. + +## Tarefa + +Para esta tarefa, você pode escolher o que criar para um aplicativo. + +Aqui estão algumas sugestões: + +- Ajuste o aplicativo gerador de receitas para melhorá-lo ainda mais. Brinque com os valores de temperatura e os prompts para ver o que você pode criar. +- Crie um "companheiro de estudos". Este aplicativo deve ser capaz de responder a perguntas sobre um tópico. Por exemplo: Python. Você poderia ter prompts como: "O que é um certo tópico em Python?" ou poderia ter um prompt que diz: "Me mostre o código para um certo tópico", etc. + +- Bot de história, faça a história ganhar vida, instrua o bot a interpretar um certo personagem histórico e faça perguntas sobre sua vida e época. + +## Solução + +### Amigo de Estudo + +Abaixo está um prompt inicial, veja como você pode usá-lo e ajustá-lo ao seu gosto. + +```text +- "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" +``` + +### Bot de História + +Aqui estão alguns prompts que você pode usar: + +```text +- "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" +``` + +## Verificação de Conhecimento + +What does the concept temperature do? + +O que o conceito de temperatura faz? + +1. Ele controla o quão aleatória é a saída. +2. Ele controla o quão grande é a resposta. +3. Ele controla quantos tokens são usados. + +Resposta: 1. Ele controla o quão aleatória é a saída. + +## 🚀 Desafio + +When working on the assignment, try to vary the temperature, try set it to 0, 0.5, and 1. Remember that 0 is the least varied and 1 is the most, what value works best for your app? + +Quando estiver trabalhando na tarefa, tente variar a temperatura, tente definir para 0, 0.5 e 1. Lembre-se de que 0 é o menos variado e 1 é o mais, qual valor funciona melhor para o seu aplicativo? + +## Excelente trabalho! Continue seu aprendizado + +Após concluir esta lição, confira nossa [coleção de aprendizado de IA generativa](https://aka.ms/genai-collection?WT.mc_id=academic-105485-koreyst) para continuar a aprimorar seus conhecimentos sobre IA generativa! + +Vamos prosseguir para a Lição 7, onde veremos como [criar aplicativos de chat](../../../07-building-chat-applications/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst)! diff --git a/07-building-chat-applications/dotnet/notebook-azure-openai.dib b/07-building-chat-applications/dotnet/notebook-azure-openai.dib new file mode 100644 index 000000000..7909a657b --- /dev/null +++ b/07-building-chat-applications/dotnet/notebook-azure-openai.dib @@ -0,0 +1,37 @@ +#!meta + +{"kernelInfo":{"defaultKernelName":"csharp","items":[{"aliases":[],"name":"csharp"}]}} + +#!csharp + +#r "nuget: Azure.AI.OpenAI, 1.0.0-beta.8" + +#!csharp + +using Azure; +using Azure.AI.OpenAI; +using static System.Environment; + +#!csharp + +string endpoint = ""; +string key = ""; + +OpenAIClient client = new(new Uri(endpoint), new AzureKeyCredential(key)); + +var chatCompletionsOptions = new ChatCompletionsOptions() +{ + Messages = + { + new ChatMessage(ChatRole.System, "You are the president of France"), + new ChatMessage(ChatRole.System, "You have just resigned"), + new ChatMessage(ChatRole.User, "What tasks needs doing?") + }, + MaxTokens = 100 +}; + +Response response = client.GetChatCompletions("gpt-35-turbo", chatCompletionsOptions); + +Console.WriteLine(response.Value.Choices[0].Message.Content); + +Console.WriteLine(); diff --git a/07-building-chat-applications/notebook-simple-azure-openai.ipynb b/07-building-chat-applications/notebook-simple-azure-openai.ipynb new file mode 100644 index 000000000..bacca917b --- /dev/null +++ b/07-building-chat-applications/notebook-simple-azure-openai.ipynb @@ -0,0 +1,68 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import openai\n", + "\n", + "openai.api_type = \"azure\"\n", + "openai.api_version = os.getenv(\"AZURE_OPENAI_API_VERSION\",\"\").strip()\n", + "\n", + "API_KEY = os.getenv(\"AZURE_OPENAI_API_KEY\",\"\").strip()\n", + "assert API_KEY, \"ERROR: Azure OpenAI Key is missing\"\n", + "openai.api_key = API_KEY\n", + "\n", + "RESOURCE_ENDPOINT = os.getenv(\"OPENAI_API_BASE\",\"\").strip()\n", + "assert RESOURCE_ENDPOINT, \"ERROR: Azure OpenAI Endpoint is missing\"\n", + "assert \"openai.azure.com\" in RESOURCE_ENDPOINT.lower(), \"ERROR: Azure OpenAI Endpoint should be in the form: \\n\\n\\t.openai.azure.com\"\n", + "openai.api_base = RESOURCE_ENDPOINT\n", + "deployment = \"gpt-35-turbo\" # replace with your deployment name" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create your first prompt\n", + "text_prompt = \" My foot hurts, what can be wrong?\"\n", + "\n", + "response = openai.ChatCompletion.create(\n", + " engine=deployment,\n", + " messages = [\n", + " {\"role\":\"system\", \"content\":\"I'm a doctor, specialist on surgery\"},\n", + " {\"role\":\"user\",\"content\":text_prompt},])\n", + "\n", + "\n", + "response['choices'][0]['message']['content']" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/07-building-chat-applications/translations/cn/README.md b/07-building-chat-applications/translations/cn/README.md index 85e3444a5..8222c5e45 100644 --- a/07-building-chat-applications/translations/cn/README.md +++ b/07-building-chat-applications/translations/cn/README.md @@ -62,14 +62,7 @@ - **更容易维护**：更新和改进更易于管理，因为大多数 API 和 SDK 在发布新版本时只需要更新库。 - **获得尖端技术**：利用经过微调和在广泛数据集上训练的模型为您的应用程序提供自然语言功能。 -访问 SDK 或 API 的功能通常涉及获取使用所提供服务的许可，这通常是通过使用唯一 kwy 或身份验证 token 来实现的。 我们将使用 OpenAI Python library 来探索它是什么样子。 您也可以在本章的 - -[OpenAI notebook](../../notebook-openai.ipynb?WT.mc_id=academic-105485-koreyst) - -[Azure OpenAI notebook](../../notebook-azure-openai.ipynb?WT.mc_id=academic-105485-koreyst) - -中自行尝试。 - +访问 SDK 或 API 的功能通常涉及获取使用所提供服务的许可，这通常是通过使用唯一 kwy 或身份验证 token 来实现的。 我们将使用 OpenAI Python library 来探索它是什么样子。 您也可以在本章的[notebook](../../notebook-openai.ipynb?WT.mc_id=academic-105485-koreyst) 中自行尝试。 ```python import os diff --git a/07-building-chat-applications/translations/pt-br/README.md b/07-building-chat-applications/translations/pt-br/README.md new file mode 100644 index 000000000..fd17c5ca6 --- /dev/null +++ b/07-building-chat-applications/translations/pt-br/README.md @@ -0,0 +1,192 @@ +# Building Generative AI-Powered Chat Applications + +## Criando Aplicações Chat com IA Generativa + +[![Building Generative AI-Powered Chat Applications](../../images/07-lesson-banner.png?WT.mc_id=academic-105485-koreyst)](https://youtu.be/Kw4i-tlKMrQ?WT.mc_id=academic-105485-koreyst) + +> *(Clique na imagem acima para ver o vídeo da lição)* + +Agora que vimos como podemos criar aplicativos de geração de texto, vamos dar uma olhada nos aplicativos de bate-papo. + +Aplicativos de chat (bate-papo) tornaram-se integrados em nossas vidas diárias, oferecendo mais do que apenas um meio de conversa casual. Eles são partes integrantes do atendimento ao cliente, suporte técnico e até mesmo sistemas de consultoria sofisticados. É provável que você tenha recebido alguma ajuda de um aplicativo de bate-papo não há muito tempo. À medida que integramos tecnologias mais avançadas, como a IA generativa, nessas plataformas, a complexidade aumenta e, com ela, os desafios. + +Algumas perguntas que precisamos responder são: + +- **Criação de um aplicativo**: Como podemos criar de forma eficiente e integrar de maneira transparente esses aplicativos impulsionados por IA para casos de uso específicos? + +- **Monitoramento**: Uma vez implantados, como podemos monitorar e garantir que os aplicativos estejam operando no mais alto nível de qualidade, tanto em termos de funcionalidade quanto na aderência aos [seis princípios de IA responsável](https://www.microsoft.com/ai/responsible-ai?WT.mc_id=academic-105485-koreyst)? + +À medida que avançamos para uma era definida pela automação e interações homem-máquina sem emendas, entender como a IA generativa transforma o escopo, a profundidade e a adaptabilidade dos aplicativos de chat torna-se essencial. Esta lição investigará os aspectos da arquitetura que suportam esses sistemas intricados, explorará as metodologias para ajustá-los para tarefas específicas de domínio e avaliará as métricas e considerações pertinentes para garantir a implantação responsável de IA. + +## Introdução + +Esta lição abrange: + +- Técnicas para criar e integrar eficientemente aplicativos de chat. +- Como aplicar personalização e ajuste fino a aplicativos. +- Estratégias e considerações para monitorar efetivamente aplicativos de chat. + +## Metas de Aprendizado + +Até o final desta lição, você será capaz de: + +- Descrever considerações para construir e integrar aplicativos de chat em sistemas existentes. +- Personalizar aplicativos de chat para casos de uso específicos. +- Identificar métricas-chave e considerações para monitorar e manter a qualidade de aplicativos de chat impulsionados por IA. +- Garantir que os aplicativos de chat utilizem a IA de maneira responsável. + +## Integrando IA Generativa em Aplicativos de Chat + +Elevar aplicativos de chat por meio de IA generativa não se concentra apenas em torná-los mais inteligentes; trata-se de otimizar sua arquitetura, desempenho e interface do usuário para oferecer uma experiência de usuário de qualidade. Isso envolve investigar as bases arquitetônicas, integrações de API e considerações de interface do usuário. Esta seção visa oferecer a você um roteiro abrangente para navegar por essas paisagens complexas, seja você integrando-os em sistemas existentes ou construindo-os como plataformas independentes. + +Ao final desta seção, você estará equipado com a experiência necessária para construir e incorporar eficientemente aplicativos de chat. + +### Chatbot ou Aplicação de Chat? + +Antes de nos aprofundarmos na criação de aplicativos de chat, vamos comparar 'chatbots' com 'aplicações de chat impulsionadas por IA', que desempenham papéis e funcionalidades distintas. O principal propósito de um chatbot é automatizar tarefas conversacionais específicas, como responder a perguntas frequentes ou rastrear um pacote. Normalmente, ele é governado por lógica baseada em regras ou algoritmos complexos de IA. Em contraste, uma aplicação de chat impulsionada por IA é um ambiente muito mais expansivo projetado para facilitar várias formas de comunicação digital, como chats de texto, voz e vídeo entre usuários humanos. Sua característica definidora é a integração de um modelo de IA generativa que simula conversas matizadas e semelhantes às humanas, gerando respostas com base em uma ampla variedade de entradas e indicações contextuais. Uma aplicação de chat impulsionada por IA generativa pode participar de discussões em domínio aberto, adaptar-se a contextos conversacionais em evolução e até mesmo produzir diálogos criativos ou complexos. + +A tabela abaixo destaca as principais diferenças e semelhanças para nos ajudar a entender seus papéis únicos na comunicação digital. + +| Chatbot | Aplicação de Chat Impulsionada por IA Generativa | +| ------------------------------------- | ------------------------------------------------- | +| Focado em tarefas e baseado em regras | Consciente do contexto | +| Frequentemente integrado a sistemas maiores | Pode hospedar um ou vários chatbots | +| Limitado a funções programadas | Incorpora modelos de IA generativa | +| Interações especializadas e estruturadas | Capaz de discussões em domínio aberto | + +### Alavancando funcionalidades pré-criadas com SDKs e APIs + +Ao criar uma aplicação de chat, um ótimo primeiro passo é avaliar o que já está disponível. Utilizar SDKs e APIs para construir aplicações de chat é uma estratégia vantajosa por várias razões. Ao integrar SDKs e APIs bem documentados, você posiciona estrategicamente sua aplicação para o sucesso a longo prazo, abordando preocupações de escalabilidade e manutenção. + +- **Acelera o processo de desenvolvimento e reduz o overhead**: Contar com funcionalidades pré-construídas, em vez do processo caro de construí-las, permite que você se concentre em outros aspectos da sua aplicação que possam ser mais importantes, como a lógica de negócios. + +- **Melhor desempenho**: Ao construir funcionalidades do zero, eventualmente você se perguntará "Como ela escala? Esta aplicação é capaz de lidar com um aumento repentino de usuários?" SDKs e APIs bem mantidos frequentemente têm soluções embutidas para essas preocupações. + +- **Manutenção mais fácil**: Atualizações e melhorias são mais fáceis de gerenciar, pois a maioria das APIs e SDKs simplesmente requer uma atualização de biblioteca quando uma versão mais recente é lançada. + +- **Acesso a tecnologia de ponta**: Alavancar modelos que foram ajustados e treinados em conjuntos de dados extensivos proporciona à sua aplicação capacidades de linguagem natural. + +Acesso à funcionalidade de um SDK ou API geralmente envolve a obtenção de permissão para usar os serviços fornecidos, frequentemente por meio do uso de uma chave única ou token de autenticação. Utilizaremos a Biblioteca Python da OpenAI para explorar como isso é feito. Você também pode experimentar por conta própria no seguinte [notebook para OpenAI](../../notebook-openai.ipynb?WT.mc_id=academic-105485-koreyst) ou [Notebook para Serviços Azure OpenAI](../../notebook-azure-openai.ipynb?WT.mc_id=academic-105485-koreys) para esta lição. + +```python +import os +import openai + +openai.api_key = os.getenv("OPENAI_API_KEY") + +chat_completion = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "Suggest two titles for an instructional lesson on chat applications for generative AI."}]) +``` + +No exemplo acima é usado o modelo GPT-3.5 Turbo para completar o prompt. Mas observe que a chave da API é definida antes de fazê-lo. Você receberia o seguinte erro se não definisse a chave. + +```output +AuthenticationError: No API key provided. You can set your API key in code using 'openai.api_key = ', or you can set the environment variable OPENAI_API_KEY=). If your API key is stored in a file, you can point the openai module at it with 'openai.api_key_path = '. You can generate API keys in the OpenAI web interface. See https://platform.openai.com/account/api-keys for details. +``` + +## Experiência do Usuário (UX) + +Os princípios gerais de UX se aplicam aos aplicativos de chat. Porém, aqui estão algumas considerações adicionais que se tornam particularmente importantes devido aos componentes de aprendizado de máquina envolvidos. + +- **Mecanismo para lidar com ambiguidade**: Modelos de IA generativa ocasionalmente geram respostas ambíguas. Uma funcionalidade que permite aos usuários solicitar esclarecimentos pode ser útil caso se deparem com esse problema. + +- **Retenção de contexto**: Modelos avançados de IA generativa têm a capacidade de lembrar o contexto dentro de uma conversa, o que pode ser um ativo necessário para a experiência do usuário. Dar aos usuários a capacidade de controlar e gerenciar o contexto melhora a experiência do usuário, mas introduz o risco de retenção de informações sensíveis do usuário. Considerações sobre por quanto tempo essas informações são armazenadas, como a introdução de uma política de retenção, podem equilibrar a necessidade de contexto contra a privacidade. + +- **Personalização**: Com a capacidade de aprender e se adaptar, os modelos de IA oferecem uma experiência individualizada para o usuário. Personalizar a experiência do usuário por meio de recursos como perfis de usuário não apenas faz com que o usuário se sinta compreendido, mas também auxilia na busca por respostas específicas, criando uma interação mais eficiente e satisfatória. + +Um exemplo de personalização é o ajuste de "Instruções Personalizadas" no ChatGPT da OpenAI. Ele permite que você forneça informações sobre si mesmo que podem ser um contexto importante para seus prompts. Aqui está um exemplo de uma instrução personalizada. + +![Custom Instructions Settings in ChatGPT](../../images/custom-instructions.png?WT.mc_id=academic-105485-koreyst) + +Esse prompt "perfil" faz com que o ChatGPT crie um plano de aula sobre listas vinculadas. Observe que o ChatGPT leva em consideração que o usuário pode querer um plano de aula mais aprofundado com base em sua experiência. + +![A prompt in ChatGPT for a lesson plan about linked lists](../../images/lesson-plan-prompt.png?WT.mc_id=academic-105485-koreyst) + +### Estrutura de Mensagens do Sistema da Microsoft para Grandes Modelos de Linguagem + +[Microsoft has provided guidance](https://learn.microsoft.com/azure/ai-services/openai/concepts/system-message#define-the-models-output-format?WT.mc_id=academic-105485-koreyst) para escrever mensagens de sistema eficazes ao gerar respostas de LLMs divididas em 4 áreas: + +1. Definindo para quem o modelo se destina, assim como suas capacidades e limitações. +2. Definindo o formato de saída do modelo. +3. Fornecendo exemplos específicos que demonstrem o comportamento pretendido do modelo. +4. Estabelecendo barreiras comportamentais adicionais. + +### Acessibilidade + +Seja o usuário portador de deficiência visual, auditiva, motora ou cognitiva, uma aplicação de chat bem projetada deve ser utilizável por todos. A lista a seguir detalha características específicas destinadas a aprimorar a acessibilidade para várias deficiências de usuários. + +- **Recursos para Deficiência Visual**: Temas de alto contraste e texto redimensionável, compatibilidade com leitores de tela. +- **Recursos para Deficiência Auditiva**: Funções de texto para fala e fala para texto, indicações visuais para notificações sonoras. +- **Recursos para Deficiência Motora**: Suporte à navegação por teclado, comandos de voz. +- **Recursos para Deficiência Cognitiva**: Opções de linguagem simplificada. + +## Customização e Ajuste Fino para Modelos de Linguagem Específicos de Domínio + +Imagine uma aplicação de chat que compreende o jargão da sua empresa e antecipa as consultas específicas que sua base de usuários comumente faz. Existem algumas abordagens que valem a pena mencionar: + +- **Alavancar modelos DSL**. DSL significa linguagem específica de domínio. Você pode aproveitar um modelo chamado DSL treinado em um domínio específico para entender seus conceitos e cenários. +- **Aplicar ajuste fino**. O ajuste fino é o processo de treinar ainda mais seu modelo com dados específicos. + +## Customização: Usando um DSL + +Aproveitar modelos de linguagem específicos de domínio (Modelos DSL) pode aprimorar o engajamento do usuário ao fornecer interações especializadas e contextualmente relevantes. É um modelo treinado ou ajustado para entender e gerar texto relacionado a um campo, indústria ou assunto específico. As opções para usar um modelo DSL podem variar desde treiná-lo do zero até usar modelos pré-existentes por meio de SDKs e APIs. Outra opção é o ajuste fino, que envolve pegar um modelo pré-treinado existente e adaptá-lo para um domínio específico. + +## Customização: Aplicar Ajuste Fino + +O ajuste fino é frequentemente considerado quando um modelo pré-treinado não atende a um domínio especializado ou tarefa específica. + +Por exemplo, consultas médicas são complexas e exigem muito contexto. Quando um profissional de saúde faz um diagnóstico, isso se baseia em uma variedade de fatores, como estilo de vida ou condições pré-existentes, e pode até depender de periódicos médicos recentes para validar o diagnóstico. Em cenários tão nuances, um aplicativo de chat de IA de propósito geral não pode ser uma fonte confiável. + +### Cenário: um aplicativo médico + +Considere um aplicativo de chat projetado para auxiliar profissionais de saúde, fornecendo referências rápidas a diretrizes de tratamento, interações medicamentosas ou descobertas recentes de pesquisas. + +Um modelo de propósito geral pode ser adequado para responder a perguntas médicas básicas ou fornecer conselhos gerais, mas pode ter dificuldades com o seguinte: + +- **Casos altamente específicos ou complexos**. Por exemplo, um neurologista pode perguntar ao aplicativo: "Quais são as melhores práticas atuais para o manejo da epilepsia resistente a medicamentos em pacientes pediátricos?" +- **Falta de avanços recentes**. Um modelo de propósito geral pode ter dificuldade em fornecer uma resposta atualizada que incorpore os avanços mais recentes em neurologia e farmacologia. + +Em casos como esses, o ajuste fino do modelo com um conjunto de dados médicos especializados pode melhorar significativamente sua capacidade de lidar com essas consultas médicas intrincadas de maneira mais precisa e confiável. Isso requer acesso a um conjunto de dados grande e relevante que represente os desafios e perguntas específicos do domínio que precisam ser abordados. + +## Considerações para uma Experiência de Chat Impulsionada por IA de Alta Qualidade + +Esta seção delineia os critérios para aplicações de chat consideradas "de alta qualidade", que incluem a captura de métricas acionáveis e a adesão a um framework que utiliza de forma responsável a tecnologia de IA. + +### Métricas-Chave + +Para manter o desempenho de alta qualidade de uma aplicação, é essencial acompanhar métricas-chave e considerações. Essas medições não apenas garantem a funcionalidade da aplicação, mas também avaliam a qualidade do modelo de IA e a experiência do usuário. Abaixo está uma lista que abrange métricas básicas, de IA e de experiência do usuário a serem consideradas. + +| Métrica | Definição | Considerações para o Desenvolvedor de Chat | +| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | +| **Tempo de Atividade (Uptime)**| Mede o tempo em que a aplicação está operacional e acessível pelos usuários. | Como você irá minimizar o tempo de inatividade? | +| **Tempo de Resposta** | O tempo que a aplicação leva para responder a uma consulta do usuário. | Como você pode otimizar o processamento de consultas para melhorar o tempo de resposta? | +| **Precisão** | A razão entre previsões verdadeiras positivas e o número total de previsões positivas. | Como você irá validar a precisão do seu modelo? | +| **Revocação (Sensibilidade)** | A razão entre previsões verdadeiras positivas e o número real de positivos. | Como você irá medir e melhorar a revocação? | +| **Escore F1** | A média harmônica de precisão e revocação, que equilibra o compromisso entre ambos. | Qual é o seu Escore F1 alvo? Como você irá equilibrar precisão e revocação? | +| **Perplexidade** | Mede quão bem a distribuição de probabilidade prevista pelo modelo se alinha com a distribuição real dos dados. | Como você irá minimizar a perplexidade? | +| **Métricas de Satisfação do Usuário** | Mede a percepção do usuário em relação à aplicação. Frequentemente capturado por meio de pesquisas. | Com que frequência você irá coletar feedback do usuário? Como você irá se adaptar a isso? | +| **Taxa de Erro** | A taxa na qual o modelo comete erros na compreensão ou saída. | Quais estratégias você tem para reduzir as taxas de erro? | +| **Ciclos de Retreinamento** | A frequência com que o modelo é atualizado para incorporar novos dados e insights. | Com que frequência você irá retrainer o modelo? O que desencadeia um ciclo de retratamento? | +| **Detecção de Anomalias** | Ferramentas e técnicas para identificar padrões incomuns que não seguem o comportamento esperado. | Como você irá responder a anomalias? | + | +### Implementando Práticas de IA Responsável em Aplicações de Chat + +A abordagem da Microsoft para a IA Responsável identificou seis princípios que devem orientar o desenvolvimento e uso de IA. Abaixo estão os princípios, suas definições e o que um desenvolvedor de chat deve considerar e por que deve levar isso a sério. + +| Princípios | Definição pela Microsoft | Considerações para o Desenvolvedor de Chat | Por que é Importante | +| ----------------------- | ------------------------------------------------------ | ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | +| Justiça | Sistemas de IA devem tratar todas as pessoas de forma justa. | Garantir que a aplicação de chat não discrimine com base nos dados do usuário. | Construir confiança e inclusividade entre os usuários; evita ramificações legais. | +| Confiabilidade e Segurança | Sistemas de IA devem ter desempenho confiável e seguro. | Implementar testes e mecanismos de segurança para minimizar erros e riscos. | Garante satisfação do usuário e evita possíveis danos. | +| Privacidade e Segurança | Sistemas de IA devem ser seguros e respeitar a privacidade. | Implementar criptografia forte e medidas de proteção de dados. | Proteger dados sensíveis do usuário e cumprir leis de privacidade. | +| Inclusividade | Sistemas de IA devem capacitar todos e envolver as pessoas. | Projetar uma interface acessível e fácil de usar para diversos públicos. | Garante que uma variedade maior de pessoas possa usar a aplicação de forma eficaz. | +| Transparência | Sistemas de IA devem ser compreensíveis. | Fornecer documentação clara e justificativa para as respostas da IA. | Os usuários têm mais probabilidade de confiar em um sistema se puderem entender como são tomadas as decisões. | +| Responsabilidade | As pessoas devem ser responsáveis pelos sistemas de IA. | Estabelecer um processo claro para auditoria e melhoria das decisões de IA. | Possibilita melhorias contínuas e medidas corretivas em caso de erros. | + +## Tarefa + +Veja a [tarefa](../../notebook-azure-openai.ipynb?WT.mc_id=academic-105485-koreyst) que o levará por uma série de exercícios, desde a execução de seus primeiros prompts de chat até a classificação e resumo de texto e muito mais. + +## Excelente Trabalho! Continue no Aprendizado! + +Depois de concluir esta lição, confira nossa [coleção de aprendizado de IA generativa](https://aka.ms/genai-collection?WT.mc_id=academic-105485-koreyst) para continuar a aprimorar seus conhecimentos sobre IA generativa! + +Agora, vamos seguir para a Lição 8 para ver como você pode começar a [criar aplicativos de pesquisa](../../../08-building-search-applications/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst)! \ No newline at end of file diff --git a/08-building-search-applications/README.md b/08-building-search-applications/README.md index de1368e2c..55bb8f53b 100644 --- a/08-building-search-applications/README.md +++ b/08-building-search-applications/README.md @@ -47,7 +47,7 @@ Here is an example of a semantic search. Let's say you were looking to buy a car [Text embeddings](https://en.wikipedia.org/wiki/Word_embedding?WT.mc_id=academic-105485-koreyst) are a text representation technique used in [natural language processing](https://en.wikipedia.org/wiki/Natural_language_processing?WT.mc_id=academic-105485-koreyst). Text embeddings are semantic numerical representations of text. Embeddings are used to represent data in a way that is easy for a machine to understand. There are many models for building text embeddings, in this lesson, we will focus on generating embeddings using the OpenAI Embedding Model. -Here's an example, image the following text is in a transcript from one of the episodes on the AI Show YouTube channel: +Here's an example, imagine the following text is in a transcript from one of the episodes on the AI Show YouTube channel: ```text Today we are going to learn about Azure Machine Learning. diff --git a/08-building-search-applications/dotnet/notebook-azure-openai.dib b/08-building-search-applications/dotnet/notebook-azure-openai.dib new file mode 100644 index 000000000..7dfc2ca1e --- /dev/null +++ b/08-building-search-applications/dotnet/notebook-azure-openai.dib @@ -0,0 +1,61 @@ +#!meta + +{"kernelInfo":{"defaultKernelName":"csharp","items":[{"aliases":[],"name":"csharp"}]}} + +#!csharp + +#r "nuget: Azure.AI.OpenAI, 1.0.0-beta.9" + +#!csharp + +using Azure; +using Azure.AI.OpenAI; + +#!csharp + +#r "nuget:Microsoft.DotNet.Interactive.AIUtilities, 1.0.0-beta.23557.4" + +using Microsoft.DotNet.Interactive; +using Microsoft.DotNet.Interactive.AIUtilities; + +#!csharp + +var azureOpenAIKey = ""; +var azureOpenAIEndpoint = ""; +var deployment = ""; + +#!csharp + +OpenAIClient client = new (new Uri(azureOpenAIEndpoint), new AzureKeyCredential(azureOpenAIKey)); + +#!csharp + +var source = "Car"; +var compareTo = "Vehicle"; +var parrot = "A bird"; + +var parrotEmbeddings = await client.GetEmbeddingsAsync(new EmbeddingsOptions(deployment, new []{ parrot })); + +// vector version +var embeddings = await client.GetEmbeddingsAsync(new EmbeddingsOptions(deployment, new []{ source })); + +// vector version +var embeddingsCompareTo = await client.GetEmbeddingsAsync(new EmbeddingsOptions(deployment, new []{ compareTo })); + +var sourceValue = embeddings.Value.Data[0].Display(); +Console.WriteLine(sourceValue); +var compareToValue = embeddingsCompareTo.Value.Data[0].Display(); +Console.WriteLine(compareToValue); + +#!csharp + +var comparer = new CosineSimilarityComparer(f => f); +var carArray = embeddings.Value.Data[0].Embedding.ToArray(); // float [] +var vehicleArray = embeddingsCompareTo.Value.Data[0].Embedding.ToArray(); // float [] +var parrotArray = parrotEmbeddings.Value.Data[0].Embedding.ToArray(); // float [] + +var score = comparer.Score(carArray, vehicleArray); +Console.WriteLine(score); + +score = comparer.Score(carArray, parrotArray); +Console.WriteLine(score); diff --git a/08-building-search-applications/notebook-azure-openai-simple.ipynb b/08-building-search-applications/notebook-azure-openai-simple.ipynb new file mode 100644 index 000000000..cd36c2e27 --- /dev/null +++ b/08-building-search-applications/notebook-azure-openai-simple.ipynb @@ -0,0 +1,109 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install openai dotenv" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import openai\n", + "from dotenv import load_dotenv\n", + "load_dotenv()\n", + "\n", + "openai.api_type = \"azure\"\n", + "openai.api_version = os.getenv(\"AZURE_OPENAI_API_VERSION\",\"\").strip()\n", + "\n", + "API_KEY = os.getenv(\"AZURE_OPENAI_API_KEY\",\"\").strip()\n", + "assert API_KEY, \"ERROR: Azure OpenAI Key is missing\"\n", + "openai.api_key = API_KEY\n", + "\n", + "RESOURCE_ENDPOINT = os.getenv(\"OPENAI_API_BASE\",\"\").strip()\n", + "assert RESOURCE_ENDPOINT, \"ERROR: Azure OpenAI Endpoint is missing\"\n", + "assert \"openai.azure.com\" in RESOURCE_ENDPOINT.lower(), \"ERROR: Azure OpenAI Endpoint should be in the form: \\n\\n\\t.openai.azure.com\"\n", + "openai.api_base = RESOURCE_ENDPOINT" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Dependencies for embeddings_utils\n", + "!pip install matplotlib plotly scikit-learn pandas" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from openai.embeddings_utils import cosine_similarity" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "text = 'the quick brown fox jumped over the lazy dog'\n", + "model = 'text-embedding-ada-002'\n", + "openai.Embedding()\\\n", + " .create(input=[text], engine='text-embedding-ada-002')[\"data\"][0][\"embedding\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# compare several words\n", + "automobile_embedding = openai.Embedding.create(input='automobile', engine=model)[\"data\"][0][\"embedding\"]\n", + "vehicle_embedding = openai.Embedding.create(input='vehicle', engine=model)[\"data\"][0][\"embedding\"]\n", + "dinosaur_embedding = openai.Embedding.create(input='dinosaur', engine=model)[\"data\"][0][\"embedding\"]\n", + "stick_embedding = openai.Embedding.create(input='stick', engine=model)[\"data\"][0][\"embedding\"]\n", + "\n", + "# comparing cosine similarity, automobiles vs automobiles should be 1.0, i.e exactly the same, while automobiles vs dinosaurs should be between 0 and 1, i.e. not the same\n", + "print(cosine_similarity(automobile_embedding, automobile_embedding))\n", + "print(cosine_similarity(automobile_embedding, vehicle_embedding))\n", + "print(cosine_similarity(automobile_embedding, dinosaur_embedding))\n", + "print(cosine_similarity(automobile_embedding, stick_embedding))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/08-building-search-applications/translations/pt-br/README.md b/08-building-search-applications/translations/pt-br/README.md new file mode 100644 index 000000000..7ff3dc49b --- /dev/null +++ b/08-building-search-applications/translations/pt-br/README.md @@ -0,0 +1,169 @@ +# Criando Aplicações de Busca + +[![Introduction to Generative AI and Large Language Models](../../images/08-lesson-banner.png?WT.mc_id=academic-105485-koreyst)](TBD) + +> **Vídeo em breve** + +Há muito mais nas LLMs do que chatbots e geração de texto. Também é possível criar aplicações de busca usando `Embeddings`. `Embeddings` são representações numéricas de dados, também conhecidas como vetores, e podem ser usados para busca semântica de dados. + +Nesta lição, você vai criar uma aplicação de busca para a nossa startup de educação. Nossa startup é uma organização sem fins lucrativos que fornece educação gratuita para estudantes em países em desenvolvimento. Nossa startup possui uma grande quantidade de vídeos no YouTube que os estudantes podem usar para aprender sobre IA. Nossa startup deseja criar uma aplicação de busca que permita aos estudantes procurar por um vídeo no YouTube digitando uma pergunta. + +Por exemplo, um estudante pode digitar: 'O que é Jupyter Notebooks?' ou 'O que é Azure ML' e a aplicação de busca retornará uma lista de vídeos do YouTube relevantes para a pergunta. E melhor ainda, a aplicação de busca retornará um link para o local no vídeo onde está localizada a resposta para a pergunta. + +## Introdução + +Nesta lição, vamos cobrir: + +- Busca semântica vs busca por palavras-chave. +- O que são Embeddings de Texto. +- Criando um Índice de Embeddings de Texto. +- Buscando em um Índice de Embeddings de Texto. + +## Metas de Aprendizado + +Após completar esta lição, você será capaz de: + +- Diferenciar entre busca semântica e busca por palavras-chave. +- Explicar o que são Embeddings de Texto. +- Criar uma aplicação usando Embeddings para buscar dados. + +## Por que criar uma aplicação de busca? + +Criar uma aplicação de busca ajudará você a entender como usar Embeddings para buscar dados. Você também aprenderá como construir uma aplicação de busca que pode ser usada por estudantes para encontrar informações rapidamente. + +A lição inclui um Índice de Embeddings dos transcritos do YouTube para o canal [AI Show](https://www.youtube.com/playlist?list=PLlrxD0HtieHi0mwteKBOfEeOYf0LJU4O1?WT.mc_id=academic-105485-koreyst) da Microsoft no YouTube. O AI Show é um canal do YouTube que ensina sobre IA e aprendizado de máquina. O Índice de Embeddings contém os Embeddings para cada um dos transcritos do YouTube até outubro de 2023. Você usará o Índice de Embeddings para construir uma aplicação de busca para nossa startup. A aplicação de busca retorna um link para o local no vídeo onde está localizada a resposta para a pergunta. Esta é uma ótima maneira para os estudantes encontrarem rapidamente as informações de que precisam. + +Abaixo nós temos um exemplo de uma consulta semântica para a pergunta: 'É possível usar o RStudio com o Azure ML?'. Confira a URL do YouTube, você verá que a URL contém um carimbo de data/hora que o leva para o local no vídeo onde está localizada + +![Semantic query for the question "can you use rstudio with Azure ML"](../../images/query-results.png?WT.mc_id=academic-105485-koreyst) + +## O que é busca semântica? + +Agora você pode estar se perguntando, o que é busca semântica? A busca semântica é uma técnica de busca que utiliza a semântica, ou significado, das palavras em uma consulta para retornar resultados relevantes. + +Aqui está um exemplo de busca semântica. Digamos que você esteja procurando comprar um carro, você pode buscar por 'meu carro dos sonhos', a busca semântica entende que você não está `sonhando` com um carro, mas sim procurando comprar o seu carro `ideal`. A busca semântica compreende sua intenção e retorna resultados relevantes. A alternativa é a `busca por palavras-chave`, que literalmente procuraria sonhos sobre carros e frequentemente retornaria resultados irrelevantes. + +## O que são Embeddings de Texto? + +[Embeddings de texto](https://en.wikipedia.org/wiki/Word_embedding?WT.mc_id=academic-105485-koreyst) são uma técnica de representação de texto usada em [processamento de linguagem natural](https://en.wikipedia.org/wiki/Natural_language_processing?WT.mc_id=academic-105485-koreyst). Embeddings de texto são representações numéricas semânticas de texto. Embeddings são usados para representar dados de uma maneira fácil para uma máquina entender. Existem muitos modelos para construir embeddings de texto, nesta lição, vamos nos concentrar em gerar embeddings usando o Modelo de Embedding da OpenAI. + +Aqui está um exemplo, imagine que o seguinte texto está em um transcrição de um dos episódios no canal do YouTube AI Show: + +```text +Today we are going to learn about Azure Machine Learning. +``` + +Nós passaríamos o texto para a API de Embedding da OpenAI e ela retornaria o seguinte embedding consistindo de 1536 números, também conhecido como um vetor. Cada número no vetor representa um aspecto diferente do texto. Para brevidade, aqui estão os primeiros 10 números do vetor. + +```python +[-0.006655829958617687, 0.0026128944009542465, 0.008792596869170666, -0.02446001023054123, -0.008540431968867779, 0.022071078419685364, -0.010703742504119873, 0.003311325330287218, -0.011632772162556648, -0.02187200076878071, ...] +``` + +## Como o Índice de Embeddings é criado? + +O Índice de Embeddings para esta lição foi criado com uma série de scripts Python. Você encontrará os scripts juntamente com as instruções no [README](../../scripts/README.md?WT.mc_id=academic-105485-koreyst) na pasta 'scripts' para esta lição. Você não precisa executar esses scripts para completar esta lição, pois o Índice de Embeddings é fornecido para você. + +Os scripts executam as seguintes operações: + +1. A transcrição de cada vídeo do YouTube na lista de reprodução [AI Show](https://www.youtube.com/playlist?list=PLlrxD0HtieHi0mwteKBOfEeOYf0LJU4O1?WT.mc_id=academic-105485-koreyst) é baixada. + +2. Usando [OpenAI Functions](https://learn.microsoft.com/azure/ai-services/openai/how-to/function-calling?WT.mc_id=academic-105485-koreyst), uma tentativa é feita para extrair o nome do orador dos primeiros 3 minutos do transcrição do YouTube. O nome do orador para cada vídeo é armazenado no Índice de Embeddings chamado `embedding_index_3m.json`. + +3. O texto da transcrição é então dividido em **segmentos de texto de 3 minutos**. O segmento inclui cerca de 20 palavras sobrepostas do próximo segmento para garantir que o Embedding para o segmento não seja cortado e para fornecer um melhor contexto de busca. + +4. Cada segmento de texto é então passado para a API de Chat da OpenAI para resumir o texto em 60 palavras. O resumo também é armazenado no Índice de Embeddings `embedding_index_3m.json`. + +5. Finalmente, o texto do segmento é passado para a API de Embedding da OpenAI. A API de Embedding retorna um vetor de 1536 números que representam o significado semântico do segmento. O segmento juntamente com o vetor de Embedding da OpenAI é armazenado em um Índice de Embeddings `embedding_index_3m.json`. + +### Banco de Dados Vetorial + +Para simplificar a lição, o Índice de Embeddings é armazenado em um arquivo JSON chamado `embedding_index_3m.json` e carregado em um Dataframe Pandas. No entanto, em produção, o Índice de Embeddings seria armazenado em um banco de dados vetorial como [Azure Cognitive Search](https://learn.microsoft.com/training/modules/improve-search-results-vector-search?WT.mc_id=academic-105485-koreyst), [Redis](https://cookbook.openai.com/examples/vector_databases/redis/readme?WT.mc_id=academic-105485-koreyst), [Pinecone](https://cookbook.openai.com/examples/vector_databases/pinecone/readme?WT.mc_id=academic-105485-koreyst), [Weaviate](https://cookbook.openai.com/examples/vector_databases/weaviate/readme?WT.mc_id=academic-105485-koreyst), para citar apenas alguns. + +## Compreendendo a similaridade de cosseno + +Aprendemos sobre embeddings de texto, o próximo passo é aprender como usar embeddings de texto para buscar dados e, em particular, encontrar os embeddings mais semelhantes a uma consulta dada usando a similaridade de cosseno. + +### O que é similaridade de cosseno? + +A similaridade de cosseno é uma medida de similaridade entre dois vetores, você também ouvirá isso referido como `busca por vizinho mais próximo`. Para realizar uma busca por similaridade de cosseno, é necessário _vetorizar_ o texto da _consulta_ usando a API de Embedding da OpenAI. Em seguida, calcular a _similaridade de cosseno_ entre o vetor de consulta e cada vetor no Índice de Embeddings. Lembre-se, o Índice de Embeddings tem um vetor para cada segmento de texto do transcrição do YouTube. Finalmente, ordene os resultados por similaridade de cosseno, e os segmentos de texto com a maior similaridade de cosseno são os mais semelhantes à consulta. + +De uma perspectiva matemática, a similaridade de cosseno mede o cosseno do ângulo entre dois vetores projetados em um espaço multidimensional. Essa medida é benéfica, porque se dois documentos estão distantes pela distância euclidiana devido ao tamanho, eles ainda podem ter um ângulo menor entre eles e, portanto, uma maior similaridade de cosseno. Para mais informações sobre as equações de similaridade de cosseno, consulte [Similaridade de cosseno](https://en.wikipedia.org/wiki/Cosine_similarity?WT.mc_id=academic-105485-koreyst). + +## Criando sua primeira aplicação de busca + +A seguir, vamos aprender como construir uma aplicação de busca usando Embeddings. A aplicação de busca permitirá que os estudantes procurem por um vídeo digitando uma pergunta. A aplicação de busca retornará uma lista de vídeos relevantes para a pergunta. A aplicação de busca também retornará um link para o local no vídeo onde está localizada a resposta para a pergunta. + +Esta solução foi construída e testada no Windows 11, macOS e Ubuntu 22.04 usando Python 3.10 ou posterior. Você pode baixar o Python em [python.org](https://www.python.org/downloads/?WT.mc_id=academic-105485-koreyst). + +## Assignment - building a search application, to enable students + +## Tarefa - criando uma aplicação de busca para habilitar os estudantes + +Nós introduzimos nossa startup no início desta lição. Agora é hora de habilitar os estudantes para criar uma aplicação de busca para suas avaliações. + +Nessa tarefa, você criará os Serviços Azure OpenAI que serão usados para construir a aplicação de busca. Você criará os seguintes Serviços Azure OpenAI. Você precisará de uma assinatura Azure para completar esta tarefa. + +### Inicie o Azure Cloud Shell + +1. Entre no [portal Azure](https://portal.azure.com/?WT.mc_id=academic-105485-koreyst). +2. Selecione o ícone do Cloud Shell no canto superior direito do portal Azure. +3. Selecione **Bash** para o tipo de ambiente. + +#### Crie um grupo de recursos + +> Para estas instruções, estamos usando o grupo de recursos chamado "semantic-video-search" no East US. +> Você pode alterar o nome do grupo de recursos, mas ao alterar o local dos recursos, +> verifique a [tabela de disponibilidade do modelo](https://aka.ms/oai/models?WT.mc_id=academic-105485-koreyst). + +```shell +az group create --name semantic-video-search --location eastus +``` + +#### Crie um recurso do Serviço do Azure OpenAI + +No Azure Cloud Shell, execute o seguinte comando para criar um recurso do Serviço Azure OpenAI. + +```shell +az cognitiveservices account create --name semantic-video-openai --resource-group semantic-video-search \ + --location eastus --kind OpenAI --sku s0 +``` + +#### Obtenha o endpoint e as chaves para uso nesta aplicação + +No Azure Cloud Shell, execute os seguintes comandos para obter o endpoint e as chaves para o recurso do Serviço Azure OpenAI. + +```shell +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 +``` + +#### Implemente o modelo de Embedding da OpenAI + +No Azure Cloud Shell, execute o seguinte comando para implantar o modelo de Embedding da OpenAI. + +```shell +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 \ + --scale-settings-scale-type "Standard" +``` + +## Solução + +Abre a [notebook de solução](../../solution.ipynb?WT.mc_id=academic-105485-koreyst) no GitHub Codespaces e siga as instruções no Jupyter Notebook. + +Quando você executar o notebook, será solicitado a inserir uma consulta. A caixa de entrada será assim: + +![Input box for the user to input a query](../../images/notebook-search.png?WT.mc_id=academic-105485-koreyst) + +## Excelente trabalho! Continue aprendendo! + +Após completar esta lição, confira nossa [coleção de aprendizado de IA generativa](https://aka.ms/genai-collection?WT.mc_id=academic-105485-koreyst) para continuar a aprimorar seu conhecimento em IA generativa! + +Aqui vamos, para a Lição 9, onde veremos como [criar aplicações de geração de imagens](../../../09-building-image-applications/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst)! diff --git a/09-building-image-applications/README.md b/09-building-image-applications/README.md index 489d7343c..ef1a0cba3 100644 --- a/09-building-image-applications/README.md +++ b/09-building-image-applications/README.md @@ -410,7 +410,7 @@ openai.api_type = 'azure' 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. +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. @@ -423,7 +423,7 @@ 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""" +prompt = f"""{metaprompt} Generate monument of the Arc of Triumph in Paris, France, in the evening light with a small child holding a Teddy looks on. """" diff --git a/09-building-image-applications/app.py b/09-building-image-applications/app.py index 73a4d75b1..6c045f222 100644 --- a/09-building-image-applications/app.py +++ b/09-building-image-applications/app.py @@ -21,11 +21,12 @@ try: # Create an image by using the image generation API + generation_response = client.Image.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, + temperature=1, ) # Set the directory for the stored image image_dir = os.path.join(os.curdir, 'images') @@ -53,20 +54,27 @@ # ---creating variation below--- + response = client.Image.create_variation( image=open(image_path, "rb"), n=1, size="1024x1024" ) +======= +# response = openai.Image.create_variation( +# image=open(image_path, "rb"), +# n=1, +# size="1024x1024" +# ) -image_path = os.path.join(image_dir, 'generated_variation.png') +# image_path = os.path.join(image_dir, 'generated_variation.png') -image_url = response['data'][0]['url'] +# image_url = response['data'][0]['url'] -generated_image = requests.get(image_url).content # download the image -with open(image_path, "wb") as image_file: - image_file.write(generated_image) +# 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() \ No newline at end of file +# # Display the image in the default image viewer +# image = Image.open(image_path) +# image.show() \ No newline at end of file diff --git a/09-building-image-applications/dotnet/notebook-azure-openai.dib b/09-building-image-applications/dotnet/notebook-azure-openai.dib new file mode 100644 index 000000000..a621fffb7 --- /dev/null +++ b/09-building-image-applications/dotnet/notebook-azure-openai.dib @@ -0,0 +1,37 @@ +#!meta + +{"kernelInfo":{"defaultKernelName":"csharp","items":[{"aliases":[],"name":"csharp"}]}} + +#!csharp + +#r "nuget: Azure.AI.OpenAI, 1.0.0-beta.9" + +#!csharp + +using System; +using System.IO; +using System.Threading.Tasks; +using Azure.AI.OpenAI; +using Azure; + +#!csharp + +string endpoint = ""; +string key = ""; + +#!csharp + +OpenAIClient client = new(new Uri(endpoint), new AzureKeyCredential(key)); + +var imageGenerations = await client.GetImageGenerationsAsync( + new ImageGenerationOptions() + { + Prompt = "captain with a parrot on his shoulder", + Size = ImageSize.Size256x256, + }); + +// Image Generations responses provide URLs you can use to retrieve requested images +Uri imageUri = imageGenerations.Value.Data[0].Url; + +// Print the image URI to console: +Console.WriteLine(imageUri); diff --git a/09-building-image-applications/images/generated-image.png b/09-building-image-applications/images/generated-image.png index 3fc41eb12..4facb0125 100644 Binary files a/09-building-image-applications/images/generated-image.png and b/09-building-image-applications/images/generated-image.png differ diff --git a/09-building-image-applications/translations/cn/README.md b/09-building-image-applications/translations/cn/README.md index ddc67e502..afea0b4a9 100644 --- a/09-building-image-applications/translations/cn/README.md +++ b/09-building-image-applications/translations/cn/README.md @@ -415,7 +415,7 @@ openai.api_type = 'azure' 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. +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. @@ -428,7 +428,7 @@ 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""" +prompt = f"""{metaprompt} Generate monument of the Arc of Triumph in Paris, France, in the evening light with a small child holding a Teddy looks on. """" diff --git a/09-building-image-applications/translations/pt-br/README.md b/09-building-image-applications/translations/pt-br/README.md new file mode 100644 index 000000000..cd482d1f6 --- /dev/null +++ b/09-building-image-applications/translations/pt-br/README.md @@ -0,0 +1,506 @@ +# Criando aplicativos de geração de imagens + +[![Building Image Generation Applications](../../images/09-lesson-banner.png?WT.mc_id=academic-105485-koreyst)](TBD) + +> **Vídeo em Breve** + +Ainda há muito mais que os LLMs podem fazer além da geração de texto. Também é possível gerar imagens a partir de descrições de texto. Ter imagens como modalidade pode ser altamente útil em uma série de áreas, desde MedTech, arquitetura, turismo, desenvolvimento de jogos e muito mais. Neste capítulo, veremos os dois modelos de geração de imagens mais populares, DALL-E e Midjourney. + +## Introduction + +In this lesson, we will cover: + +- Image generation and why it's useful. +- DALL-E and Midjourney, what they are, and how they work. +- 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. +- Work with DALL-E and Midjourney. + +## Why build an image generation application? + +Image generation applications are a great way to explore the capabilities of Generative AI. They can be used for, for example: + +- **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. + +## Scenario: Edu4All + +As part of this lesson, we will continue to work with our startup, Edu4All, in this lesson. The students will create images for their assessments, exactly what images is up to the students, but they could be illustrations for their own fairytale or create a new character for their story or help them visualize their ideas and concepts. + +Here's what Edu4All's students could generate for example if they're working in class on monuments: + +![Edu4All startup, class on monuments, Eiffel Tower](../../images/startup.png?WT.mc_id=academic-105485-koreyst) + +using a prompt like + +## Introdução + +Nesta lição, abordaremos: + +- Geração de imagens e por que é útil. +- DALL-E e Midjourney, o que são e como funcionam. +- Como criar uma aplicação de geração de imagens. + +## Metas de Aprendizado + +Após completar esta lição, você será capaz de: + +- Criar uma aplicação de geração de imagens. +- Definir limites para o seu aplicativo com meta-prompts. +- Trabalhar com DALL-E e Midjourney. + +## Por que criar um aplicativo de geração de imagens? + +Aplicativos de geração de imagens são uma ótima maneira de explorar as capacidades da Inteligência Artificial Generativa. Eles podem ser usados, por exemplo: + +- **Edição e síntese de imagens**: Você pode gerar imagens para uma variedade de casos de uso, como edição e síntese de imagens. + +- **Aplicados a várias indústrias**: Eles também podem ser usados para gerar imagens para diversas indústrias como: Medtech, Turismo, Desenvolvimento de Jogos e muito mais. + +## Cenário: Edu4All + +Como parte desta lição, continuaremos a trabalhar com nossa startup, Edu4All. Os estudantes criarão imagens para suas avaliações, exatamente quais imagens ficam a critério dos estudantes, mas podem ser ilustrações para seu próprio conto de fadas, criar um novo personagem para sua história ou ajudá-los a visualizar suas ideias e conceitos. + +Veja o que os estudantes da Edu4All poderiam gerar, por exemplo, se estivessem trabalhando em sala de aula sobre monumentos: + +![Edu4All startup, aula sobre monumentos, Torre Eiffel](../../images/startup.png?WT.mc_id=academic-105485-koreyst) + +usando um prompt como: + +> "Dog next to Eiffel Tower in early morning sunlight" + +## O que é DALL-E e Midjourney? + +[DALL-E](https://openai.com/dall-e-2?WT.mc_id=academic-105485-koreyst) e [Midjourney](https://www.midjourney.com/?WT.mc_id=academic-105485-koreyst) são dois dos modelos de geração de imagens mais populares, eles permitem que você use prompts para gerar imagens. + +### DALL-E + +Vamos começar com o DALL-E, que é um modelo de Inteligência Artificial Generativa que gera imagens a partir de descrições de texto. + +> [DALL-E é uma combinação de dois modelos, CLIP e atenção difusa](https://towardsdatascience.com/openais-dall-e-and-clip-101-a-brief-introduction-3a4367280d4e?WT.mc_id=academic-105485-koreyst). + +- **CLIP** é um modelo que gera embeddings, que são representações numéricas de dados, a partir de imagens e texto. + +- **Atenção difusa** é um modelo que gera imagens a partir de embeddings. O DALL-E é treinado em um conjunto de dados de imagens e texto e pode ser usado para gerar imagens a partir de descrições de texto. Por exemplo, o DALL-E pode ser usado para gerar imagens de um gato com chapéu ou um cachorro com um moicano. + +### Midjourney + +Midjourney funciona de maneira semelhante ao DALL-E, gerando imagens a partir de prompts de texto. Midjourney também pode ser usado para gerar imagens usando prompts como "um gato com chapéu" ou "um cachorro com um moicano". + +![Imagem gerada pelo Midjourney, pombo mecânico](https://upload.wikimedia.org/wikipedia/commons/thumb/8/8c/Rupert_Breheny_mechanical_dove_eca144e7-476d-4976-821d-a49c408e4f36.png/440px-Rupert_Breheny_mechanical_dove_eca144e7-476d-4976-821d-a49c408e4f36.png?WT.mc_id=academic-105485-koreyst) +*Créditos da imagem: Wikipedia, imagem gerada pelo Midjourney* + +## Como DALL-E e Midjourney Funcionam + +Primeiro, [DALL-E](https://arxiv.org/pdf/2102.12092.pdf?WT.mc_id=academic-105485-koreyst). DALL-E é um modelo de Inteligência Artificial Generativa baseado na arquitetura do transformer com um *transformer autoregressivo*. + +Um *transformer autoregressivo* define como um modelo gera imagens a partir de descrições de texto, gerando um pixel de cada vez e, em seguida, usando os pixels gerados para gerar o próximo pixel. Passando por várias camadas em uma rede neural, até que a imagem esteja completa. + +Com esse processo, o DALL-E controla atributos, objetos, características e muito mais na imagem que gera. No entanto, DALL-E 2 e 3 têm mais controle sobre a imagem gerada. + +## Criando seu primeiro aplicativo de geração de imagens + +Então, o que é necessário para construir um aplicativo de geração de imagens? Você precisa das seguintes bibliotecas: + +- **python-dotenv**, é altamente recomendável usar esta biblioteca para manter suas informações confidenciais em um arquivo *.env* longe do código. +- **openai**, esta biblioteca é o que você usará para interagir com a API da OpenAI. +- **pillow**, para trabalhar com imagens em Python. +- **requests**, para ajudar você a fazer solicitações HTTP. + +1. Crie um arquivo *.env* com o seguinte conteúdo: + + ```text + AZURE_OPENAI_ENDPOINT= + AZURE_OPENAI_KEY= + ``` + + Encontre essas informações no Portal do Azure para o seu recurso na seção "Chaves e Endpoint". + +1. Cole as bibliotecas acima em um arquivo chamado *requirements.txt* assim: + + ```text + python-dotenv + openai + pillow + requests + ``` + +1. Depois, crie um ambiente virtual e instale as bibliotecas: + + ```bash + python3 -m venv venv + source venv/bin/activate + pip install -r requirements.txt + ``` + + Para Windows, use os seguintes comandos para criar e ativar seu ambiente virtual: + + ```bash + python3 -m venv venv + venv\Scripts\activate.bat + ```` + +1. Adicione o seguinte código em um arquivo chamado *app.py*: + + ```python + import openai + import os + import requests + from PIL import Image + import dotenv + + # import dotenv + dotenv.load_dotenv() + + # Get endpoint and key from environment variables + openai.api_base = os.environ['AZURE_OPENAI_ENDPOINT'] + openai.api_key = os.environ['AZURE_OPENAI_KEY'] + + # Assign the API version (DALL-E is currently supported for the 2023-06-01-preview API version only) + openai.api_version = '2023-06-01-preview' + openai.api_type = 'azure' + + + try: + # Create an image by using the image generation API + generation_response = openai.Image.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, + ) + # 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.error.InvalidRequestError as err: + print(err) + + ``` + +Vamos explicar este código: + +- Primeiro, importamos as bibliotecas de que precisamos, incluindo as bibliotecas OpenAI, dotenv, request e Pillow. + + ```python + import openai + import os + import requests + from PIL import Image + import dotenv + ``` + +- Depois, carregamos as variáveis de ambiente do arquivo *.env*. + + ```python + # import dotenv + dotenv.load_dotenv() + ``` + +- Após isso, definimos o endpoint, a chave para a API OpenAI, a versão e o tipo. + + ```python + # Get endpoint and key from environment variables + openai.api_base = os.environ['AZURE_OPENAI_ENDPOINT'] + openai.api_key = os.environ['AZURE_OPENAI_KEY'] + + # add version and type, Azure specific + openai.api_version = '2023-06-01-preview' + openai.api_type = 'azure' + ``` + +- Depois, geramos a imagem: + + ```python + # Create an image by using the image generation API + generation_response = openai.Image.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, + ) + ``` + + Acima está o código que responde com um objeto JSON que contém a URL da imagem gerada. Podemos usar a URL para baixar a imagem e salvá-la em um arquivo. + +- Finalmente, abrimos a imagem e usamos o visualizador de imagens padrão para exibi-la: + + ```python + image = Image.open(image_path) + image.show() + ``` + +### Mais detalhes sobre a geração da imagem + +Vamos dar uma olhada no código que gera a imagem com mais detalhes: + +```python +generation_response = openai.Image.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, + ) +``` + +- **prompt** é o prompt de texto usado para gerar a imagem. Neste caso, estamos usando o prompt: "Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils". + +- **size** é o tamanho da imagem gerada. Neste caso, estamos gerando uma imagem de 1024x1024 pixels. + +- **n** é o número de imagens geradas. Neste caso, estamos gerando duas imagens. + +- **temperature** é um parâmetro que controla a aleatoriedade da saída de um modelo de Inteligência Artificial Generativa. A temperatura é um valor entre 0 e 1, onde 0 significa que a saída é determinística e 1 significa que a saída é aleatória. O valor padrão é 0.7. + +Há mais coisas que você pode fazer com imagens que abordaremos na próxima seção. + +## Mais capacidades de geração de imagens + +Você viu até agora como conseguimos gerar uma imagem usando algumas linhas em Python. No entanto, há mais coisas que você pode fazer com imagens. + +Você também pode fazer o seguinte: + +- **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. + +- **Realizar edições**: Ao fornecer uma imagem existente, uma máscara e um prompt, você pode alterar uma imagem. Por exemplo, você pode adicionar algo a uma parte de uma imagem. Imagine nossa imagem de coelho, você pode adicionar um chapéu ao coelho. Como você faria isso é fornecendo a imagem, uma máscara (identificando a parte da área para a mudança) e um prompt de texto para dizer o que deve ser feito. + + ```python + response = openai.Image.create_edit( + image=open("base_image.png", "rb"), + mask=open("mask.png", "rb"), + prompt="An image of a rabbit with a hat on its head.", + n=1, + size="1024x1024" + ) + image_url = response['data'][0]['url'] + ``` + + A base da imagem conteria apenas o coelho, mas a imagem final teria o chapéu no coelho. + +- **Criar variações**: A ideia é que você pegue uma imagem existente e peça que sejam criadas variações. Para criar uma variação, você fornece uma imagem e um prompt de texto e o código é assim: + + ```python + response = openai.Image.create_variation( + image=open("bunny-lollipop.png", "rb"), + n=1, + size="1024x1024" + ) + image_url = response['data'][0]['url'] + ``` + + > Observação: isso é suportado apenas no OpenAI + +## Temperatura + +Temperatura é um parâmetro que controla a aleatoriedade da saída de um modelo de Inteligência Artificial Generativa. A temperatura é um valor entre 0 e 1, onde 0 significa que a saída é determinística e 1 significa que a saída é aleatória. O valor padrão é 0.7. + +Vamos dar uma olhada em um exemplo de como a temperatura funciona, executando este prompt duas vezes: + +> Prompt : "Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils" + +![Bunny on a horse holding a lollipop, version 1](../../images/v1-generated-image.png?WT.mc_id=academic-105485-koreyst) + +Agora, vamos executar o mesmo prompt apenas para ver que não obteremos a mesma imagem duas vezes: + +![Generated image of bunny on horse](../../images/v2-generated-image.png?WT.mc_id=academic-105485-koreyst) + +Como você pode ver, as imagens são semelhantes, mas não são as mesmas. Vamos tentar mudar o valor da temperatura para 0.1 e ver o que acontece: + +```python + generation_response = openai.Image.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 + ) +``` + +### Alterando a temperatura + +Agora, vamos tentar tornar a resposta mais determinística. Podemos observar pelas duas imagens que geramos que na primeira imagem há um coelho e na segunda imagem há um cavalo, então as imagens variam muito. + +Vamos alterar nosso código e definir a temperatura para 0, assim: + +```python +generation_response = openai.Image.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 + ) +``` + +Agora quando você executar este código, você obtém essas duas imagens: + +- ![Temperature 0, v1](../../images/v1-temp-generated-image.png?WT.mc_id=academic-105485-koreyst) +- ![Temperature 0 , v2](../../images/v2-temp-generated-image.png?WT.mc_id=academic-105485-koreyst) + +Aqui você pode ver claramente como as imagens se assemelham mais umas às outras. + +## Como definir limites para seu aplicativo com metaprompts + +Com a nossa demonstração, já podemos gerar imagens para nossos clientes. No entanto, precisamos estabelecer algumas limitações para nossa aplicação. + +Por exemplo, não queremos gerar imagens que não sejam seguras para o trabalho ou que não sejam apropriadas para crianças. + +Podemos fazer isso com *metaprompts*. Metaprompts são prompts de texto que são usados para controlar a saída de um modelo de IA generativa. Por exemplo, podemos usar metaprompts para controlar a saída e garantir que as imagens geradas sejam seguras para o trabalho ou apropriadas para crianças. + +### Como funciona? + +Agora, como os metaprompts funcionam? + +Metaprompts são prompts de texto usados para controlar a saída de um modelo de IA generativa. Eles são posicionados antes do prompt de texto e são usados para controlar a saída do modelo, sendo incorporados em aplicativos para controlar a saída do modelo. Encapsulando a entrada do prompt e a entrada do metaprompt em um único prompt de texto. + +Um exemplo de metaprompt seria o seguinte: + +```text +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) + +```text + +Now, let's see how we can use meta prompts in our demo. + +```python +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 +``` + +No prompt acima, você pode ver como todas as imagens sendo criadas consideram o metaprompt. + +## Tarefa - vamos habilitar os estudantes + +Nós introduzimos o Edu4All no início desta lição. Agora é hora de permitir que os estudantes gerem imagens para suas avaliações. + +Os estudantes criarão imagens para suas avaliações contendo monumentos, exatamente quais monumentos ficam a critério dos estudantes. Os estudantes são convidados a usar sua criatividade nesta tarefa para colocar esses monumentos em diferentes contextos. + +## Solução + +Aqui está uma possível solução: + +```python +import openai +import os +import requests +from PIL import Image +import dotenv + +# import dotenv +dotenv.load_dotenv() + +# Get endpoint and key from environment variables +openai.api_base = "" +openai.api_key = "" + +# Assign the API version (DALL-E is currently supported for the 2023-06-01-preview API version only) +openai.api_version = '2023-06-01-preview' +openai.api_type = 'azure' + +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""" +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 = openai.Image.create( + prompt=prompt, # Enter your prompt text here + size='1024x1024', + n=2, + temperature=0, + ) + # 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.error.InvalidRequestError as err: + print(err) +``` + +## Excelente trabalho! Continue seu aprendizado + +Após completar esta lição, confira nossa [coleção de aprendizado de IA generativa](https://aka.ms/genai-collection?WT.mc_id=academic-105485-koreyst) para continuar a aprimorar seus conhecimentos sobre IA generativa! + +Vamos partir agora para a Lição 10, onde veremos como [Criando aplicativos de IA com Low Code](../../../10-building-low-code-ai-applications/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) diff --git a/10-building-low-code-ai-applications/translations/pt-br/README.md b/10-building-low-code-ai-applications/translations/pt-br/README.md new file mode 100644 index 000000000..b166f975d --- /dev/null +++ b/10-building-low-code-ai-applications/translations/pt-br/README.md @@ -0,0 +1,231 @@ +# Criando Aplication de IA com Low Code + +[![Building Low Code AI Applications](../../images/10-lesson-banner.png?WT.mc_id=academic-105485-koreyst)](https://youtu.be/XX8491SAF44?WT.mc_id=academic-105485-koreyst) + +> *(Clique na imagem acima para ver o vídeo desta lição)* + +## Introdução + +Agora que aprendemos como criar aplicações geradoras de imagens, vamos falar sobre low code. A IA generativa pode ser usada em diversas áreas, incluindo low code. Mas o que é low code e como podemos adicionar IA nisso? + +A criação de aplicativos e soluções tornou-se mais fácil para desenvolvedores tradicionais e não desenvolvedores por meio do uso de Plataformas de Desenvolvimento Low Code. Essas plataformas possibilitam a criação de aplicativos e soluções com pouco ou nenhum código. Isso é alcançado fornecendo um ambiente visual de desenvolvimento que permite arrastar e soltar componentes para criar aplicativos e soluções. Isso permite que você construa aplicativos e soluções mais rapidamente e com menos recursos. Nesta lição, vamos aprofundar como usar o Low Code e como aprimorar o desenvolvimento de low code com IA usando a Power Platform. + +A Power Platform oferece às organizações a oportunidade de capacitar suas equipes a criar suas próprias soluções por meio de um ambiente intuitivo de low-code ou no-code. Esse ambiente ajuda a simplificar o processo de construção de soluções. Com a Power Platform, as soluções podem ser construídas em dias ou semanas, em vez de meses ou anos. A Power Platform consiste em cinco produtos-chave: Power Apps, Power Automate, Power BI, Power Pages e Power Virtual Agents. + +### Metas de Aprendizagem + +Ao final desta lição, você será capaz de: + +- Entender como Copilot funciona na Power Platform. +- Criar um aplicativo de rastreamento de atribuições de estudantes para nossa startup. +- Criar um fluxo de processamento de faturas que usa IA para extrair informações de faturas. +- Aplicar as melhores práticas ao usar o Modelo de IA Create Text with GPT. + +As ferramentas e tecnologias que você usará nesta lição são: + +- **Power Apps**, para o aplicativo de rastreamento de atribuições de estudantes, que fornece um ambiente de desenvolvimento de low-code para criar aplicativos para rastrear, gerenciar e interagir com dados. +- **Dataverse**, para armazenar os dados do aplicativo de rastreamento de atribuições de estudantes, onde o Dataverse fornecerá uma plataforma de dados de baixo código para armazenar os dados do aplicativo. +- **Power Automate**, para o fluxo de processamento de faturas, onde você terá um ambiente de desenvolvimento de low-code para criar fluxos de trabalho para automatizar o processo de processamento de faturas. +- **AI Builder**, para o Modelo de IA de processamento de faturas, onde você usará modelos de IA predefinidos para processar as faturas para nossa startup. + +## IA Generativa na Power Platform + +O aprimoramento do desenvolvimento de low-code e aplicativos com IA generativa é uma área-chave para a Power Platform. O objetivo é permitir que todos criam aplicativos, sites, painéis e automatizem processos com IA, *sem exigir qualquer conhecimento em ciência de dados*. Esse objetivo é alcançado integrando a IA generativa na experiência de desenvolvimento de low-code na Power Platform na forma de Copilot e AI Builder. + +### Como isso funciona? + +Copilot é um assistente de IA que permite que você crie soluções da Power Platform descrevendo seus requisitos em uma série de etapas de conversação usando linguagem natural. Você pode, por exemplo, instruir seu assistente de IA a declarar quais campos seu aplicativo usará e ele criará tanto o aplicativo quanto o modelo de dados subjacente, ou você poderia especificar como configurar um fluxo no Power Automate. + +Você pode usar as funcionalidades orientadas pelo Copilot como um recurso nas telas do seu aplicativo para permitir que os usuários descubram insights por meio de interações conversacionais. + +O AI Builder é uma capacidade de IA de baixo código disponível na Power Platform que permite que você use Modelos de IA para ajudá-lo a automatizar processos e prever resultados. Com o AI Builder, você pode trazer IA para seus aplicativos e fluxos que se conectam aos seus dados no Dataverse ou em várias fontes de dados em nuvem, como SharePoint, OneDrive ou Azure. + +O Copilot está disponível em todos os produtos da Power Platform: Power Apps, Power Automate, Power BI, Power Pages e Power Virtual Agents. O AI Builder está disponível no Power Apps e Power Automate. Nesta lição, vamos nos concentrar em como usar Copilot e AI Builder no Power Apps e Power Automate para criar uma solução para nossa startup educacional. + +### Copilot no Power Apps + +Como parte da Power Platform, o Power Apps fornece um ambiente de desenvolvimento de low-code para criar aplicativos para rastrear, gerenciar e interagir com dados. É uma suíte de serviços de desenvolvimento de aplicativos com uma plataforma de dados escalável e a capacidade de se conectar a serviços em nuvem e dados locais. O Power Apps permite que você construa aplicativos que são executados em navegadores, tablets e telefones, e podem ser compartilhados com colegas. O Power Apps facilita os usuários no desenvolvimento de aplicativos com uma interface simples, para que cada usuário de negócios ou desenvolvedor profissional possa criar aplicativos personalizados. A experiência de desenvolvimento de aplicativos também é aprimorada com IA generativa por meio do Copilot. + +O recurso de assistente de IA Copilot no Power Apps permite que você descreva que tipo de aplicativo você precisa e que informações deseja que seu aplicativo rastreie, colete ou exiba. O Copilot então gera um aplicativo Canvas responsivo com base na sua descrição. Você pode personalizar o aplicativo conforme suas necessidades. O AI Copilot também gera e sugere uma Tabela Dataverse com os campos que você precisa para armazenar os dados que deseja rastrear e alguns dados de exemplo. Vamos examinar o que é o Dataverse e como você pode usá-lo no Power Apps nesta lição mais tarde. Você pode, então, personalizar a tabela para atender às suas necessidades usando o AI Copilot por meio de etapas de conversação. Este recurso está prontamente disponível na tela inicial do Power Apps. + +### Copilot no Power Automate + +Como parte da Power Platform, o Power Automate permite que os usuários criem fluxos de trabalho automatizados entre aplicativos e serviços. Ele ajuda a automatizar processos de negócios repetitivos, como comunicação, coleta de dados e aprovações de decisões. Sua interface simples permite que usuários com qualquer competência técnica (de iniciantes a desenvolvedores experientes) automatizem tarefas de trabalho. A experiência de desenvolvimento de fluxo de trabalho também é aprimorada com IA generativa por meio do Copilot. + +O recurso de assistente de IA Copilot no Power Automate permite que você descreva que tipo de fluxo você precisa e quais ações deseja que seu fluxo execute. O Copilot, então, gera um fluxo com base na sua descrição. Você pode personalizar o fluxo conforme suas necessidades. O AI Copilot também gera e sugere as ações necessárias para realizar a tarefa que você deseja automatizar. Vamos examinar o que são os fluxos e como você pode usá-los no Power Automate nesta lição mais tarde. Você pode, então, personalizar as ações para atender às suas necessidades usando o AI Copilot por meio de etapas de conversação. Este recurso está prontamente disponível na tela inicial do Power Automate. + +## Atribuição: gerenciar atribuições de estudantes e faturas para nossa startup, usando Copilot + +Nossa startup fornece cursos online para estudantes. A startup cresceu rapidamente e está enfrentando dificuldades para acompanhar a demanda por seus cursos. A startup contratou você como desenvolvedor da Power Platform para ajudá-los a criar uma solução de baixo código para ajudá-los a gerenciar suas atribuições de estudantes e faturas. Sua solução deve ser capaz de ajudá-los a rastrear e gerenciar as atribuições de estudantes por meio de um aplicativo e automatizar o processo de processamento de faturas por meio de um fluxo. Foi solicitado a você que use a IA generativa para desenvolver a solução. + +Quando estiver começando a usar o Copilot, você pode usar a [Biblioteca de Prompts do Power Platform Copilot](https://pnp.github.io/powerplatform-prompts/?WT.mc_id=academic-109639-somelezediko) para começar com os prompts. Esta biblioteca contém uma lista de prompts que você pode usar para criar aplicativos e fluxos com Copilot. Você também pode usar os prompts na biblioteca para ter uma ideia de como descrever seus requisitos para o Copilot. + +### Criando um Aplicativo de Rastreamento de Atribuições de Estudantes para Nossa Startup + +Os educadores em nossa startup têm tido dificuldades para acompanhar as atribuições de estudantes. Eles têm usado uma planilha para rastrear as atribuições, mas isso tem se tornado difícil de gerenciar à medida que o número de estudantes aumentou. Eles pediram a você que construa um aplicativo que os ajude a rastrear e gerenciar as atribuições de estudantes. O aplicativo deve permitir que eles adicionem novas atribuições, vejam atribuições, atualizem atribuições e excluam atribuições. O aplicativo também deve permitir que educadores e estudantes vejam as atribuições que foram avaliadas e aquelas que ainda não foram avaliadas. + +Você criará o aplicativo usando Copilot no Power Apps seguindo as etapas abaixo: + +1. Acesse a [tela inicial do Power Apps](https://make.powerapps.com?WT.mc_id=academic-105485-koreyst). + +2. Use a área de texto na tela inicial para descrever o aplicativo que deseja criar. Por exemplo, ***Quero criar um aplicativo para rastrear e gerenciar as atribuições de estudantes***. Clique no botão **Enviar** para enviar o prompt ao AI Copilot. + +![Descreva o aplicativo que deseja criar](../../images/copilot-chat-prompt-powerapps.png?WT.mc_id=academic-105485-koreyst) + +1. 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](https://docs.microsoft.com/powerapps/maker/data-platform/data-platform-intro?WT.mc_id=academic-109639-somelezediko). + + ![Suggested fields in your new table](../../images/copilot-dataverse-table-powerapps.png?WT.mc_id=academic-105485-koreyst) + +1. Os educadores desejam enviar e-mails aos alunos que enviaram suas atribuições para mantê-los atualizados sobre o progresso de suas tarefas. Você pode usar o Copilot para adicionar um novo campo à tabela para armazenar o e-mail do aluno. Por exemplo, você pode usar o seguinte comando para adicionar um novo campo à tabela: ***Quero adicionar uma coluna para armazenar o e-mail do aluno***. Clique no botão **Enviar** para enviar o comando ao AI Copilot. + +![Adicionando um novo campo](../../images/copilot-new-column.png?WT.mc_id=academic-105485-koreyst) + +1. O AI Copilot gerará um novo campo e você poderá personalizá-lo conforme suas necessidades. + +1. Quando terminar com a tabela, clique no botão **Criar aplicativo** para criar o aplicativo. + +1. O AI Copilot gerará um aplicativo Canvas responsivo com base na sua descrição. Você pode, então, personalizar o aplicativo conforme suas necessidades. + +1. Para que os educadores possam enviar e-mails aos alunos, você pode usar o Copilot para adicionar uma nova tela ao aplicativo. Por exemplo, você pode usar o seguinte comando para adicionar uma nova tela ao aplicativo: ***Quero adicionar uma tela para enviar e-mails aos alunos***. Clique no botão **Enviar** para enviar o comando ao AI Copilot. + +![Adicionando uma nova tela via comando](../../images/copilot-new-screen.png?WT.mc_id=academic-105485-koreyst) + +1. O AI Copilot gerará uma nova tela e você poderá personalizá-la conforme suas necessidades. + +1. Quando terminar com o aplicativo, clique no botão **Salvar** para salvar o aplicativo. + +1. Para compartilhar o aplicativo com os educadores, clique no botão **Compartilhar** e depois clique novamente no botão **Compartilhar**. Você pode, então, compartilhar o aplicativo com os educadores inserindo seus endereços de e-mail. + +> **Dever de Casa**: O aplicativo que você acabou de criar é um bom começo, mas pode ser melhorado. Com o recurso de e-mail, os educadores só podem enviar e-mails aos alunos manualmente digitando seus e-mails. Você pode usar o Copilot para criar uma automação que permitirá aos educadores enviar e-mails aos alunos automaticamente quando eles enviarem suas atribuições? Sua dica é que, com o comando certo, você pode usar o Copilot no Power Automate para criar isso. + +### Criar uma Tabela de Informações de Faturas para Nossa Startup + +A equipe financeira de nossa startup tem tido dificuldades para acompanhar as faturas. Eles têm usado uma planilha para rastrear as faturas, mas isso tem se tornado difícil de gerenciar à medida que o número de faturas aumentou. Eles pediram a você que construa uma tabela que os ajude a armazenar, rastrear e gerenciar as informações das faturas que receberam. A tabela deve ser usada para criar uma automação que extrairá todas as informações da fatura e as armazenará na tabela. A tabela também deve permitir que a equipe financeira veja as faturas que foram pagas e aquelas que ainda não foram pagas. + +A Power Platform possui uma plataforma de dados subjacente chamada Dataverse que permite armazenar os dados para seus aplicativos e soluções. O Dataverse fornece uma plataforma de dados de baixo código para armazenar os dados do aplicativo. É um serviço totalmente gerenciado que armazena dados com segurança na nuvem da Microsoft e é provisionado dentro do seu ambiente Power Platform. Ele vem com capacidades integradas de governança de dados, como classificação de dados, linhagem de dados, controle de acesso fino e muito mais. Você pode aprender mais [sobre o Dataverse aqui](https://docs.microsoft.com/powerapps/maker/data-platform/data-platform-intro?WT.mc_id=academic-109639-somelezediko). + +Por que devemos usar o Dataverse para nossa startup? As tabelas padrão e personalizadas dentro do Dataverse fornecem uma opção de armazenamento segura e baseada na nuvem para seus dados. Tabelas permitem que você armazene diferentes tipos de dados, semelhante a como você pode usar várias planilhas em uma única pasta de trabalho do Excel. Você pode usar tabelas para armazenar dados específicos da sua organização ou necessidade de negócios. Alguns dos benefícios que nossa startup obterá ao usar o Dataverse incluem, mas não estão limitados a: + +- **Fácil de gerenciar**: Tanto os metadados quanto os dados são armazenados na nuvem, então você não precisa se preocupar com os detalhes de como eles são armazenados ou gerenciados. Você pode se concentrar em criar seus aplicativos e soluções. + +- **Seguro**: O Dataverse fornece uma opção de armazenamento segura e baseada na nuvem para seus dados. Você pode controlar quem tem acesso aos dados em suas tabelas e como podem acessá-los usando segurança baseada em funções. + +- **Metadados ricos**: Tipos de dados e relacionamentos são usados diretamente dentro do Power Apps + +- **Lógica e validação**: Você pode usar regras de negócios, campos calculados e regras de validação para impor lógica de negócios e manter a precisão dos dados. + +Agora que você sabe o que é o Dataverse e por que deve usá-lo, vamos ver como você pode usar o Copilot para criar uma tabela no Dataverse para atender aos requisitos de nossa equipe financeira. + +>**Nota** : Você usará esta tabela na próxima seção para criar uma automação que extrairá todas as informações da fatura e as armazenará na tabela. + +Para criar uma tabela no Dataverse usando o Copilot, siga as etapas abaixo: + +1. Acesse a [tela inicial do Power Apps](https://make.powerapps.com?WT.mc_id=academic-105485-koreyst). + +2. Na barra de navegação à esquerda, selecione **Tabelas** e, em seguida, clique em **Descrever a nova tabela**. + +![Selecionar nova tabela](../../images/describe-new-table.png?WT.mc_id=academic-105485-koreyst) + +1. Na tela **Descrever a nova tabela**, use a área de texto para descrever a tabela que deseja criar. Por exemplo, ***Quero criar uma tabela para armazenar informações de fatura***. Clique no botão **Enviar** para enviar o comando ao AI Copilot. + +![Descrever a tabela](../../images/copilot-chat-prompt-dataverse.png?WT.mc_id=academic-105485-koreyst) + +1. O AI Copilot sugerirá uma Tabela Dataverse com os campos necessários para armazenar os dados que você deseja rastrear e alguns dados de exemplo. Você pode, então, personalizar a tabela para atender às suas necessidades usando o recurso de assistente AI Copilot por meio de etapas de conversação. + +![Tabela Dataverse sugerida](../../images/copilot-dataverse-table.png?WT.mc_id=academic-105485-koreyst) + +1. A equipe financeira deseja enviar um e-mail ao fornecedor para atualizá-lo com o status atual de sua fatura. Você pode usar o Copilot para adicionar um novo campo à tabela para armazenar o e-mail do fornecedor. Por exemplo, você pode usar o seguinte comando para adicionar um novo campo à tabela: ***Quero adicionar uma coluna para armazenar o e-mail do fornecedor***. Clique no botão **Enviar** para enviar o comando ao AI Copilot. + +1. O AI Copilot gerará um novo campo e você poderá personalizá-lo conforme suas necessidades. + +1. Quando terminar com a tabela, clique no botão **Criar** para criar a tabela. + +## Modelos de IA na Power Platform com o AI Builder + +O AI Builder é uma capacidade de IA de baixo código disponível na Power Platform que permite que você use Modelos de IA para automatizar processos e prever resultados. Com o AI Builder, você pode adicionar IA aos seus aplicativos e fluxos que se conectam aos seus dados no Dataverse ou em várias fontes de dados em nuvem, como SharePoint, OneDrive ou Azure. + +## Modelos de IA Pré-Criados vs Modelos de IA Personalizados + +O AI Builder fornece dois tipos de Modelos de IA: Modelos de IA Pré-Construídos e Modelos de IA Personalizados. Os Modelos de IA Pré-Construídos estão prontos para uso, treinados pela Microsoft e disponíveis na Power Platform. Eles ajudam a adicionar inteligência aos seus aplicativos e fluxos sem a necessidade de coletar dados e, em seguida, criar, treinar e publicar seus próprios modelos. Você pode usar esses modelos para automatizar processos e prever resultados. + +Alguns dos Modelos de IA Pré-Construídos disponíveis na Power Platform incluem: + +- **Extração de Frases-Chave**: Este modelo extrai frases-chave de texto. +- **Detecção de Idioma**: Este modelo detecta o idioma de um texto. +- **Análise de Sentimento**: Este modelo detecta sentimento positivo, negativo, neutro ou misto em texto. +- **Leitor de Cartões de Visita**: Este modelo extrai informações de cartões de visita. +- **Reconhecimento de Texto**: Este modelo extrai texto de imagens. +- **Detecção de Objetos**: Este modelo detecta e extrai objetos de imagens. +- **Processamento de Formulários**: Este modelo extrai informações de formulários. +- **Processamento de Faturas**: Este modelo extrai informações de faturas. + +Com Modelos de IA Personalizados, você pode trazer seu próprio modelo para o AI Builder, permitindo que ele funcione como qualquer modelo personalizado do AI Builder, permitindo que você treine o modelo usando seus próprios dados. Você pode usar esses modelos para automatizar processos e prever resultados tanto no Power Apps quanto no Power Automate. Ao usar seu próprio modelo, existem limitações que se aplicam. Leia mais sobre essas [limitações](https://learn.microsoft.com/ai-builder/byo-model#limitations?WT.mc_id=academic-105485-koreyst). + +![Modelos do AI Builder](../../images/ai-builder-models.png?WT.mc_id=academic-105485-koreyst) + +## Tarefa #2 - Criar um Fluxo de Processamento de Faturas para Nossa Startup + +A equipe financeira tem tido dificuldades para processar faturas. Eles têm usado uma planilha para rastrear as faturas, mas isso tem se tornado difícil de gerenciar à medida que o número de faturas aumentou. Eles pediram a você que construa um fluxo que os ajudará a processar faturas usando IA. O fluxo deve permitir que eles extraiam informações das faturas e armazenem as informações em uma tabela do Dataverse. O fluxo também deve permitir que eles enviem um e-mail à equipe financeira com as informações extraídas. + +Agora que você sabe o que é o AI Builder e por que deve usá-lo, vamos ver como você pode usar o Modelo de IA de Processamento de Faturas no AI Builder, que cobrimos anteriormente, para criar um fluxo que ajudará a equipe financeira a processar faturas. + +Para criar um fluxo que ajudará a equipe financeira a processar faturas usando o Modelo de IA de Processamento de Faturas no AI Builder, siga as etapas abaixo: + +1. Acesse a [tela inicial do Power Automate](https://make.powerautomate.com?WT.mc_id=academic-105485-koreyst). + +2. Use a área de texto na tela inicial para descrever o fluxo que você deseja criar. Por exemplo, ***Processar uma fatura quando ela chegar à minha caixa de correio***. Clique no botão **Enviar** para enviar o comando ao AI Copilot. + + ![Copilot power automate](../../images/copilot-chat-prompt-powerautomate.png?WT.mc_id=academic-105485-koreyst) + +3. O AI Copilot sugerirá as ações que você precisa realizar para a tarefa que deseja automatizar. Você pode clicar no botão **Próximo** para passar para as próximas etapas. + +4. Na próxima etapa, o Power Automate solicitará que você configure as conexões necessárias para o fluxo. Quando terminar, clique no botão **Criar fluxo** para criar o fluxo. + +5. O AI Copilot gerará um fluxo e você poderá personalizá-lo para atender às suas necessidades. + +6. Atualize o acionador do fluxo e defina a **Pasta** para a pasta onde as faturas serão armazenadas. Por exemplo, você pode definir a pasta como **Caixa de entrada**. Clique em **Mostrar opções avançadas** e defina **Apenas com Anexos** como **Sim**. Isso garantirá que o fluxo só seja executado quando um e-mail com um anexo for recebido na pasta. + +7. Remova as seguintes ações do fluxo: **HTML para texto**, **Compor**, **Compor 2**, **Compor 3** e **Compor 4**, pois você não as usará. + +8. Remova a ação **Condição** do fluxo, pois você não a usará. Deve se parecer com a captura de tela a seguir: + + ![Power Automate, remover ações](../../images/powerautomate-remove-actions.png?WT.mc_id=academic-105485-koreyst) + +9. Clique no botão **Adicionar uma ação** e pesquise por **Dataverse**. Selecione a ação **Adicionar uma nova linha**. + +10. Na ação **Extrair informações das faturas**, atualize o **Arquivo da Fatura** para apontar para o **Conteúdo do Anexo** do e-mail. Isso garantirá que o fluxo extraia informações do anexo da fatura. + +11. Selecione a **Tabela** que você criou anteriormente. Por exemplo, você pode selecionar a tabela **Informações da Fatura**. Escolha o conteúdo dinâmico da ação anterior para preencher os seguintes campos: + + - ID + - Valor + - Data + - Nome + - Status - Defina o **Status** como **Pendente**. + - E-mail do Fornecedor - Use o conteúdo dinâmico do **Quando um novo e-mail chega** para o gatilho. + + ![Power Automate, adicionar linha](../../images/powerautomate-add-row.png?WT.mc_id=academic-105485-koreyst) + +12. Quando terminar o fluxo, clique no botão **Salvar** para salvar o fluxo. Você pode testar o fluxo enviando um e-mail com uma fatura para a pasta que você especificou no gatilho. + +> **Dever de casa**: O fluxo que você acabou de criar é um bom começo. Agora, você precisa pensar em como pode criar uma automação que permitirá que nossa equipe financeira envie um e-mail ao fornecedor para atualizá-lo com o status atual de sua fatura. Sua dica: o fluxo deve ser executado quando o status da fatura mudar. + +## Utilize um Modelo de IA de Geração de Texto no Power Automate + +O Modelo de IA Criar Texto com GPT no AI Builder permite que você gere texto com base em um prompt e é alimentado pelo Serviço Microsoft Azure OpenAI. Com essa capacidade, você pode incorporar a tecnologia GPT (Generative Pre-Trained Transformer) em seus aplicativos e fluxos para criar uma variedade de fluxos automatizados e aplicativos perspicazes. + +Os modelos GPT passam por treinamento extensivo em grandes quantidades de dados, permitindo que eles produzam texto que se assemelha de perto à linguagem humana quando fornecidos com um prompt. Quando integrados à automação de fluxo de trabalho, modelos de IA como o GPT podem ser aproveitados para simplificar e automatizar uma ampla variedade de tarefas. + +Por exemplo, você pode criar fluxos para gerar automaticamente texto para uma variedade de casos de uso, como rascunhos de e-mails, descrições de produtos e muito mais. Você também pode usar o modelo para gerar texto para vários aplicativos, como chatbots e aplicativos de atendimento ao cliente que permitem que os agentes de atendimento ao cliente respondam de forma eficaz e eficiente às perguntas dos clientes. + +![create a prompt](../../images/create-prompt-gpt.png?WT.mc_id=academic-105485-koreyst) + +Para aprender a usar este modelo de IA no Power Automate, passe pelo módulo [Adicionar inteligência com o AI Builder e GPT](https://learn.microsoft.com/training/modules/ai-builder-text-generation/?WT.mc_id=academic-109639-somelezediko). + +## Excelente trabalho! Vamos continuar com o Apredizado! + +Após concluir esta lição, confira nossa [coleção de aprendizado de IA generativa](https://aka.ms/genai-collection?WT.mc_id=academic-105485-koreyst) para continuar a aprimorar seu conhecimento em IA generativa! + +Vamos avançar para a Lição 11, onde veremos como [Integrando a IA generativa com chamada de função](../../../11-integrating-with-function-calling/transaltions/pt-br/README.md?WT.mc_id=academic-105485-koreyst)! diff --git a/11-integrating-with-function-calling/transaltions/pt-br/README.md b/11-integrating-with-function-calling/transaltions/pt-br/README.md new file mode 100644 index 000000000..7943cd82c --- /dev/null +++ b/11-integrating-with-function-calling/transaltions/pt-br/README.md @@ -0,0 +1,453 @@ +# Integrando com chamadas de função + +![chapter image](../../images/11-lesson-banner.png?WT.mc_id=academic-105485-koreyst) + +Você aprendeu bastante até agora nas lições anteriores. No entanto, podemos melhorar ainda mais. Algumas coisas que podemos abordar são como podemos obter um formato de resposta mais consistente para facilitar o trabalho com a resposta a jusante. Além disso, podemos querer adicionar dados de outras fontes para enriquecer ainda mais nossa aplicação. + +Os problemas mencionados acima são o que este capítulo pretende abordar. + +> **Vídeo em Breve** + +## Introdução + +Esta lição abordará: + +- Explicará o que é a chamada de função e seus casos de uso. +- Criar uma chamada de função usando o Azure OpenAI. +- Como integrar uma chamada de função em um aplicativo. + +## Metas de Aprendizado + +Após concluir esta lição, você será capaz de: + +- Explicar o propósito de usar chamadas de função. +- Configurar a Chamada de Função usando o Serviço Azure Open AI. +- Projetar chamadas de função eficazes para o caso de uso do seu aplicativo. + +## Cenário: melhorando nosso chatbot com funções + +Para esta lição, queremos criar um recurso para nossa startup de educação que permite aos usuários usar um chatbot para encontrar cursos técnicos. Vamos recomendar cursos que se encaixem no nível de habilidade deles, função atual e tecnologia de interesse. + +Para completar este cenário, usaremos uma combinação de: + +- `Azure Open AI` para criar uma experiência de chat para o usuário. +- `Microsoft Learn Catalog API` para ajudar os usuários a encontrar cursos com base na solicitação do usuário. +- `Chamada de Função` para pegar a consulta do usuário e enviá-la a uma função para fazer a solicitação à API. + +Para começar, vamos ver por que queremos usar chamada de função em primeiro lugar: + +## Por que a Chamada de Função + +Antes da chamada de função, as respostas de um LLM eram desestruturadas e inconsistentes. Os desenvolvedores eram obrigados a escrever código de validação complexo para garantir que pudessem lidar com cada variação de uma resposta. Os usuários não podiam obter respostas como "Qual é a temperatura atual em Estocolmo?". Isso ocorre porque os modelos eram limitados ao tempo em que os dados foram treinados. + +A Chamada de Função é um recurso do Serviço Azure Open AI para superar as seguintes limitações: + +- **Formato de resposta consistente**. Se pudermos controlar melhor o formato da resposta, podemos integrar mais facilmente a resposta a jusante em outros sistemas. +- **Dados externos**. Capacidade de usar dados de outras fontes de um aplicativo em um contexto de chat. + +## Ilustrando o problema por meio de um cenário + +> Recomendamos que você crie um arquivo *Notebook.ipynb* e cole o código abaixo em células de código separadas se quiser executar o cenário abaixo. Você também pode apenas ler enquanto tentamos ilustrar um problema em que as funções podem ajudar a resolver o problema. + +Vamos dar uma olhada no exemplo que ilustra o problema do formato de resposta: + +Digamos que queremos criar um banco de dados de dados de estudantes para que possamos sugerir o curso certo para eles. Abaixo temos duas descrições de estudantes que são muito semelhantes nos dados que contêm. + +1. Crie uma conexão com nosso recurso Azure Open AI: + + ```python + import os + import openai + import json + openai.api_type = "azure" + openai.api_base = "YOUR OPENAI API BASE URL" + openai.api_version = "2023-07-01-preview" + openai.api_key = os.getenv("OPENAI_API_KEY") + ``` + + Acima está algum código Python para configurar nossa conexão com o Azure Open AI, onde definimos `api_type`, `api_base`, `api_version` e `api_key`. + +1. Crie duas descrições de estudantes usando as variáveis `student_1_description` e `student_2_description`. + + ```python + 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." + ``` + + Nós queremos enviar as descrições de estudantes acima para um LLM para analisar os dados. Esses dados podem ser usados posteriormente em nosso aplicativo e enviados para uma API ou armazenados em um banco de dados. + +1. Vamos criar duas solicitações idênticas nas quais instruímos o LLM sobre as informações que nos interessam: + + ```python + 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} + ''' + ``` + + O prompt acima instrui o LLM a extrair informações e retornar a resposta no formato JSON. + +1. Após configurar os prompts e a conexão com o Azure Open AI, agora enviaremos os prompts para o LLM usando `openai.ChatCompletion`. Armazenamos o prompt na variável `messages` e atribuímos a função `user`. Isso é para imitar uma mensagem de um usuário sendo escrita em um chatbot. + + ```python + # response from prompt one + openai_response1 = openai.ChatCompletion.create( + engine="gpt-function", + messages = [{'role': 'user', 'content': prompt1}] + ) + openai_response1['choices'][0]['message']['content'] + + # response from prompt two + openai_response2 = openai.ChatCompletion.create( + engine="gpt-function", + messages = [{'role': 'user', 'content': prompt2 }] + ) + openai_response2['choices'][0]['message']['content'] + ``` + +Agora nós podemos enviar ambas as solicitações para o LLM e examinar a resposta que recebemos encontrando-a assim `openai_response1['choices'][0]['message']['content']`. + +1. Por fim, podemos converter a resposta para o formato JSON chamando `json.loads`: + + ```python + # Loading the response as a JSON object + json_response1 = json.loads(openai_response1['choices'][0]['message']['content']) + json_response1 + ``` + + Resposta 1: + + ```json + {'name': 'Emily Johnson', + 'major': 'computer science', + 'school': 'Duke University', + 'grades': '3.7', + 'club': 'Chess Club'} + ``` + + Resposta 2: + + ```json + {'name': 'Michael Lee', + 'major': 'computer science', + 'school': 'Stanford University', + 'grades': '3.8 GPA', + 'club': 'Robotics Club'} + ``` + + Embora os prompts sejam os mesmos e as descrições sejam semelhantes, vemos que os valores da propriedade `Grades` são formatados de maneira diferente, como `3.7` ou `3.7 GPA`, por exemplo. + + Isso ocorre porque o LLM recebe dados não estruturados na forma do prompt escrito e também retorna dados não estruturados. Precisamos ter um formato estruturado para saber o que esperar ao armazenar ou usar esses dados. + +Então, como resolvemos o problema de formatação? Ao usar chamadas de função, podemos garantir que recebemos dados estruturados de volta. Ao usar chamadas de função, o LLM na verdade não chama ou executa funções. Em vez disso, criamos uma estrutura para o LLM seguir para suas respostas. Em seguida, usamos essas respostas estruturadas para saber qual função executar em nossos aplicativos. + +![fluxo de função](../../images/Function-Flow.png?WT.mc_id=academic-105485-koreyst) + +Podemos então pegar o que é retornado da função e enviar isso de volta ao LLM. O LLM responderá usando linguagem natural para responder à consulta do usuário. + +## Casos de uso para chamadas de função + +Existem muitos casos de uso diferentes em que chamadas de função podem aprimorar seu aplicativo, como: + +- **Chamando Ferramentas Externas**. Chatbots são ótimos para fornecer respostas a perguntas dos usuários. Ao usar chamadas de função, os chatbots podem usar mensagens dos usuários para concluir determinadas tarefas. Por exemplo, um aluno pode pedir ao chatbot para "Enviar e-mail ao meu instrutor dizendo que preciso de mais ajuda com este assunto". Isso pode fazer uma chamada de função para `send_email(to: string, body: string)`. + +- **Criando Consultas de API ou Banco de Dados**. Os usuários podem encontrar informações usando linguagem natural que é convertida em uma consulta ou solicitação de API formatada. Um exemplo disso pode ser um professor que solicita "Quais são os alunos que concluíram a última tarefa", o que poderia chamar uma função chamada `get_completed(student_name: string, assignment: int, current_status: string)`. + +- **Criando Dados Estruturados**. Os usuários podem pegar um bloco de texto ou CSV e usar o LLM para extrair informações importantes. Por exemplo, um aluno pode converter um artigo da Wikipedia sobre acordos de paz para criar cartões de memória de IA. Isso pode ser feito usando uma função chamada `get_important_facts(agreement_name: string, date_signed: string, parties_involved: list)`. + +## Criando Sua Primeira Chamada de Função + +O processo de criar uma chamada de função inclui 3 etapas principais: + +1. **Chamando** a API de Completions de Chat com uma lista de suas funções e uma mensagem do usuário. +2. **Lendo** a resposta do modelo para realizar uma ação, ou seja, executar uma função ou chamada de API. +3. **Fazendo** outra chamada para a API de Completions de Chat com a resposta de sua função para usar essas informações e criar uma resposta para o usuário. + +![Fluxo LLM](../../images/LLM-Flow.png?WT.mc_id=academic-105485-koreyst) + +### Etapa 1 - criando mensagens + +A primeira etapa é criar uma mensagem do usuário. Isso pode ser atribuído dinamicamente, pegando o valor de uma entrada de texto, ou você pode atribuir um valor aqui. Se esta é a sua primeira vez trabalhando com a API de Completions de Chat, precisamos definir o `role` e o `content` da mensagem. + +O `role` pode ser `system` (criando regras), `assistant` (o modelo) ou `user` (o usuário final). Para chamadas de função, vamos atribuir isso como `user` e uma pergunta de exemplo. + +```python +messages= [ {"role": "user", "content": "Find me a good course for a beginner student to learn Azure."} ] +``` + +Ao atribuir diferentes papéis, fica claro para o LLM se é o sistema dizendo algo ou o usuário, o que ajuda a criar um histórico de conversação no qual o LLM pode se basear. + +### Etapa 2 - criando funções + +Em seguida, definiremos uma função e os parâmetros dessa função. Usaremos apenas uma função aqui chamada `search_courses`, mas você pode criar várias funções. + +> **Importante**: As funções são incluídas na mensagem do sistema para o LLM e serão contadas na quantidade de tokens disponíveis. + +Abaixo, criamos as funções como uma matriz de itens. Cada item é uma função e tem propriedades `name`, `description` e `parameters`: + +```python +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" + ] + } + } +] +``` + +Vamos descrever cada instância de função mais detalhadamente abaixo: + +- `name` - O nome da função que queremos que seja chamada. +- `description` - Esta é a descrição de como a função funciona. Aqui é importante ser específico e claro. +- `parameters` - Uma lista de valores e formatos que você deseja que o modelo produza em sua resposta. A matriz de parâmetros consiste em itens, onde cada item tem as seguintes propriedades: + 1. `type` - O tipo de dados no qual as propriedades serão armazenadas. + 1. `properties` - Lista dos valores específicos que o modelo usará para sua resposta + 1. `name` - A chave é o nome da propriedade que o modelo usará em sua resposta formatada, por exemplo, `product`. + 1. `type` - O tipo de dados desta propriedade, por exemplo, `string`. + 1. `description` - Descrição da propriedade específica. + +Há também uma propriedade opcional `required` - propriedade necessária para que a chamada da função seja concluída. + +### Etapa 3 - Fazendo a chamada da função + +Depois de definir uma função, agora precisamos incluí-la na chamada à API de Completção de Bate-papo. Fazemos isso adicionando `functions` à solicitação. Neste caso, `functions=functions`. + +Também há a opção de definir `function_call` como `auto`. Isso significa que vamos deixar o LLM decidir qual função deve ser chamada com base na mensagem do usuário, em vez de atribuirmos. + +Aqui está algum código abaixo onde chamamos `ChatCompletion.create`, observe como definimos `functions=functions` e `function_call="auto"`, dando assim ao LLM a escolha de quando chamar as funções que fornecemos: + +```python +response = openai.ChatCompletion.create( engine="gpt-function", + messages=messages, + functions=functions, + function_call="auto", ) + +print(response['choices'][0]['message']) +``` + +The response coming back now looks like so: + +```json +{ + "role": "assistant", + "function_call": { + "name": "search_courses", + "arguments": "{\n \"role\": \"student\",\n \"product\": \"Azure\",\n \"level\": \"beginner\"\n}" + } +} +``` + +Aqui nós podemos ver como a função `search_courses` foi chamada e com quais argumentos, conforme listado na propriedade `arguments` na resposta JSON. + +A conclusão de que o LLM foi capaz de encontrar os dados para se encaixar nos argumentos da função, pois estava extraindo-o do valor fornecido ao parâmetro `messages` na chamada de conclusão do chat. Abaixo está um lembrete do valor `messages`: + +```python +messages= [ {"role": "user", "content": "Find me a good course for a beginner student to learn Azure."} ] +``` + +Como você pode ver, `student`, `Azure` e `beginner` foram extraídos de `messages` e definidos como entrada para a função. Usar funções dessa maneira é uma ótima maneira de extrair informações de um prompt, mas também de fornecer estrutura ao LLM e ter funcionalidade reutilizável. + +Agora, precisamos ver como podemos usar isso em nosso aplicativo. + +## Integrando Chamadas de Função em um Aplicativo + +Após testarmos a resposta formatada do LLM, agora podemos integrá-la a um aplicativo. + +### Gerenciando o fluxo + +Para integrar isso ao nosso aplicativo, siga estas etapas: + +1. First, let's make the call to the Open AI services and store the message in a variable called `response_message`. + +1. Primeiro, vamos fazer a chamada aos serviços Open AI e armazenar a mensagem em uma variável chamada `response_message`. + + ```python + response_message = response["choices"][0]["message"] + ``` + +1. Agora vamos definir a função que chamará a API Microsoft Learn para obter uma lista de cursos: + + ```python + 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) + ``` + + Observe como agora criamos uma função Python real que mapeia para os nomes de função introduzidos na variável `functions`. Também estamos fazendo chamadas reais de API externa para buscar os dados de que precisamos. Neste caso, vamos contra a API Microsoft Learn para pesquisar módulos de treinamento. + + Ok! Então criamos variáveis `functions` e uma função Python correspondente, como dizemos ao LLM como mapear essas duas coisas para que nossa função Python seja chamada? + +1. Para ver se precisamos chamar uma função Python, precisamos olhar para a resposta LLM e ver se `function_call` faz parte dela e chamar a função apontada. Veja como você pode fazer a verificação mencionada abaixo: + + ```python + # Check if the model wants to call a function + if response_message.get("function_call"): + print("Recommended Function call:") + print(response_message.get("function_call")) + 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, + } + ) + ``` + + Essas três linhas garantem que extraímos o nome da função, os argumentos e fazemos a chamada: + + ```python + function_to_call = available_functions[function_name] + + function_args = json.loads(response_message["function_call"]["arguments"]) + function_response = function_to_call(**function_args) + ``` + + Acima está a saída da execução do nosso código: + + **Saída** + + ```Recommended Function call: + { + "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'}] + + ``` + +1. Agora enviaremos a mensagem atualizada, `messages` para o LLM para que possamos receber uma resposta em linguagem natural em vez de uma resposta formatada em JSON da API. + + ```python + print("Messages in next request:") + print(messages) + print() + + second_response = openai.ChatCompletion.create( + messages=messages, + engine="gpt-function", + 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"]) + ``` + + **Saída** + + ```python + { + "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." + } + + ``` + +## Tarefa + +Para continuar seu aprendizado sobre a Chamada de Função do Azure Open AI, você pode: + +- Adicionar mais parâmetros à função que podem ajudar os aprendizes a encontrar mais cursos. +- Criar outra chamada de função que obtenha mais informações do aprendiz, como o idioma nativo. +- Implementar tratamento de erro quando a chamada de função e/ou a chamada da API não retornar cursos adequados. + +Dica: Consulte a [documentação de referência da API Learn](https://learn.microsoft.com/training/support/catalog-api-developer-reference?WT.mc_id=academic-105485-koreyst) para ver como e onde esses dados estão disponíveis. + +## Ótimo trabalho! Continue a jornada + +Após completar esta lição, confira nossa [coleção de aprendizado sobre IA Generativa](https://aka.ms/genai-collection?WT.mc_id=academic-105485-koreyst) para continuar a aprimorar seus conhecimentos em IA Generativa! + +Vá para a Lição 12, onde veremos como [Projetando UX para aplicativos de IA](../../../12-designing-ux-for-ai-applications/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst)! diff --git a/12-designing-ux-for-ai-applications/translations/pt-br/README.md b/12-designing-ux-for-ai-applications/translations/pt-br/README.md new file mode 100644 index 000000000..ebe8f450f --- /dev/null +++ b/12-designing-ux-for-ai-applications/translations/pt-br/README.md @@ -0,0 +1,122 @@ +# Projetando UX para aplicativos de IA + +[![Designing UX for AI Applications](../../images/12-lesson-banner.png?WT.mc_id=academic-105485-koreyst)](https://youtu.be/bO7h2_hOhR0?WT.mc_id=academic-105485-koreyst) + +> *(Clique na imagem acima para assistir ao vídeo desta lição)* + +A experiência do usuário é um aspecto muito importante na criação de aplicativos. Os usuários precisam poder usar seu aplicativo de maneira eficiente para realizar tarefas. Ser eficiente é uma coisa, mas você também precisa projetar aplicativos para que possam ser usados por todos, tornando-os *acessíveis*. Este capítulo se concentrará nessa área para que você termine projetando um aplicativo que as pessoas possam e queiram usar. + +## Introdução + +A experiência do usuário é como um usuário interage e utiliza um produto ou serviço específico, seja um sistema, ferramenta ou design. Ao desenvolver aplicativos de IA, os desenvolvedores não apenas se concentram em garantir que a experiência do usuário seja eficaz, mas também ética. Nesta lição, abordamos como construir aplicativos de Inteligência Artificial (IA) que atendem às necessidades do usuário. + +A lição abordará as seguintes áreas: + +* Introdução à Experiência do Usuário e Compreensão das Necessidades do Usuário +* Projeto de Aplicações de IA para Confiança e Transparência +* Projeto de Aplicações de IA para Colaboração e Feedback + +## Metas de Aprendizado + +Após esta lição, você será capaz de: + +* Compreender como construir aplicativos de IA que atendam às necessidades do usuário. +* Projetar aplicativos de IA que promovam confiança e colaboração. + +### Pré-requisito + +Dedique um tempo para ler mais sobre [experiência do usuário e design thinking.](https://learn.microsoft.com/training/modules/ux-design?WT.mc_id=academic-105485-koreyst) + +## Introdução à Experiência do Usuário e Compreensão das Necessidades do Usuário + +Em nossa fictícia startup de educação, temos dois usuários principais, professores e alunos. Cada um dos dois usuários tem necessidades únicas. Um design centrado no usuário prioriza o usuário, garantindo que os produtos sejam relevantes e benéficos para quem se destina. + +A aplicação deve ser **útil, confiável, acessível e agradável** para proporcionar uma boa experiência do usuário. + +### Usabilidade + +Ser útil significa que a aplicação possui funcionalidades que correspondem ao seu propósito, como automatizar o processo de avaliação ou gerar flashcards para revisão. Uma aplicação que automatiza o processo de avaliação deve ser capaz de atribuir notas com precisão e eficiência ao trabalho dos alunos com base em critérios predefinidos. Da mesma forma, uma aplicação que gera flashcards de revisão deve ser capaz de criar perguntas relevantes e diversas com base em seus dados. + +### Confiabilidade + +Ser confiável significa que a aplicação pode realizar sua tarefa de forma consistente e sem erros. No entanto, a IA, assim como os humanos, não é perfeita e pode estar sujeita a erros. As aplicações podem encontrar erros ou situações inesperadas que exigem intervenção ou correção humana. Como lidar com erros? Na última seção desta lição, abordaremos como os sistemas e aplicações de IA são projetados para colaboração e feedback. + +### Acessibilidade + +Ser acessível significa estender a experiência do usuário a usuários com várias habilidades, incluindo aqueles com deficiências, garantindo que ninguém seja deixado de fora. Seguindo diretrizes e princípios de acessibilidade, as soluções de IA se tornam mais inclusivas, utilizáveis e benéficas para todos os usuários. + +### Agradável + +Ser agradável significa que a aplicação é agradável de usar. Uma experiência do usuário atraente pode ter um impacto positivo no usuário, incentivando-os a retornar à aplicação e aumentando a receita do negócio. + +![imagem ilustrando considerações de UX em IA](../../images/uxinai.png?WT.mc_id=academic-105485-koreyst) + +Nem todo desafio pode ser resolvido com IA. A IA entra para aprimorar sua experiência do usuário, seja automatizando tarefas manuais ou personalizando experiências do usuário. + +# Projetando Aplicações de IA para Confiança e Transparência + +Criar confiança é crucial ao projetar aplicações de IA. A confiança garante que o usuário tenha confiança de que o aplicativo concluirá o trabalho, entregará resultados consistentes e que os resultados são o que o usuário precisa. Um risco nessa área é a desconfiança e a confiança excessiva. A desconfiança ocorre quando um usuário tem pouca ou nenhuma confiança em um sistema de IA, o que leva o usuário a rejeitar seu aplicativo. A confiança excessiva ocorre quando um usuário superestima a capacidade de um sistema de IA, levando os usuários a confiarem demais no sistema de IA. Por exemplo, um sistema de avaliação automatizada, no caso de confiança excessiva, pode levar o professor a não revisar alguns trabalhos para garantir que o sistema de avaliação funcione bem. Isso poderia resultar em notas injustas ou imprecisas para os alunos, ou oportunidades perdidas de feedback e melhoria. + +Duas maneiras de garantir que a confiança esteja no centro do design são explicabilidade e controle. + +### Explicabilidade + +Quando a IA ajuda a informar decisões, como transmitir conhecimento às futuras gerações, é fundamental que professores e pais entendam como as decisões da IA são tomadas. Isso é explicabilidade - entender como as aplicações de IA tomam decisões. Projetar para explicabilidade inclui adicionar detalhes de exemplos do que uma aplicação de IA pode fazer. Por exemplo, em vez de "Comece com o professor de IA", o sistema pode usar: "Resuma suas anotações para uma revisão mais fácil usando a IA." + +![uma página inicial do aplicativo com uma ilustração clara da explicabilidade em aplicações de IA](../../images/explanability-in-ai.png?WT.mc_id=academic-105485-koreyst) + +Outro exemplo é como a IA usa dados pessoais do usuário. Por exemplo, um usuário com a persona "aluno" pode ter limitações com base em sua persona. A IA pode não ser capaz de revelar respostas a perguntas, mas pode ajudar o usuário a pensar em como resolver um problema. + +![IA respondendo a perguntas com base na persona](../../images/solving-questions.png?WT.mc_id=academic-105485-koreyst) + +A última parte importante da explicabilidade é a simplificação das explicações. Alunos e professores podem não ser especialistas em IA, portanto, as explicações do que a aplicação pode ou não pode fazer devem ser simplificadas e fáceis de entender. + +![explicações simplificadas sobre as capacidades da IA](../../images/simplified-explanations.png?WT.mc_id=academic-105485-koreyst) + +### Controle + +A IA generativa cria uma colaboração entre a IA e o usuário, onde, por exemplo, um usuário pode modificar prompts para obter resultados diferentes. Além disso, uma vez que uma saída é gerada, os usuários devem poder modificar os resultados, dando-lhes uma sensação de controle. Por exemplo, ao usar o Bing, você pode personalizar seu prompt com base no formato, tom e comprimento. Além disso, você pode fazer alterações em sua saída e modificar o resultado, conforme mostrado abaixo: + +![resultados da pesquisa no Bing com opções para modificar o prompt e a saída](../../images/bing1.png?WT.mc_id=academic-105485-koreyst "Resultados da pesquisa no Bing com opções para modificar o prompt e a saída") + +Outro recurso no Bing que permite ao usuário ter controle sobre o aplicativo é a capacidade de escolher participar ou sair dos dados que a IA usa. Para um aplicativo escolar, um aluno pode querer usar suas anotações, bem como os recursos dos professores como material de revisão. + +![resultados da pesquisa no Bing com opções para modificar o prompt e a saída](../../images/bing2.png?WT.mc_id=academic-105485-koreyst "Resultados da pesquisa no Bing com opções para modificar o prompt e a saída") + +> Ao projetar aplicações de IA, a intencionalidade é fundamental para garantir que os usuários não confiem demais, estabelecendo expectativas irreais de suas capacidades. Uma maneira de fazer isso é criar atrito entre os prompts e os resultados, lembrando ao usuário que isso é IA e não um ser humano colega. + +# Projetando Aplicações de IA para Colaboração e Feedback + +Como mencionado anteriormente, a IA generativa cria uma colaboração entre o usuário e a IA. A maioria das interações envolve um usuário inserindo um prompt e a IA gerando uma saída. E se a saída estiver incorreta? Como o aplicativo lida com erros, se ocorrerem? A IA culpa o usuário ou se dá ao trabalho de explicar o erro? + +As aplicações de IA devem ser construídas para receber e fornecer feedback. Isso não apenas ajuda o sistema de IA a melhorar, mas também constrói confiança com os usuários. Um ciclo de feedback deve ser incluído no design, um exemplo pode ser um simples polegar para cima ou para baixo na saída. + +Outra maneira de lidar com isso é comunicar claramente as capacidades e limitações do sistema. Quando um usuário comete um erro solicitando algo além das capacidades da IA, também deve haver uma maneira de lidar com isso, como mostrado abaixo. + +![Dar feedback e lidar com erros](../../images/feedback-loops.png?WT.mc_id=academic-105485-koreyst) + +Erros do sistema são comuns em aplicativos nos quais o usuário pode precisar de assistência com informações fora do escopo da IA ou o aplicativo pode ter um limite de quantas perguntas/assuntos um usuário pode gerar resumos. Por exemplo, um aplicativo de IA treinado com dados em assuntos limitados, como História e Matemática, pode não conseguir lidar com perguntas sobre Geografia. Para mitigar isso, o sistema de IA pode dar uma resposta como: "Desculpe, nosso produto foi treinado com dados nos seguintes assuntos..., não consigo responder à pergunta que você fez." + +As aplicações de IA não são perfeitas, portanto, estão sujeitas a cometer erros. Ao projetar suas aplicações, certifique-se de criar espaço para feedback dos usuários e tratamento de erros de maneira simples e facilmente explicável. + +## Tarefa + +# Implementando Melhorias na sua Aplicação de IA + +Ao considerar a implementação dos passos abaixo na sua aplicação de IA, você pode aprimorar a experiência do usuário: + +- **Agradável:** Pense em como tornar sua aplicação mais agradável. Você está adicionando explicações em todos os lugares? Está incentivando o usuário a explorar? Como você está redigindo suas mensagens de erro? + +- **Usabilidade:** Se estiver construindo um aplicativo web, certifique-se de que ele seja navegável tanto pelo mouse quanto pelo teclado. + +- **Confiança e Transparência:** Não confie completamente na saída da IA. Considere como adicionar um ser humano ao processo para verificar a saída. Além disso, pense e implemente outras maneiras de alcançar confiança e transparência. + +- **Controle:** Dê ao usuário controle sobre os dados que fornecem à aplicação. Implemente uma maneira de o usuário consentir ou recusar a coleta de dados na aplicação de IA. + + + +## Parabéns! Você concluiu este curso + +Após concluir esta lição, confira nossa [coleção de aprendizado de IA generativa](https://aka.ms/genai-collection?WT.mc_id=academic-105485-koreyst) para continuar a aprimorar seus conhecimentos sobre IA generativa! + +Parabéns! Você concluiu este curso! A criação de aplicações em IA Generativa não deve parar por aqui. Esperançosamente, você foi inspirado a começar a criar sua própria startup de IA generativa. Vá para o [Microsoft Founders Hub](https://aka.ms/genai-foundershub?WT.mc_id=academic-105485-koreyst) e inscreva-se no programa para receber suporte em sua jornada. diff --git a/13-continued-learning/README.md b/13-continued-learning/README.md index 2b15ed3ce..e75e95685 100644 --- a/13-continued-learning/README.md +++ b/13-continued-learning/README.md @@ -48,7 +48,11 @@ After completing this course, check out our [Generative AI Learning collection]( ## Lesson 4 - Understanding Prompt Engineering Fundamentals -🔗 [Introduction to Prompt Engineering](https://learn.microsoft.com/azure/ai-services/openai/concepts/prompt-engineering?&WT.mc_id=academic-105485-koreyst) +🔗 [Getting Started with Azure OpenAI Services](https://https://learn.microsoft.com/training/modules/get-started-openai/?&WT.mc_id=academic-105485-koreyst) + +[Apply Prompt Engineering with Azure OpenAI services](https://learn.microsoft.com/training/modules/apply-prompt-engineering-azure-openai/?&WT.mc_id=academic-105485-koreyst) + +[Introduction to Prompt Engineering](https://learn.microsoft.com/azure/ai-services/openai/concepts/prompt-engineering?&WT.mc_id=academic-105485-koreyst) 🔗 [Prompt Engineering Overview](https://learn.microsoft.com/semantic-kernel/prompt-engineering/?WT.mc_id=academic-105485-koreyst) @@ -76,6 +80,9 @@ After completing this course, check out our [Generative AI Learning collection]( 🔗 [Fine-Tuning language models from human preferences](https://arxiv.org/pdf/1909.08593.pdf?wt.mc_id=github_S-1231_webpage_reactor) +🔗 [Build natural language solutions with Azure OpenAI Services](https://learn.microsoft.com/training/modules/build-language-solution-azure-openai/?WT.mc_id=academic-105485-koreyst) + + 🔗 [OpenAI Fine-Tuning](https://platform.openai.com/docs/guides/fine-tuning/when-to-use-fine-tuning?wt.mc_id=github_S-1231_webpage_reactor ) ## Lesson 8 - Building Search Applications @@ -99,6 +106,7 @@ After completing this course, check out our [Generative AI Learning collection]( 🔗 [OpenAI's CLIP paper](https://arxiv.org/pdf/2103.00020.pdf?WT.mc_id=academic-105485-koreyst) ## Lesson 10 - Building Low Code AI Applications +🔗 [Create bots with Microsoft Copilot Studio](https://learn.microsoft.com/training/paths/work-power-virtual-agents/?&WT.mc_id=academic-105485-koreyst) 🔗 [Add intelligence with AI Builder and GPT](https://learn.microsoft.com/training/modules/ai-builder-text-generation?&WT.mc_id=academic-105485-koreyst) diff --git a/13-continued-learning/translations/pt-br/README.md b/13-continued-learning/translations/pt-br/README.md new file mode 100644 index 000000000..db1ec8335 --- /dev/null +++ b/13-continued-learning/translations/pt-br/README.md @@ -0,0 +1,127 @@ +# Recursos Adicionais + +Aqui estão links para outros ótimos recursos para continuar sua aprendizagem e construção com IA Generativa. + +Se você estiver sentindo falta de algum recurso, nos avise enviando um PR! + +## 🧠 Uma Coleção para Dominar tudo sobre o tópico + +Após completar este curso, confira nossa [Coleção de Aprendizagem de IA Generativa](https://aka.ms/genai-collection?WT.mc_id=academic-105485-koreyst) para continuar a aprimorar seu conhecimento em IA Generativa! + +## Lição 1 - Introdução à IA Generativa e LLMs + +🔗 [How GPT models work: accessible to everyone](https://bea.stollnitz.com/blog/how-gpt-works/?WT.mc_id=academic-105485-koreyst) + +🔗 [Fundamentals of Generative AI](https://learn.microsoft.com/training/modules/fundamentals-generative-ai?&WT.mc_id=academic-105485-koreyst) + +🔗 [How GPT models work: accessible to everyone](https://bea.stollnitz.com/blog/how-gpt-works?WT.mc_id=academic-105485-koreyst) + +🔗 [Generative AI: Implication and Applications for Education](https://arxiv.org/abs/2305.07605?wt.mc_id=github_S-1231_webpage_reactor) + +## Lição 2 - Explorando e Comparando Diferentes Tipos de LLM + +🔗 [How to use Open Source foundation models curated by Azure Machine Learning (preview) - Azure Machine Learning | Microsoft Learn](https://learn.microsoft.com/azure/machine-learning/how-to-use-foundation-models?WT.mc_id=academic-105485-koreyst) + +🔗 [The Large Language Model (LLM) Index | Sapling](https://sapling.ai/llm/index?WT.mc_id=academic-105485-koreyst) + +🔗 [[2304.04052] Decoder-Only or Encoder-Decoder? Interpreting Language Model as a Regularized Encoder-Decoder (arxiv.org)](https://arxiv.org/abs/2304.04052?WT.mc_id=academic-105485-koreyst) + +🔗 [Retrieval Augmented Generation using Azure Machine Learning prompt flow](https://learn.microsoft.com/azure/machine-learning/concept-retrieval-augmented-generation?WT.mc_id=academic-105485-koreyst) + +🔗 [Grounding LLMs](https://techcommunity.microsoft.com/t5/fasttrack-for-azure/grounding-llms/ba-p/3843857?wt.mc_id=github_S-1231_webpage_reactor) + +🔗 [The Large Language Model (LLM) Index | Sapling](https://sapling.ai/llm/index?wt.mc_id=github_S-1231_webpage_reactor ) + +🔗 [[2304.04052] Decoder-Only or Encoder-Decoder? Interpreting Language Model as a Regularized Encoder-Decoder (arxiv.org)](https://arxiv.org/abs/2304.04052?wt.mc_id=github_S-1231_webpage_reactor) + +## Lição 3 - Usando a IA Generativa de forma Responsável + +🔗 [Fundamentals of Responsible Generative AI](https://learn.microsoft.com/training/modules/responsible-generative-ai/?&WT.mc_id=academic-105485-koreyst) + +🔗 [Grounding LLMs](https://techcommunity.microsoft.com/t5/fasttrack-for-azure/grounding-llms/ba-p/3843857?WT.mc_id=academic-105485-koreyst) + +🔗 [Fundamentals of Responsible Generative AI](https://learn.microsoft.com/training/modules/responsible-generative-ai?WT.mc_id=academic-105485-koreyst) + +🔗 [Being Responsible with Generative AI](https://learn.microsoft.com/shows/ai-show/being-responsible-with-generative-ai?WT.mc_id=academic-105485-koreyst) + +🔗 [GPT-4 System Card](https://cdn.openai.com/papers/gpt-4-system-card.pdf?wt.mc_id=github_S-1231_webpage_reactor) + +## Lição 4 - Entendendo os Fundamentos da Engenharia de Prompt + +🔗 [Introduction to Prompt Engineering](https://learn.microsoft.com/azure/ai-services/openai/concepts/prompt-engineering?&WT.mc_id=academic-105485-koreyst) + +🔗 [Prompt Engineering Overview](https://learn.microsoft.com/semantic-kernel/prompt-engineering/?WT.mc_id=academic-105485-koreyst) + +🔗 [Azure OpenAI for Education Prompts](https://techcommunity.microsoft.com/t5/education-blog/azure-openai-for-education-prompts-ai-and-a-guide-from-ethan-and/ba-p/3938259?wt.mc_id=github_S-1231_webpage_reactor ) + +🔗 [Introduction to Prompt Engineering](https://learn.microsoft.com/azure/ai-services/openai/concepts/prompt-engineering?WT.mc_id=academic-105485-koreyst) + +🔗 [Prompt Engineering Overview](https://learn.microsoft.com/semantic-kernel/prompt-engineering?WT.mc_id=academic-105485-koreyst) + +🔗 [Azure OpenAI for Education Prompts](https://techcommunity.microsoft.com/t5/e1.ucation-blog/azure-openai-for-education-prompts-ai-and-a-guide-from-ethan-and/ba-p/3938259?WT.mc_id=academic-105485-koreyst) + +## Lição 5 - Criando Prompts Avançados + +🔗 [Prompt Engineering Techniques](https://learn.microsoft.com/azure/ai-services/openai/concepts/advanced-prompt-engineering?WT.mc_id=academic-105485-koreyst) + +## Lição 6 - Criando Aplicações de Geração de Texto + +🔗 [Prompt Engineering Techniques](https://learn.microsoft.com/azure/ai-services/openai/concepts/advanced-prompt-engineering?pivots=programming-language-chat-completions&WT.mc_id=academic-105485-koreyst) + +## Lição 7 - Criando Aplicações de Chat + +🔗 [System message framework and template recommendations for Large Language Models (LLMs)](https://learn.microsoft.com/azure/ai-services/openai/concepts/system-message?WT.mc_id=academic-105485-koreyst) + +🔗 [Learn how to work with the GPT-35-Turbo and GPT-4 models](https://learn.microsoft.com/azure/ai-services/openai/how-to/chatgpt?&WT.mc_id=academic-105485-koreyst) + +🔗 [Fine-Tuning language models from human preferences](https://arxiv.org/pdf/1909.08593.pdf?wt.mc_id=github_S-1231_webpage_reactor) + +🔗 [OpenAI Fine-Tuning](https://platform.openai.com/docs/guides/fine-tuning/when-to-use-fine-tuning?wt.mc_id=github_S-1231_webpage_reactor ) + +## Lição 8 - Criando Aplicações de Busca + +🔗 [Azure Cognitive Search](https://learn.microsoft.com/training/modules/improve-search-results-vector-search?WT.mc_id=academic-105485-koreyst) + +🔗 [OpenAI Embedding API](https://platform.openai.com/docs/api-reference/embeddings?wt.mc_id=github_S-1231_webpage_reactor) + +🔗 [Cosine Similarity](https://en.wikipedia.org/wiki/Cosine_similarity?wt.mc_id=github_S-1231_webpage_reactor) + +## Lição 9 - Criando Aplicações de Geração de Imagens + +🔗 [Generate Images with Azure OpenAI Service](https://learn.microsoft.com/training/modules/generate-images-azure-openai?WT.mc_id=academic-105485-koreyst) + +🔗 [OpenAI's DALL-E and CLIP 101: A Brief Introduction](https://towardsdatascience.com/openais-dall-e-and-clip-101-a-brief-introduction-3a4367280d4e?wt.mc_id=github_S-1231_webpage_reactor) + +🔗 [OpenAI's CLIP paper](https://arxiv.org/pdf/2103.00020.pdf?wt.mc_id=github_S-1231_webpage_reactor) + +🔗 [OpenAI's DALL-E and CLIP 101: A Brief Introduction](https://towardsdatascience.com/openais-dall-e-and-clip-101-a-brief-introduction-3a4367280d4e?WT.mc_id=academic-105485-koreyst) + +🔗 [OpenAI's CLIP paper](https://arxiv.org/pdf/2103.00020.pdf?WT.mc_id=academic-105485-koreyst) + +## Lição 10 - Criando Aplicações com Low Code + +🔗 [Add intelligence with AI Builder and GPT](https://learn.microsoft.com/training/modules/ai-builder-text-generation?&WT.mc_id=academic-105485-koreyst) + +🔗 [Get Started with AI Builder](https://learn.microsoft.com/training/modules/get-started-with-ai-builder?WT.mc_id=academic-105485-koreyst) + +🔗 [Detect Objects with AI Builder](https://learn.microsoft.com/training/modules/get-started-with-ai-builder-object-detection?WT.mc_id=academic-105485-koreyst) + +🔗 [Build a canvas app solution with Copilot in Power Apps](https://learn.microsoft.com/training/modules/build-canvas-app-real-estate-power-apps-copilot/?WT.mc_id=academic-105485-koreyst) + +🔗 [Power Platform Copilot Prompt Library](https://pnp.github.io/powerplatform-prompts/?wt.mc_id=github_S-1231_webpage_reactor&WT.mc_id=academic-109639-somelezediko) + +## Lição 11 - Integrando Aplicações com Chamadas de Função + +🔗 [OpenAI Functions Documentation](https://learn.microsoft.com/azure/ai-services/openai/how-to/function-calling?WT.mc_id=academic-105485-koreyst) + +## Lição 12 - Projetando UX para Aplicações de IA + +🔗 [Best practices for building collaborative UX with Human-AI partnership](https://learn.microsoft.com/community/content/best-practices-ai-ux?WT.mc_id=academic-105485-koreyst) + +🔗 [Designing Human-Centric AI Experiences: Applied UX Design for Artificial Intelligence by Akshay Kpre](https://www.linkedin.com/learning/ux-for-ai-design-practices-for-ai-developers?wt.mc_id=github_S-1231_webpage_reactor) + +🔗 [UX for AI: Design Practices for AI Developers](https://www.youtube.com/watch?wt.mc_id=github_S-1231_webpage_reactor&v=Lkbkd_hkDLY) + +🔗 [New skills in the age of AI by John Maeda](https://www.amazon.com/Designing-Human-Centric-Experiences-Artificial-Intelligence/dp/1484280873?wt.mc_id=github_S-1231_webpage_reactor) + +🔗 [Designing Human-Centric AI Experiences: Applied UX Design for Artificial Intelligence by Akshay Kpre](https://www.amazon.com/Designing-Human-Centric-Experiences-Artificial-Intelligence/dp/1484280873?WT.mc_id=academic-105485-koreyst) diff --git a/docs/.nojekyll b/docs/.nojekyll new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/docs/.nojekyll @@ -0,0 +1 @@ + diff --git a/docs/_navbar.md b/docs/_navbar.md new file mode 100644 index 000000000..20ed5d926 --- /dev/null +++ b/docs/_navbar.md @@ -0,0 +1,6 @@ + + +* Select Language + + * [English](/) + * [Chinese](/translation/cn/) diff --git a/index.html b/index.html index 6009dd7c9..d3799ee2c 100644 --- a/index.html +++ b/index.html @@ -23,6 +23,7 @@ repo: 'https://github.com/Microsoft/generative-ai-for-beginners', relativePath: true, auto2top: true, + loadNavbar: 'docs/_navbar.md', } diff --git a/translation/pt-br/README.md b/translation/pt-br/README.md new file mode 100644 index 000000000..bb0fd5732 --- /dev/null +++ b/translation/pt-br/README.md @@ -0,0 +1,100 @@ + +![Generative AI For Beginners](../../images/repository-thumbnail.png?WT.mc_id=academic-105485-koreyst) + +### Um curso com 12 lições que ensina tudo o que você precisa saber para começar a criar aplicações de IA Generativa + +[![GitHub license](https://img.shields.io/github/license/microsoft/Generative-AI-For-Beginners.svg)](https://github.com/microsoft/Generative-AI-For-Beginners/blob/master/LICENSE?WT.mc_id=academic-105485-koreyst) +[![GitHub contributors](https://img.shields.io/github/contributors/microsoft/Generative-AI-For-Beginners.svg)](https://GitHub.com/microsoft/Generative-AI-For-Beginners/graphs/contributors/?WT.mc_id=academic-105485-koreyst) +[![GitHub issues](https://img.shields.io/github/issues/microsoft/Generative-AI-For-Beginners.svg)](https://GitHub.com/microsoft/Generative-AI-For-Beginners/issues/?WT.mc_id=academic-105485-koreyst) +[![GitHub pull-requests](https://img.shields.io/github/issues-pr/microsoft/Generative-AI-For-Beginners.svg)](https://GitHub.com/microsoft/Generative-AI-For-Beginners/pulls/?WT.mc_id=academic-105485-koreyst) +[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com) + +[![GitHub watchers](https://img.shields.io/github/watchers/microsoft/Generative-AI-For-Beginners.svg?style=social&label=Watch)](https://GitHub.com/microsoft/Generative-AI-For-Beginners/watchers/?WT.mc_id=academic-105485-koreyst) +[![GitHub forks](https://img.shields.io/github/forks/microsoft/Generative-AI-For-Beginners.svg?style=social&label=Fork)](https://GitHub.com/microsoft/Generative-AI-For-Beginners/network/?WT.mc_id=academic-105485-koreyst) +[![GitHub stars](https://img.shields.io/github/stars/microsoft/Generative-AI-For-Beginners.svg?style=social&label=Star)](https://GitHub.com/microsoft/Generative-AI-For-Beginners/stargazers/?WT.mc_id=academic-105485-koreyst) + +[![Open in GitHub Codespaces](https://img.shields.io/static/v1?style=for-the-badge&label=GitHub+Codespaces&message=Open&color=lightgrey&logo=github)](https://codespaces.new/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst) +[![](https://dcbadge.vercel.app/api/server/ByRwuEEgH4)](https://aka.ms/genai-discord?WT.mc_id=academic-105485-koreyst) + +# Curso - Inteligência Artificial Generativa para Iniciantes + +Aprenda os fundamentos para criar aplicações de IA Generativa com nosso curso que abrange 12 lições, criado pelos **[Microsoft Cloud Advocates](https://developer.microsoft.com/advocates/?WT.mc_id=academic-105485-koreyst)**. Cada lição aborda um aspecto fundamental dos princípios e desenvolvimento de aplicações em IA Generativa. Ao decorrer deste curso, estaremos desenvolvendo nossa própria startup de IA Generativa para que você possa entender o que é necessário para lançar suas ideias. + +## 🌱 Primeiros Passos + +Para começar, [faça um fork deste repositório](https://github.com/microsoft/generative-ai-for-beginners/fork?WT.mc_id=academic-105485-koreyst) para sua própria conta do GitHub para poder alterar qualquer código e concluir os desafios. Você também pode [marcar este repositório com uma estrela (🌟)](https://docs.github.com/en/get-started/exploring-projects-on-github/saving-repositories-with-stars?WT.mc_id=academic-105485-koreyst) para que possa encontrar com mais facilidade depois. + +Abaixo estão os links para cada lição. Sinta-se à vontade para explorar e começar em qualquer lição que te interessa mais! + +Acesse a [Página de Configuração do Curso](../../00-course-setup/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) para encontrar o guia de configuração que melhor se adapta a você. + +## 🗣️ Conheça Outros Aprendizes e Obtenha Suporte + +Nós acreditamos que uma das melhores formas de aprender é aprendendo com outras pessoas! Junte-se ao nosso [servidor oficial do Discord de IA](https://aka.ms/genai-discord?WT.mc_id=academic-105485-koreyst) para conhecer e fazer networking com outros alunos(as) que estão fazendo este curso e obter suporte. Quem sabe você pode encontrar seu próximo co-fundador(a) lá! + +[![Junte-se ao canal do Discord](https://dcbadge.vercel.app/api/server/ByRwuEEgH4)](https://aka.ms/genai-discord?WT.mc_id=academic-105485-koreyst) + +### 🚀 Você é uma startup ou tem uma ideia que deseja lançar? + +Visit [Microsoft's Founders Hub](https://aka.ms/genai-foundershub?WT.mc_id=academic-105485-koreyst) where you can apply to receive **free OpenAI credits** and up to **$150k towards Azure's leading AI services**. + +Visite o [Microsoft's Founders Hub](https://aka.ms/genai-foundershub?WT.mc_id=academic-105485-koreyst) onde você pode se inscrever para receber **créditos gratuitos da OpenAI** e até **USD 150 mil para os principais serviços de IA da Azure**. + +## 🙏 Deseja ajudar? + +Aqui estão maneiras de contribuir para este curso: + +- Encontre erros de ortografia ou erros de código, [criando uma ISSUE](https://github.com/microsoft/generative-ai-for-beginners/issues?WT.mc_id=academic-105485-koreyst) ou [um Pull Request](https://github.com/microsoft/generative-ai-for-beginners/pulls?WT.mc_id=academic-105485-koreyst) + +- Envie suas ideias, talvez suas ideias para novas lições ou exercícios e nos informe como podemos melhorar. + +- Traduza para o seu idioma, cada capítulo possui um subdiretório de *translations*, se você deseja ajudar em relação a isso, crie a seguinte estrutura: + +```text + Capítulo NN/ <== número do capítulo da lição. Ex:: `00-course-setup` + translations + es/ <== o código do seu idioma + README.md <== sua tradução +``` + +## 📂 Cada lição inclui: + +- uma breve introdução em vídeo ao tópico +- uma lição escrita localizada no `README` +- para lições baseadas em projetos, exemplos de códigos no `Jupyter Notebook` +- um desafio ou tarefa para aplicar o seu aprendizado +- links para recursos adicionais para continuar o seu aprendizado + +## 🗃️ Lições + +| | Link da Lição | Conceitos Ensinados | Aprendizado Objetivo | +| :---: | :------------------------------------------: | :-------------------------------------------------: | ---------------------------------------------------- | +| 00 | [Introdução ao Curso - Como Começar Este Curso](../../00-course-setup/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | Configuração técnica e estrutura do curso | Te preparar para o sucesso ao aprender neste curso | +| 01 | [Introdução à IA Generativa e LLMs](../../01-introduction-to-genai/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | **Conceito**: IA Generativa e como chegamos à atual paisagem tecnológica | Compreensão do que é a IA Generativa e como os Modelos de Linguagem de Grande Porte (LLMs) funcionam | +| 02 | [Explorando e Comparando Diferentes LLMs](../../02-exploring-and-comparing-different-llms/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | **Conceito**: Testar, iteragir e comparar diferentes Modelos de Linguagem de Grande Porte | Selecionar o modelo correto para o seu caso de uso | +| 03 | [Uso Responsável da IA Generativa](../../03-using-generative-ai-responsibly/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | **Conceito**: Compreensão das limitações dos modelos fundamentais e dos riscos da IA | Aprender a construir Aplicações de IA Generativa de forma responsável | +| 04 | [Fundamentos da Engenharia de Prompt](../../04-prompt-engineering-fundamentals/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | **Código/Conceito**: Aplicação das Melhores Práticas de Engenharia de Prompt | Compreensão da estrutura e uso de prompts | +| 05 | [Criação de Prompts Avançados](../../05-advanced-prompts/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | **Código/Conceito**: Amplie seu conhecimento em Engenharia de Prompts aplicando diferentes técnicas aos seus prompts | Aplicar técnicas de Engenharia de Prompts que melhorem os resultados dos seus prompts | +| 06 | [Criando Aplicações de Geração de Texto](../../06-text-generation-apps/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | **Código**: Criar uma aplicação de geração de texto usando o Azure OpenAI | Compreender como usar eficientemente `tokens` e `temperatura` para variar a saída do modelo | +| 07 | [Criando Aplicações de Chat](../../07-building-chat-applications/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | **Código**: Técnicas para criar e integrar eficientemente aplicações de chat | Identificar métricas-chave e considerações para monitorar e manter a qualidade de aplicaççoes de chat com IA | +| 08 | [Criando Aplicações de Busca com Bancos de Dados Vetoriais](../../08-building-search-applications/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | **Código**: Busca `Semântica vs. por Palavras-chave`. O que são incorporações de texto e como elas se aplicam à busca | Criar uma aplicação que usa incorporações para buscar dados. | +| 09 | [Criando Aplicações de Geração de Imagens](../../09-building-image-applications/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | **Código**: Geração de imagens e por que é útil na criação de aplicações | Criar Aplicações de geração de imagens | +| 10 | [Criando Aplicações de IA com Pouco Código](../../10-building-low-code-ai-applications/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | **Low Code**: Introdução à IA Generativa no `Power Platform` | Criar Aplicações de rastreamento de tarefas de estudantes para nossa startup educacional com Low Code | +| 11 | [Integração de Aplicações Externas com Chamadas de Função](../../11-integrating-with-function-calling/transaltions/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | **Código**: O que é a chamada de função e seus casos de uso para aplicações | Configurar uma chamada de função para recuperar dados de uma API externa | +| 12 | [Design de UX para Aplicações de IA](../../12-designing-ux-for-ai-applications/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | **Conceito**: Design de Aplicações de IA para Confiança e Transparência | Aplicar princípios de design de UX ao desenvolver Aplicações de IA Generativa | +| xx | [Continue seu Aprendizado](../../13-continued-learning/translations/pt-br/README.md?WT.mc_id=academic-105485-koreyst) | Links para continuar seu aprendizado a partir de cada lição! | Aperfeiçoar suas habilidades em IA Generativa | | + +## 🎒 Outros Cursos + +Our team produces other courses! Check out: + +Nosso time produz outros cursos! Confiram agora: + +- [ML para Iniciantes](https://aka.ms/ml-beginners?WT.mc_id=academic-105485-koreyst) +- [Ciência de Dados para Iniciantes](https://aka.ms/datascience-beginners?WT.mc_id=academic-105485-koreyst) +- [IA para Iniciantes](https://aka.ms/ai-beginners?WT.mc_id=academic-105485-koreyst) + +- [Web Dev para Iniciantes](https://aka.ms/webdev-beginners?WT.mc_id=academic-105485-koreyst) +- [IoT para Iniciantes](https://aka.ms/iot-beginners?WT.mc_id=academic-105485-koreyst) + +- [Desenvolvimento XR para Iniciantes](https://github.com/microsoft/xr-development-for-beginners?WT.mc_id=academic-105485-koreyst) \ No newline at end of file