Conheça o framework Foundation Models

Olá, eu sou o Erik. E eu sou o Yifei. Hoje, temos o privilégio de apresentar o novo framework Foundation Models. O framework Foundation Models oferece acesso ao grande modelo de linguagem no dispositivo que viabiliza a Apple Intelligence, com uma API Swift prática e avançada. Ele está disponível para macOS, iOS, iPadOS e visionOS. Você pode usá-lo para aprimorar os recursos dos apps, como fornecer sugestões de busca personalizadas. Também pode criar outros recursos, como gerar um itinerário em um app de viagem, tudo no dispositivo. Pode até mesmo usá-lo para criar diálogos instantâneos para personagens em um jogo.

Ele é otimizado para geração de conteúdo, resumo de texto, análise de comandos do usuário e muito mais. Tudo isso é executado no dispositivo, garantindo a privacidade dos dados que entram e saem do modelo. Isso também significa que ele pode ser executado offline. E está integrado ao sistema operacional, então não aumentará o tamanho do seu app. É um grande ano, então, para ajudar você a aproveitar ao máximo o framework Foundation Models, preparamos uma série de vídeos. Neste primeiro vídeo, apresentaremos um resumo avançado do framework como um todo. Vamos começar pelos detalhes do modelo. Depois, vamos apresentar a geração guiada, que permite obter resultados estruturados no Swift, e as APIs de streaming que transformam latência em bons resultados. Também vamos saber como chamar ferramentas para que o modelo execute de maneira autônoma o código definido no seu app. Por fim, vamos abordar a compatibilidade com vários turnos com sessões stateful e como integramos perfeitamente o framework ao ecossistema dos desenvolvedores Apple. É claro que a parte mais importante do framework é o modelo que o viabiliza. E o melhor jeito de começar a usar os prompts do modelo é por meio do Xcode. Testar prompts para descobrir o que funciona melhor é fundamental no desenvolvimento com grandes modelos de linguagem, e o novo recurso Playgrounds no Xcode é o melhor jeito de fazer isso. Com apenas algumas linhas de código, você pode começar a enviar prompts ao modelo no dispositivo. Aqui, vamos pedir para ele gerar um título para uma viagem ao Japão. O resultado do modelo aparecerá na tela à direita. Agora, quero saber se esse prompt também funciona bem para outros destinos. Em um #Playground, você pode acessar os tipos definidos no seu app, então vou criar um loop for sobre os pontos de referência no meu. O Xcode mostrará a resposta do modelo para todos os pontos de referência.

O modelo no dispositivo que usamos é um grande modelo de linguagem com 3 bilhões de parâmetros, cada um quantificado em 2 bits. Ele consiste em várias ordens de magnitude maior do que qualquer outro modelo do sistema operacional.

Mesmo assim, é importante ter em mente que esse modelo é dimensionado para o dispositivo. Ele é otimizado para casos de uso como resumo, extração, classificação, entre outros. Ele não foi criado para conhecimento do mundo ou raciocínio avançado, tarefas para as quais usaríamos LLMs dimensionados para o servidor.

Os modelos dimensionados para o dispositivo exigem que as tarefas sejam subdivididas.

Ao trabalhar com o modelo, você começará a perceber seus pontos fortes e fracos.

Em alguns casos de uso, como marcação de conteúdo, também fornecemos adaptadores especializados que maximizam a capacidade do modelo em domínios específicos. Também vamos continuar aprimorando nossos modelos ao longo do tempo. Mais adiante, vamos explorar como você pode nos contar como usa nossos modelos, o que nos ajudará a aprimorá-los para serem mais úteis para você.

Agora que já demos uma olhada no modelo, a primeira parada na nossa jornada é a geração guiada. A geração guiada é o que possibilita o desenvolvimento de recursos como os que você acabou de ver e é a base do framework Foundation Models. Vamos conferir um problema comum e discutir como GuidedGeneration o resolve. Por padrão, os modelos de linguagem produzem linguagem natural e não estruturada. Ela é de fácil leitura para humanos, mas difícil de ser mapeada nas visualizações do seu app. Uma solução comum é solicitar que o modelo produza algo que seja fácil de analisar, como JSON ou CSV.

Mas isso logo se transforma em uma brincadeira de pega-pega. Você precisa incluir instruções cada vez mais específicas sobre o que ele deve ou não fazer... Isso nem sempre funciona, então você acaba escrevendo hacks para extrair e corrigir o conteúdo. Como o modelo é probabilístico e existe chance de erros estruturais, isso compromete a confiabilidade. GuidedGeneration oferece uma solução fundamental para esse problema.

Quando você importa o Foundation Models, tem acesso a duas novas macros, @Generable e @Guide. A @Generable permite descrever um tipo do qual deseja que o modelo gere uma instância. As @Guides permitem descrever com linguagem natural as propriedades e controlar de forma programática os valores que podem ser gerados para essas propriedades.

Depois de definir um tipo @Generable, você pode fazer com que o modelo responda aos prompts gerando uma instância do seu tipo. Isso é muito poderoso. Confira como nosso prompt não precisa mais especificar o formato do resultado. O framework cuida disso. O importante é que recebemos de volta um objeto avançado do Swift que podemos mapear facilmente em uma visualização interessante.

Os tipos geráveis podem ser construídos usando primitivos, como strings, integers, doubles, floats, decimals e booleans. As matrizes também são geráveis. E os tipos geráveis também podem ser compostos. Eles são compatíveis até com tipos recursivos, que têm aplicações avançadas em domínios como interfaces generativas. O mais importante: a geração guiada garante a correção estrutural usando uma técnica chamada decodificação restrita.

Ao usar GuidedGeneration, seus prompts podem ser mais simples e focados no comportamento desejado em vez do formato. GuidedGeneration também tende a melhorar a precisão do modelo. Ao mesmo tempo, ela nos permite realizar otimizações que aceleram a inferência. Isso é possível graças à integração coordenada dos sistemas operacionais da Apple, das ferramentas para desenvolvedores e do treinamento dos nossos Foundation Models. Ainda há muito mais a ser abordado sobre a geração guiada, como a criação de esquemas dinâmicos em tempo de execução, então confira nosso vídeo aprofundado para mais detalhes. Isso conclui GuidedGeneration. Exploramos como o sistema de tipos do Swift aumenta os prompts em linguagem natural para viabilizar um resultado estruturado confiável. O próximo tópico é streaming, que se baseia na macro @Generable que você já conheceu. Se você já usou grandes modelos de linguagem, talvez saiba que eles geram texto na forma de pequenos grupos de caracteres chamados tokens.

Em geral, ao transmitir o resultado, os tokens são entregues em deltas, mas o framework Foundation Models adota uma abordagem diferente. Quero mostrar o porquê.

Conforme os deltas são produzidos, a responsabilidade de acumulá-los geralmente sobra para o desenvolvedor.

Você anexa cada delta à medida que eles chegam. E a resposta aumenta cada vez mais. Mas isso fica complicado quando o resultado tem estrutura. Se quiser mostrar a string de saudação depois de cada delta, terá que analisá-la a partir da acumulação, e isso não é trivial, principalmente em estruturas complicadas. O streaming de deltas não é a fórmula certa quando se trabalha com resultados estruturados. Os resultados estruturados são a base do framework Foundation Models. É por isso que desenvolvemos uma abordagem diferente. Em vez de deltas brutos, transmitimos capturas instantâneas.

O framework transforma os deltas produzidos em capturas instantâneas. As capturas representam respostas parcialmente geradas. Todas as propriedades são opcionais. E elas são preenchidas à medida que o modelo produz mais respostas. As capturas são uma representação robusta e conveniente para a transmissão da resposta estruturada.

Você já se familiarizou com a macro @Generable, e é dela que vêm as definições de tipos parcialmente gerados. Se você expandir a macro, descobrirá que ela produz um tipo chamado PartiallyGenerated. Ele é basicamente um espelho da estrutura externa, exceto que cada propriedade é opcional.

O tipo parcialmente gerado entra em ação quando você chama o método streamResponse na sua sessão.

A resposta do fluxo retorna uma sequência assíncrona. E os elementos dessa sequência são instâncias de um tipo parcialmente gerado. Cada elemento da sequência terá uma captura instantânea atualizada.

Essas capturas funcionam bem com frameworks declarativos, como a SwiftUI. Primeiro, crie um estado que mantenha um tipo parcialmente gerado. Depois, basta iterar em um fluxo de resposta, armazenar os elementos e presenciar a interface ganhar vida.

Para concluir, vamos analisar algumas melhores práticas para streaming.

Primeiro, dê asas à criatividade com as animações e transições da SwiftUI para ocultar a latência. Você tem a chance de transformar um momento de espera em um momento divertido. Depois, você vai precisar pensar cuidadosamente sobre a identidade das visualizações na SwiftUI, principalmente ao gerar matrizes. Por fim, lembre-se de que as propriedades são geradas na ordem em que são declaradas na sua estrutura do Swift. Isso é importante tanto para as animações quanto para a qualidade do resultado do modelo. Por exemplo, você pode descobrir que os melhores resumos são produzidos quando são a última propriedade na estrutura.

Há muito a ser desvendado, então não deixe de conferir mais detalhes no nosso vídeo sobre a integração do Foundation Models nos apps da SwiftUI. Isso encerra o streaming com o Foundation Models. Na sequência, Yifei vai ensinar tudo sobre como chamar ferramentas. Agradeço, Erik. A chamada de ferramentas é mais um dos nossos principais recursos. Ela permite que o modelo execute o código definido no seu app. Esse recurso é importante para aproveitar ao máximo nosso modelo, pois oferece vários outros recursos ao modelo. Com ele, o modelo consegue identificar que uma tarefa pode exigir mais informações ou ações, tomando decisões de maneira autônoma sobre qual ferramenta usar e quando, quando for difícil decidir de forma programática. As informações fornecidas ao modelo podem ser conhecimento do mundo, eventos recentes ou dados pessoais. Por exemplo, no nosso app de viagem, são fornecidas informações sobre locais por meio do MapKit. Isso também permite que o modelo cite fontes da verdade, o que evita suposições e permite a verificação de fatos no resultado do modelo. Por fim, também possibilita que o modelo execute ações, seja no app, no sistema ou no mundo real. A integração com várias fontes de informação no app é uma estratégia decisiva para criar experiências interessantes. Agora que você sabe a utilidade da chamada de ferramentas, vamos conferir como ela funciona. Do lado esquerdo, temos uma transcrição que registra tudo o que já aconteceu até o momento. Se você tiver fornecido ferramentas, a sessão apresentará essas ferramentas ao modelo junto com as instruções. Depois, vem o prompt, em que informamos ao modelo o destino que queremos visitar. Se o modelo considerar que a resposta pode ser melhorada com alguma ferramenta, ele vai chamar uma ou mais ferramentas. Nesse exemplo, o modelo chama duas ferramentas, consultando restaurantes e hotéis. Nessa fase, o framework Foundation Models chama automaticamente o código que você escreveu para essas ferramentas. O framework insere automaticamente os resultados da ferramenta de volta na transcrição. Por fim, o modelo incorpora o resultado da ferramenta em todo o restante na transcrição para fornecer a resposta final.

Agora que sabemos como chamar ferramentas, vamos definir uma ferramenta.

Vamos definir uma ferramenta de previsão do tempo simples que segue o protocolo de ferramentas. Essa ferramenta é um exemplo simples das chamadas de ferramentas e é um ótimo jeito de começar.

Primeiro, o protocolo exige que você especifique um nome e uma descrição em linguagem natural da ferramenta.

O framework passará essas informações automaticamente ao modelo para ajudá-lo a entender quando chamar a ferramenta.

Quando o modelo chamar a ferramenta, ela executará o método de chamada definido.

O argumento do método de chamada pode ser de qualquer tipo @Generable.

Os argumentos precisam ser geráveis porque a chamada de ferramentas é baseada na geração guiada, para garantir que o modelo nunca gere nomes de ferramentas ou argumentos inválidos. Depois de definir o tipo de argumento, você pode escrever o que quiser no corpo do método. Aqui, vamos usar o CoreLocation e o WeatherKit para encontrar a temperatura de uma cidade. O resultado é representado com o tipo ToolOutput, que pode ser criado com base no GeneratedContent para representar dados estruturados. Ou em uma string se o resultado da ferramenta usar linguagem natural. Agora que definimos uma ferramenta, precisamos garantir que o modelo tenha acesso a ela. Para isso, passe a ferramenta para o inicializador da sessão. As ferramentas devem ser anexadas na inicialização da sessão e estarão disponíveis para o modelo enquanto a sessão estiver ativa.

Depois de criar uma sessão com ferramentas, basta enviar um prompt ao modelo como de costume. As chamadas de ferramentas vão ocorrer de forma transparente e autônoma, e o modelo vai incorporar os resultados das ferramentas na resposta final. Meus exemplos demonstram como definir ferramentas que independem do tipo no tempo de compilação, o que é ótimo para a maioria dos casos de uso. Mas as ferramentas também podem ser totalmente dinâmicas. Por exemplo, é possível definir os argumentos e comportamentos de uma ferramenta no tempo de execução com esquemas de geração dinâmica. Se tiver interesse, confira nosso vídeo aprofundado para saber mais. Isso conclui a chamada de ferramentas. Aprendemos por que a chamada de ferramentas é útil e como implementar as ferramentas para ampliar os recursos do modelo. Na sequência, vamos explorar as sessões stateful. A palavra sessão já foi dita várias vezes neste vídeo. O framework Foundation Models foi criado com base na noção de uma sessão stateful. Por padrão, ao criar uma sessão, você envia um prompt ao modelo de propósito geral no dispositivo. E você pode fornecer instruções personalizadas. As instruções permitem que você diga ao modelo qual é o seu papel e indique como ele deve responder. Por exemplo, é possível especificar aspectos como estilo e verbosidade. O fornecimento de instruções personalizadas é opcional, e serão usadas instruções padrão plausíveis se você não especificar uma.

Caso você opte por fornecer instruções personalizadas, é importante entender a diferença entre instruções e prompts. As instruções devem vir de você, o desenvolvedor. Os prompts podem vir do usuário. Isso acontece porque o modelo é treinado para obedecer a instruções em vez de prompts. Isso protege contra ataques de injeção de prompts, mas não garante que seja à prova de falhas. Como regra geral, as instruções costumam ser estáticas, e é melhor não interpolar comandos não confiáveis do usuário nas instruções. Portanto, essa é uma cartilha básica sobre o melhor jeito de formular instruções e prompts. Para obter outras melhores práticas, confira nosso vídeo sobre design e segurança de prompts. Agora que você já iniciou uma sessão, vamos abordar as interações multiturnos. Ao usar os métodos respond ou streamResponse já mencionados, cada interação com o modelo é retida como contexto em uma transcrição, então o modelo poderá consultar e entender as interações multiturnos anteriores em uma única sessão. Por exemplo, aqui o modelo consegue entender que, quando dizemos "faça outro", estamos nos referindo a escrever um haicai.

E a propriedade transcript no objeto da sessão vai permitir que você inspecione interações passadas ou chame visualizações da interface para representá-las.

Outra coisa importante é que, enquanto o modelo estiver produzindo resultados, sua propriedade isResponding será true. Talvez você precise observar essa propriedade e não enviar outro prompt até que o modelo finalize a resposta. Além do modelo padrão, disponibilizamos outros casos de uso especializados integrados que são respaldados por adaptadores. Se encontrar um caso de uso integrado que atenda às suas necessidades, envie-o ao inicializador do SystemLanguageModel. Para conhecer os casos de uso integrados disponíveis e como utilizá-los da melhor forma, consulte nossa documentação no site para desenvolvedores. Um dos adaptadores especializados sobre o qual quero abordar mais hoje é o adaptador de marcação de conteúdo. O adaptador de marcação de conteúdo ajuda na geração de tags, na extração de entidades e na detecção de tópicos. Por padrão, o adaptador é treinado para gerar tags de tópicos e se integra à geração guiada imediatamente. Dessa forma, você pode definir uma estrutura com a nossa macro @Generable e enviar o comando do usuário para extrair tópicos dela.

E tem mais! Ao fornecer instruções e um tipo de resultado gerável personalizados, você também pode usá-lo para detectar ações e emoções. Antes de criar uma sessão, verifique a disponibilidade: o modelo só pode ser executado em dispositivos compatíveis com a Apple Intelligence nas regiões onde ela está disponível. Para conferir se o modelo está disponível, acesse a propriedade de disponibilidade no SystemLanguageModel.

A disponibilidade é um enum de dois casos: disponível ou indisponível. Se não estiver disponível, você também receberá um motivo para ajustar a interface.

Por fim, talvez você encontre erros ao chamar o modelo. Esses erros podem incluir violação das proteções, linguagem incompatível ou janela de contexto excedida. Para proporcionar a melhor experiência ao usuário, lide com eles de forma adequada. O vídeo aprofundado ensina mais sobre isso. Isso é tudo sobre as sessões stateful multiturnos. Aprendemos a criar uma sessão e usá-la e vimos como nosso modelo mantém o controle do seu contexto. Agora que você conhece todos os recursos interessantes do framework, vamos abordar as ferramentas e a experiência do desenvolvedor. Para começar, abra um arquivo do Swift no seu projeto e use a nova macro de playground para enviar um prompt ao modelo.

Os playgrounds são robustos porque permitem repetir rapidamente os prompts sem precisar compilar e executar novamente todo o app. Em um playground, o código pode acessar todos os tipos do projeto, como os tipos geráveis que viabilizam a interface.

Sabemos que, ao criar experiências nos apps com base em grandes modelos de linguagem, é importante entender a latência subjacente, já que a execução desses modelos é mais demorada do que a de modelos de ML tradicionais. Entender para onde vai a latência pode ajudar você a ajustar a verbosidade dos prompts ou determinar quando chamar APIs úteis, como o pré-aquecimento.

E o nosso novo modelo de perfil de apps Instruments foi criado para isso. Você pode traçar o perfil da latência de uma solicitação de modelo, observar as áreas de otimização e quantificar as melhorias.

Ao desenvolver apps, talvez você tenha feedback que pode nos ajudar a melhorar nossos modelos e APIs.

Sempre que possível, envie seus comentários por meio do Assistente de Feedback. Fornecemos até mesmo uma estrutura de dados de anexo de feedback codificável que você pode anexar como um arquivo ao seu feedback.

Se você for um profissional de ML com um caso de uso especializado e um conjunto de dados personalizado, poderá treinar adaptadores personalizados usando nosso kit de ferramentas de treinamento de adaptadores. Mas lembre-se de que isso traz muitas responsabilidades, pois você precisará treiná-lo novamente sempre que a Apple aprimorar o modelo. Para saber mais, acesse o site para desenvolvedores. Agora que você aprendeu muitos dos recursos oferecidos pelo novo framework Foundation Models, mal podemos esperar por suas criações incríveis com ele. Para saber ainda mais sobre como integrar IA generativa ao seu app, como tecnologias como a geração guiada funcionam nos bastidores e como criar os melhores prompts, temos uma série de vídeos e artigos incríveis para você. Agradeço a participação. Divirta-se gerando!