<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Luciano Martins on Medium]]></title>
        <description><![CDATA[Stories by Luciano Martins on Medium]]></description>
        <link>https://medium.com/@lucianommartins?source=rss-925379214ac4------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*tyQDRMzIIFmU-0bJPjrvvA.png</url>
            <title>Stories by Luciano Martins on Medium</title>
            <link>https://medium.com/@lucianommartins?source=rss-925379214ac4------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 04:38:07 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@lucianommartins/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Primeiros passos com o Gemini na Vertex AI]]></title>
            <link>https://medium.com/google-cloud-brasil/primeiros-passos-com-o-gemini-na-vertex-ai-623083cf8780?source=rss-925379214ac4------2</link>
            <guid isPermaLink="false">https://medium.com/p/623083cf8780</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[vertex-ai]]></category>
            <dc:creator><![CDATA[Luciano Martins]]></dc:creator>
            <pubDate>Mon, 18 Dec 2023 18:14:36 GMT</pubDate>
            <atom:updated>2023-12-18T18:14:36.222Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introdução</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/824/0*ZBQqAQV0SWNK82Vx" /><figcaption>Google Gemini — anunciado em 6 de dezembro de 2023</figcaption></figure><p>Faz algumas semanas, o Google <a href="https://blog.google/technology/ai/google-gemini-ai/">lançou o Gemini</a> — o maior e com mais capacidade modelo já desenvolvido pelo Google.</p><p>Uma das grandes inovações na criação do Gemini é sua <strong>multimodalidade</strong> desde o T0, ou seja, desde seu desenvolvimento o Gemini já foi treinado com diversas modalidades (ou formatos) de informação — O que isso significa? Normalmente, os grandes modelos de linguagem são criados e treinados em uma única modalidade de dados (por exemplo, utilizando datasets em formato de texto) e depois que esta primeira “encarnação” do modelo está com uma qualidade boa, usa-se outras técnicas para otimizar este modelo para outras modalidades (imagens, áudio, video, documentos, etc).</p><p>Assim, o Gemini é treinado desde o início com diferentes modalidades — Depois, com a ajuda de datasets multimodais adicionais e para tarefas específicas, o modelo é refinado mais ainda para melhora na sua eficiência. Isso ajuda o Gemini a ter melhor compreensão e “<em>reasoning</em>” (ou “raciocínio” em uma tradução livre) para cenários envolvendo imagens e vídeos junto com <em>prompts</em> de texto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xVSq8qv9lNjpLR3G" /><figcaption>Visão abstrata da arquitetura do Gemini</figcaption></figure><h3>Mas o que isso nos traz de melhoria, na prática?</h3><p>Excelente pergunta, caro internauta! Com essa abordagem de treinamento multimodal, você tem disponível, diretamente do modelo pré-treinado, coisas como:</p><p><strong>Entendimento multimodal de contextos: </strong>Sendo o modelo treinado de forma multimodal desde o início, você consegue usar, desde a primeira interação, prompts combinando texto, imagens e vídeos (e com mais por vir no futuro).</p><p><strong><em>Reasoning</em> mais sofisticado: </strong>Ou seja, o Gemini consegue levar informações visuais e escritas em imagens, assim como escritas em prompts de texto, tudo junto, antes de gerar a resposta para sua solicitação.</p><p><strong>Capacidade de codificação avançada: </strong>O Gemini evolui a qualidade que já estava disponível nos modelos baseados no <a href="https://ai.google/discover/palm2/">PaLM2</a>, trazendo maior qualidade na geração, complementação e explicação de códigos. Para dar uma ideia, o time da Google DeepMind criou recentemente uma nova versão do AlphaCode (o <a href="https://storage.googleapis.com/deepmind-media/AlphaCode2/AlphaCode2_Tech_Report.pdf">AlphaCode 2</a>), baseado em uma versão do Gemini, que consegue resultados bem interessantes em competições de código (aquelas em que há um desafio objetivo “escreva um código que faça travessia em um grafo sob determinadas condições”) e com scores bem altos. Vale a pena dar uma olhada no <a href="https://storage.googleapis.com/deepmind-media/AlphaCode2/AlphaCode2_Tech_Report.pdf">relatório técnico do AlphaCode 2</a>.</p><p>No lançamento realizado pela Google DeepMind, foram anunciadas três variações do Gemini em sua primeira versão (1.0):</p><p><strong>Gemini Ultra: </strong>O maior modelo da família, com capacidade para solucionar tarefas mais complexas<br><strong>Gemini Pro: </strong>O melhor modelo para a maioria das tarefas<br><strong>Gemini Nano: </strong>O modelo mais eficiente para uso em dispositivos</p><p>Maiores detalhes sobre arquitetura, treinamento, datasets utilizados e resultados de avaliações com benchmarks acadêmicos podem ser encontrados no <a href="https://storage.googleapis.com/deepmind-media/gemini/gemini_1_report.pdf">relatório técnico do Gemini</a>.</p><h3>Gemini API na Vertex AI</h3><p>Após o lançamento do modelo pela área de pesquisa de IA do Google, a Google DeepMind, foi a hora da segunda parte (e pessoalmente, mais legal): o <a href="https://blog.google/technology/ai/gemini-api-developers-cloud/">lançamento do Gemini</a>, em formato de APIs, para todo mundo 🎉</p><p>O Gemini está disponível para experimentação de desenvolvedores tanto no <a href="https://ai.google.dev/">Google AI Studio</a> (antes conhecido como MakerSuite) quanto na <a href="https://cloud.google.com/vertex-ai/">Vertex AI</a> da Google Cloud. Aqui nesse blog vamos focar nessa segunda forma (na Google Cloud).</p><p>A Gemini API está disponível dentro da Vertex AI, a plataforma de desenvolvimento de soluções de machine learning dentro da Google Cloud, e a utilização é simples como a interação que já tínhamos com a PaLM API.</p><p>Na console, você consegue acessar diretamente pela Vertex AI, no menu de “Linguagem” (para interações somente de texto):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Hh5NVl5n8kepVM6C" /><figcaption>Console da Vertex AI em uma interação de texto com a Gemini API</figcaption></figure><p>Ou na opção “Multimodal”, para interações multimodais (incluindo alguns exemplos legais):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vosFH-XaYLmg21UZ" /><figcaption>Console da Vertex AI em uma interação multimodal com a Gemini API</figcaption></figure><p>Mas a diversão é mexer com código, né? Deixa a interface gráfica para outras pessoas! #brinks 🤡</p><h3>Primeiros passos</h3><p>Como começar? Bom, para não alongar muito nessa postagem, vou dar alguns exemplos rápidos, que podem ajudar a começar a jornada, e também um repositório no github com mais exemplos.</p><p>Mas nas próximas postagens teremos mais coisas legais, feitas pelos colaboradores do blog!</p><h3>Instalação da SDK da Vertex AI</h3><p>Aqui vou mostrar alguns exemplos em Python (mas tem exemplos em outras linguagens [Java, Nodejs, Go, etc] <a href="https://cloud.google.com/vertex-ai/docs/generative-ai/start/quickstarts/quickstart-multimodal#gemini-beginner-samples-nodejs">aqui</a>).</p><p>Para instalar a SDK, basta um pip install:</p><pre>$ pip3 install - upgrade - user google-cloud-aiplatform</pre><p>Aqui eu estou usando o <a href="https://cloud.google.com/vertex-ai-notebooks?hl=pt-br">Vertex AI Workbench</a> — então eu já tenho a ajuda da Vertex AI para autenticação do usuário, acesso às API etc. Nos notebooks que compartilharei no final tem os passos caso você use o <a href="https://colab.sandbox.google.com/">Google Colab</a> ou a sua própria estação.</p><h3>Modelos disponíveis</h3><p>A API Vertex AI Gemini fornece uma interface unificada para interagir com modelos Gemini. Atualmente existem dois modelos disponíveis na API Gemini:</p><p><strong>Modelo Gemini Pro</strong>(ou <strong>gemini-pro</strong> na SDK): Projetado para lidar com tarefas de linguagem natural, bate-papo multivoltas de texto e código e geração de código.<br><strong>Modelo Gemini Pro Vision </strong>(ou <strong>gemini-pro-vision</strong> na SDK): Suporta prompts multimodais. Você pode incluir texto, imagens e vídeo em suas solicitações de prompt e obter respostas em texto ou código.</p><h3>Iniciando com interações somente texto</h3><p>Depois disso você precisa importar os módulos da SDK:</p><pre>from vertexai.preview.generative_models import GenerativeModel</pre><p>E depois instanciar um objeto importando o modelo. Aqui, começando com o Gemini-Pro (somente prompts de texto).</p><pre>model = GenerativeModel(&quot;gemini-pro&quot;)</pre><p>Depois disso? Depois disso é só mandar requisições. Simples assim:</p><pre>responses = model.generate_content(&quot;Por que o céu é azul?&quot;, stream=True)</pre><p>E ter os resultados no objeto “responses”:</p><pre>for response in responses:<br>  print(response.text, end=&quot;&quot;)<br><br>A cor azul do céu é causada pela dispersão de Rayleigh, um fenômeno óptico <br>que ocorre quando a luz solar interage com as moléculas de nitrogênio e <br>oxigênio na atmosfera terrestre.<br><br>Quando a luz solar atinge a atmosfera, ela é dispersa em todas as direções. <br>A quantidade de dispersão depende do comprimento de onda da luz, com <br>comprimentos de onda mais curtos (como o azul) sendo dispersos mais do que <br>comprimentos de onda mais longos (como o vermelho).<br><br>Isso significa que a luz azul é espalhada para todas as partes do céu, <br>dando-lhe sua cor azulada. A luz vermelha, por outro lado, é menos dispersa <br>e viaja em linha reta, o que é por isso que o sol parece vermelho quando <br>está perto do horizonte.<br><br>A quantidade de dispersão também depende do ângulo do sol em relação ao <br>observador. Quando o sol está baixo no céu, a luz solar tem que viajar mais <br>através da atmosfera para atingir o observador. Isso significa que há mais <br>moléculas de gás para espalhar a luz, o que resulta em um céu mais azul.<br><br>Quando o sol está alto no céu, a luz solar tem que viajar menos através da <br>atmosfera para atingir o observador. Isso significa que há menos moléculas <br>de gás para espalhar a luz, o que resulta em um céu mais claro.<br><br>A dispersão de Rayleigh também é responsável pelos belos tons vermelhos, <br>laranja e amarelos do pôr do sol e do nascer do sol. Quando o sol está perto <br>do horizonte, a luz solar tem que viajar mais através da atmosfera para <br>atingir o observador. Isso significa que há mais moléculas de gás para <br>espalhar a luz, e os comprimentos de onda mais curtos (como o azul) são <br>espalhados para todas as partes do céu. Isso deixa apenas os comprimentos <br>de onda mais longos (como o vermelho, o laranja e o amarelo) para atingir o <br>observador, o que resulta nas cores vibrantes do pôr do sol e do nascer do <br>sol.</pre><p>Isto foi um exemplo de uma interação “unária” — Ou seja, uma requisição, uma resposta e acabou a experiência. Mas o Gemini também suporta interações de chat multiturno (ou seja, com histórico das interações anteriores). Saca só:</p><pre>chat = model.start_chat()<br>prompt = &quot;&quot;&quot;Meu nome é Luciano.<br>Você é meu assistente pessoal.<br>Meus filmes favoritos são Senhor dos Anéis e Hobbit.<br>Sugira outro filme que eu possa gostar.<br>&quot;&quot;&quot;<br>responses = chat.send_message(prompt, stream=True)</pre><p>E a resposta segue a ideia da primeira interação, utilizando o aprendizado embutido do modelo (menção honrosa pra Eragon e Willow, hein?):</p><pre>for response in responses:<br>  print(response.text, end=&quot;&quot;)<br><br>1. O Silmarillion<br>2. As Crônicas de Nárnia<br>3. Harry Potter<br>4. Percy Jackson e os Olimpianos<br>5. Eragon<br>6. A Bússola de Ouro<br>7. Terramar<br>8. A Princesa Prometida<br>9. Willow<br>10. O Cristal Encantado</pre><p>Onde entra a magia (trocadilho não intencional com o gênero dos filmes aí) dessa interação em chat? É a possibilidade de não reenviar perguntas e respostas anteriores. Por exemplo, pedir pro modelo explicar a resposta anterior (sem muitos detalhes sobre ela):</p><pre>prompt = &quot;O que estes filmes tem em comum com os filmes que eu gosto?&quot;<br>responses = chat.send_message(prompt, stream=True)</pre><p>E checando o resultado:</p><pre>for response in responses:<br>  print(response.text, end=&quot;&quot;)<br><br>Os filmes que você mencionou, Senhor dos Anéis e Hobbit, são todos filmes de <br>fantasia. Eles têm em comum com os filmes que sugeri os seguintes elementos:<br><br>* Ambientação medieval ou mitológica: Todos esses filmes se passam em mundos <br>fictícios que lembram a Idade Média ou outras épocas mitológicas.<br><br>* Magia e criaturas fantásticas: Todos esses filmes apresentam magia e <br>criaturas fantásticas, como elfos, dragões, orcs e trolls.<br><br>* Heróis e vilões: Todos esses filmes têm heróis que devem lutar contra <br>vilões poderosos para salvar o mundo.<br><br>* Aventura e ação: Todos esses filmes são cheios de aventura e ação, com <br>muitas cenas de batalha e perseguição.<br><br>* Temas universais: Todos esses filmes exploram temas universais, como o <br>bem contra o mal, a amizade, a coragem e o amor.<br><br>Além disso, muitos desses filmes foram inspirados nas mesmas fontes que <br>Senhor dos Anéis e Hobbit, como a mitologia nórdica e as obras de J.R.R. <br>Tolkien. Aqui estão alguns exemplos específicos de como esses elementos <br>aparecem em cada um dos filmes que sugeri:<br><br>* O Silmarillion: Este filme é uma adaptação da obra de J.R.R. Tolkien do <br>mesmo nome, que conta a história da criação do mundo de Arda e as guerras <br>entre os Valar e Morgoth.<br><br>* As Crônicas de Nárnia: Esta série de filmes é baseada nos livros de C.S. <br>Lewis, e conta a história de quatro crianças que são transportadas para o <br>mundo mágico de Nárnia, onde devem lutar contra a Feiticeira Branca.<br><br>* Harry Potter: Esta série de filmes é baseada nos livros de J.K. Rowling, <br>e conta a história de Harry Potter, um jovem bruxo que deve lutar contra <br>Lord Voldemort, um bruxo das trevas que quer dominar o mundo.<br><br>* Percy Jackson e os Olimpianos: Esta série de filmes é baseada nos livros <br>de Rick Riordan, e conta a história de Percy Jackson, um semideus que deve <br>lutar contra os titãs, que querem destruir o mundo.<br><br>* Eragon: Este filme é baseado no livro de Christopher Paolini, e conta a <br>história de Eragon, um jovem que descobre um ovo de dragão e se torna um <br>Cavaleiro de Dragão, que deve lutar contra o Rei Galbatorix, um tirano que <br>quer dominar o mundo.<br><br>* A Bússola de Ouro: Este filme é baseado no livro de Philip Pullman, e <br>conta a história de Lyra Belacqua, uma jovem que viaja para o Norte para <br>resgatar seu amigo, que foi sequestrado por uma organização misteriosa.<br><br>* Terramar: Este filme é baseado no livro de Ursula K. Le Guin, e conta a <br>história de Ged, um jovem mago que deve lutar contra o Arquimago, um mago <br>das trevas que quer dominar o mundo.<br><br>* A Princesa Prometida: Este filme é uma comédia romântica de fantasia que <br>conta a história de Buttercup, uma jovem que é prometida em casamento a um <br>príncipe malvado, mas é salva por Westley, um pirata que a ama.<br><br>* Willow: Este filme conta a história de Willow, um fazendeiro que é <br>escolhido para proteger uma criança especial de uma rainha malvada.<br><br>* O Cristal Encantado: Este filme conta a história de Jen, um jovem que <br>deve viajar para o Castelo de Cristal para salvar seu amigo Kira, que foi <br>sequestrada por um Skeksis, uma criatura malvada.</pre><h3>Iniciando com interações multimodais</h3><p>Agora a parte mais legal: Enviando imagens e/ou vídeo junto com o seu prompt de texto.</p><p>O primeiro passo é importar a versão do Gemini Pro com suporte a visão computacional:</p><pre>multimodal_model = GenerativeModel(&quot;gemini-pro-vision&quot;)</pre><p>O cenário que vamos fazer é o seguite: Vamos pedir pro modelo raciocinar e calcular informações contextuais de duas imagem. A primeira imagem é uma cesta de frutas e a segunda imagem é uma tabela de preços:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/484/0*svM8FUDGKcz04kxG" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/444/0*edsV58CWLWWZa48X" /><figcaption>Duas imagens de exemplos que utilizaremos: Uma cesta de frutas e uma tabela de preços</figcaption></figure><p>Vamos pedir ao modelo que interprete ambas imagens e que calcule o quanto ficaria esta “compra” (considerando que compremos todas as frutas disponíveis na primeira imagem, pagando o preço na tabela da segunda imagem):</p><pre>image_grocery_url = &quot;https://storage.googleapis.com/github-repo/img/gemini/multimodality_usecases_overview/banana-apple.jpg&quot;<br>image_prices_url = &quot;https://storage.googleapis.com/github-repo/img/gemini/multimodality_usecases_overview/pricelist.jpg&quot;<br>image_grocery = load_image_from_url(https://medium.com/image_grocery_url)<br>image_prices = load_image_from_url(https://medium.com/image_prices_url)<br>instructions = &quot;Instruções: Considere a imagem a seguir que contem frutas:&quot;<br><br>prompt1 = &quot;Quanto eu pagarei portas frutas considerando esta tabela de preços?&quot;<br><br>prompt2 = &quot;&quot;&quot;<br>Responda à pergunta através destas etapas:<br>Passo 1: Identifique que tipo de fruta existe na primeira imagem.<br>Passo 2: Conte a quantidade de cada fruta.<br>Passo 3: Para cada item da primeira imagem, verifique o preço do item na tabela de preços.<br>Passo 4: Calcule o preço subtotal de cada tipo de fruta.<br>Passo 5: Calcule o preço total das frutas usando os subtotais.<br>Responda e descreva as etapas realizadas:&quot;&quot;&quot;<br><br>contents = [<br>instructions,<br>image_grocery,<br>prompt1,<br>image_prices,<br>prompt2,<br>]<br><br>responses = multimodal_model.generate_content(contents, stream=True)</pre><p>Com isso temos como resposta:</p><pre>for response in responses:<br>  print(response.text, end=&quot;&quot;)<br><br>Passo 1: Identifique que tipo de fruta existe na primeira imagem.<br>Existem 2 bananas e 3 maçãs.<br><br>Passo 2: Conte a quantidade de cada fruta.<br>Bananas: 2<br>Maçãs: 3<br><br>Passo 3: Para cada item da primeira imagem, verifique o preço do item na tabela de preços.<br>Banana: $ 0,80<br>Maçã: $ 1,50<br><br>Passo 4: Calcule o preço subtotal de cada tipo de fruta.<br>Banana: 2 x $ 0,80 = $ 1,60<br>Maçã: 3 x $ 1,50 = $ 4,50<br><br>Passo 5: Calcule o preço total das frutas usando os subtotais.<br>$ 1,60 + $ 4,50 = $ 6,10<br><br>Portanto, o preço total das frutas é de $ 6,10.</pre><p>Ou seja, o modelo conseguiu:</p><ul><li>Entender o que está presente na primeira imagem, incluindo realizar contagem de objetos</li><li>Entender a estrutura de informações da segunda imagem</li><li>Entender as informações textuais da segunda imagem</li></ul><p>Poxa, Luciano… E vídeos? Tem vídeos também. E a interação é bem parecida. Para este exemplo, vou usar um vídeo da cidade de Antalya, na Turquia e vamos pedir informações sobre o vídeo para o modelo (sem dar nenhuma “cola” — documento de referência, pistas, etc). Aqui é um screenshot do vídeo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/596/0*s8TkhibEWF8BascX" /></figure><pre>prompt = &quot;&quot;&quot;<br>O que é mostrado neste vídeo?<br>Onde devo ir para ver isso?<br>Quais são 5 outros lugares do mundo com esta aparência?<br>&quot;&quot;&quot;<br><br>video = Part.from_uri(<br>uri=&quot;gs://github-repo/img/gemini/multimodality_usecases_overview/mediterraneansea.mp4&quot;,<br>mime_type=&quot;video/mp4&quot;,<br>)<br>contents = [prompt, video]<br>responses = multimodal_model.generate_content(contents, stream=True)</pre><p>E o resultado é como abaixo:</p><pre>for response in responses:<br>  print(response.text, end=&quot;&quot;)<br><br>O vídeo mostra a cidade de Antalya, na Turquia. Antalya é uma cidade costeira <br>localizada no sul da Turquia, banhada pelo Mar Mediterrâneo. A cidade é um <br>importante destino turístico, com praias, hotéis e resorts.<br><br>Você pode ir para Antalya de avião, carro ou ônibus. O aeroporto de Antalya <br>fica a cerca de 10 km do centro da cidade. De carro, você pode chegar a <br>Antalya pela rodovia D400. De ônibus, você pode pegar um ônibus de Istambul, <br>Ankara ou Izmir.<br><br>Aqui estão 5 outros lugares do mundo com aparência semelhante a Antalya:<br><br>1. Cinque Terre, Itália<br>2. Costa Amalfitana, Itália<br>3. Ilhas Phi Phi, Tailândia<br>4. Baía de Halong, Vietnã<br>5. Ilha de Santorini, Grécia</pre><p>Esse tipo de interação abre oportunidade para interpretar vídeos, realizar recomendações, extrair tags de conteúdos, etc.</p><h3>Conclusão</h3><p>E aí? Curtiram a ideia e a interação? Tiveram ideias de cenários que este tipo de interação, interpretação e <em>reasoning</em> podem te ajudar?</p><p>Compartilha aí! Se quiser escrever um blog aqui também e compartilhar sua experiência (de preferência compartilhando aquele código maroto junto), me dá um alô nas redes sociais e bora fazer isso 🙂</p><p>Nos próximos posts teremos mais aprofundamento em outros cenários — Mas para ter um spoiler de outras coisas que dá pra fazer, deem olhada neste meu repositório no GitHub: <a href="https://github.com/lucianommartins/generative-ai-ptbr">https://github.com/lucianommartins/generative-ai-ptbr</a></p><p>Vale a pena dar uma olhada também na documentação oficial da Gemini API da Vertex AI: <a href="https://cloud.google.com/vertex-ai/docs/generative-ai/model-reference/gemini?hl=pt-br">https://cloud.google.com/vertex-ai/docs/generative-ai/model-reference/gemini?hl=pt-br</a>.</p><p>E também o repositório oficial do time de Cloud AI Advocacy constantemente sendo populado com novos códigos, aplicações de exemplo e use cases: <a href="https://www.github.com/GoogleCloudPlatform/generative-ai">https://www.github.com/GoogleCloudPlatform/generative-ai</a></p><p>Um abraço!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=623083cf8780" width="1" height="1" alt=""><hr><p><a href="https://medium.com/google-cloud-brasil/primeiros-passos-com-o-gemini-na-vertex-ai-623083cf8780">Primeiros passos com o Gemini na Vertex AI</a> was originally published in <a href="https://medium.com/google-cloud-brasil">google-cloud-brasil</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desenvolvendo com Llama2 na Google Cloud]]></title>
            <link>https://medium.com/google-cloud-brasil/desenvolvendo-com-llama2-na-google-cloud-e5b7b3d0ca14?source=rss-925379214ac4------2</link>
            <guid isPermaLink="false">https://medium.com/p/e5b7b3d0ca14</guid>
            <category><![CDATA[vertex-ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Luciano Martins]]></dc:creator>
            <pubDate>Mon, 09 Oct 2023 11:41:38 GMT</pubDate>
            <atom:updated>2023-10-09T11:41:38.211Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KpADpNh6HJT3zulK" /><figcaption>Uma imagem de uma llama com óculos escuros (gerada pelo modelo <a href="https://cloud.google.com/vertex-ai/docs/generative-ai/image/overview">Imagen</a> da Google Cloud)</figcaption></figure><h3>Introdução</h3><p>Faz um tempo que apareço por aqui e muita coisa aconteceu desde a última postagem — Rolou o Live+Labs São Paulo, o Google Cloud Next com diversas novidades, bonde de Cloud AI de Google Cloud Brasil colou no TDC Business 2023 e o Google Cloud Summit Brasil… ufa!</p><p>Tem muita novidade legal que vou trazer aqui nos próximos posts… Mas uma em especial que eu queria trazer hoje: o <a href="https://ai.meta.com/blog/large-language-model-llama-meta-ai/">LlaMA2</a> — um modelo de linguagem gigante (ou Large Language Model, ou LLM), auto-regressivo baseado em <a href="https://blog.research.google/2017/08/transformer-novel-neural-network.html">transformers</a>, open source e gratuito para uso de pesquisa e comercial desenvolvido pela <a href="https://ai.meta.com/">Meta AI</a> — disponível para uso dentro da Google Cloud!</p><p>As principais características técnicas do Llama2 são:</p><ul><li>Treinado em um dataset misto de dados públicos, com cerca de 2T <em>tokens</em></li><li>Suporte a contextos de 4K <em>tokens</em></li><li>Vários tamanhos disponíveis: 7B, 13B, 34B e 70B de parâmetros</li></ul><p>O <a href="https://arxiv.org/abs/2307.09288">paper do Lllama2</a> tem maiores e mais profundos detalhes sobre o modelo e sua arquitetura.</p><p>Desde o Google Cloud Next 2023) você pode utilizar e até realizar <em>fine tuning</em> de várias versões do Llama2 dentro da Google Cloud, utilizando a <a href="https://cloud.google.com/vertex-ai/">Vertex AI</a> e a <a href="https://cloud.google.com/model-garden">Model Garden</a>.</p><p>Antes de exercitarmos o uso do modelo — O que seria a Model Garden?</p><h3>A Model Garden da Vertex AI</h3><p>A <a href="https://cloud.google.com/model-garden">Model Garden</a> é um biblioteca centralizada de modelos, dentro da Vertex AI, onde você encontra ferramentas e mecanismos para utilizar modelos desenvolvidos pelo Google e alguns open source — tanto de forma diretamente pré-treinada (simplesmente implantando em uma API) ou, para alguns modelos, a habilidade de refinamento (ou <em>fine tuning</em>) com datasets para tarefas específicas.</p><p>A visão geral da Model Garden é como abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EfVZokVrnhxcDCsv" /><figcaption>Página inicial da Model Garden dentro da console da Vertex AI</figcaption></figure><p>É sua primeira vez navegando na Model Garden? Ou não sabe, exatamente, qual modelo você quer utilizar para o seu cenário? Sem problemas! Você encontra na console filtros para casos de uso específico, ou possibilidade de <em>fine tuning</em>, uso de jupyter notebooks, etc:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*i9mD3e78lyxT192SYdmpaA.png" /><figcaption>Alguns dos filtros de busca de modelos da Model Garden: por tarefa, por modalidade e por funcionalidades</figcaption></figure><h3>Acessando o modelo Llama 2</h3><p>Neste blog vamos fazer uma experimentação rápida: Como utilizar um modelo direto da Model Garden e implantando em uma API para uso via chamadas REST e/ou chamadas via SDK em Python. Mais especificamente, vamos utilizar o modelo Llama 2.</p><p>Primeiro devemos encontrá-lo na Model Garden — fazemos a busca por Llama 2:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*NJ7_BZOpwFuDI_IQ" /><figcaption>Encontrando o modelo Llama 2 realizando uma busca na Model Garden</figcaption></figure><p>Caso seja a primeira vez que você entre na página do Llama 2, você terá que ler e aceitar a licença de uso do modelo antes de continuar:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/623/0*M9N6tHriZbde1mzl" /><figcaption>Licença de utilização do modelo Llama 2</figcaption></figure><p>Com o termo aceito, você verá a página inicial do Llama 2 dentro da Model Garden incluindo detalhes do modelo e as variantes disponíveis para uso (7B, 13B e 70B de parâmetros):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1018/0*fvRrNTx-8X_yvLrg" /></figure><p>Aqui vamos implantar o modelo de duas formas: usando a interface de usuário da console e usando a SDK da Vertex AI.</p><h3>Implantando o Llama 2 usando a console da Vertex AI</h3><p>Para começar o processo de implantação do modelo, iremos clicar no botão “deploy” (ou “implantar” se sua console estiver em português):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/0*Ct6p5yewAtLcYHqu" /><figcaption>Página inicial do modelo Llama 2 na model Garden com a opção de implantar o modelo pré-treinado</figcaption></figure><p>Na primeira tela de implantação do modelo, você deve primeiro escolher qual variante do modelo você quer usar (tendo modelos de geração de texto e chat e em tamanhos diferentes):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/521/0*HQWk8awNM62s2Sev" /><figcaption>Tipos e tamanhos disponíveis para o modelo Llama 2</figcaption></figure><p>Após isso você irá escolher o “nome” que o modelo será salvo no seu projeto (ele será &quot;copiado&quot; de um local público para dentro do seu projeto) e em qual região a implantação ocorrerá (aqui no meu caso, deixei na região us-central1):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/541/0*NJNSJYCKOdzgXzKj" /><figcaption>Nome e região onde a cópia do modelo Llama 2 será salva</figcaption></figure><p>Após isso, clique em “save” (ou “salvar”). Na tela seguinte você irá definir as informações de <em>endpoint</em> do modelo — ou o <em>backend</em> que a Vertex AI irá utilizar para implantar o seu modelo. Primeiro você irá escolher o nome do seu <em>endpoint</em> e o tipo de acesso (se será público ou somente em uma rede privada):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/673/0*C5_zDYngif8b9WFt" /><figcaption>Nome do endpoint e método de acesso ao endpoint (público ou privado)</figcaption></figure><p>Na tela seguinte você deve escolher a configuração de máquinas que irá ser utilizada no backend do <em>endpoint</em>, se algum acelerador será utilizado (aqui no nosso caso, iremos utilizar uma GPU NVIDIA V100) e a configuração de <em>autoscaling</em>. No meu lab aqui, a configuração ficou como abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/670/0*cQxU9A7gqfBwDCBP" /><figcaption>Definições de autoscaling e configurações de máquina para o seu endpoint com a Llama 2</figcaption></figure><p>Após isso, você clica em “done” e em “deploy” (ou implantar). Após alguns minutos, seu modelo estará implantado como <em>endpoint </em>da Vertex AI. O modelo aparecerá como salvo na Model Registry da Vertex AI:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4qAvABPtZrhkM3YB" /><figcaption>Sua cópia do modelo Llama 2 dentro da Model Registry do seu projeto</figcaption></figure><p>E também o endpoint aparecerá como disponível como <em>endpoint</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/0*jr69J6Vabqzrcy-Q" /><figcaption>Seu endpoint com o modelo Llama 2 implantado</figcaption></figure><p>E se clicarmos no nome do <em>endpoint</em>, podemos confirmar que nosso modelo Llama2 está implantado lá dentro:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/729/0*bLpLTDpGaHafuBCB" /><figcaption>Modelo Llama 2 disponível dentro do seu endpoint</figcaption></figure><p>Agora vamos ver como realizar este mesmo processo, mas dessa vez via SDK da Vertex AI.</p><h3>Implantando o Llama 2 usando a SDK da Vertex AI</h3><p>Para muitas equipes de desenvolvimento, o uso da console não é o mais prático (seja por habilidade com uso de SDK em geral, ou seja pela utilização de ferramentas de automação como Terraform). Assim, iremos realizar também a implantação do Llama 2 utilizando a SDK da Vertex AI.</p><p>Dentro da própria Model Garden você encontra um jupyter notebook pronto para isso — basta clicar no botão “Open Notebook” na página do Llama 2 da Model Garden:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/0*Ct6p5yewAtLcYHqu" /><figcaption>Página inicial do modelo Llama 2 na model Garden com a opção de abrir o notebook de exemplo</figcaption></figure><p>Para instalar a SDK da Vertex AI no seu ambiente Python, você precisa de apenas um pip install. Ele instalará a SDK da Vertex AI e todos os seus requisitos:</p><pre>pip install google-cloud-aiplatform</pre><p>Depois disso, você deve importar os módulos utilizados no resto do código:</p><pre>import os<br>import sys<br>from google.cloud import aiplatform</pre><p>E definir as variáveis que utilizaremos no código:</p><pre># project id que será utilizado no lab<br>PROJECT_ID = &quot;lucianomartins-demos-345000&quot;<br><br># a região onde realizaremos os testes<br>REGION = &quot;us-central1&quot;<br><br># as configurações de máquina que serão<br># utilizadas no endpoint do modelo<br>machine_type = &quot;n1-standard-8&quot;<br>accelerator_type = &quot;NVIDIA_TESLA_V100&quot;<br>accelerator_count = 1<br><br># precisão utilizada com o modelo<br># a recomendação para o uso direto do modelo<br># pré-treinado é &#39;float16&#39;<br>precision_loading_mode = &quot;float16&quot;</pre><p>Para fazermos o deploy do modelo, iremos utilizar uma função que chamaremos aqui de deploy_model() como abaixo:</p><pre>def deploy_model(<br>model_name,<br>base_model_name,<br>task,<br>precision_loading_mode,<br>machine_type,<br>accelerator_type,<br>accelerator_count,<br>):<br><br>&quot;&quot;&quot;Deploys trained models into Vertex AI.&quot;&quot;&quot;<br>endpoint = aiplatform.Endpoint.create(display_name=&quot;meu-endpoint-llama2–002&quot;)<br>serving_env = {<br>&quot;BASE_MODEL_ID&quot;: base_model_name,<br>&quot;PRECISION_LOADING_MODE&quot;: precision_loading_mode,<br>&quot;TASK&quot;: task,<br>}<br><br>model = aiplatform.Model.upload(<br>display_name=model_name,<br>serving_container_image_uri=&quot;us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-peft-serve&quot;,<br>serving_container_ports=[7080],<br>serving_container_predict_route=&quot;/predictions/peft_serving&quot;,<br>serving_container_health_route=&quot;/ping&quot;,<br>serving_container_environment_variables=serving_env,<br>)<br><br>model.deploy(<br>endpoint=endpoint,<br>machine_type=machine_type,<br>accelerator_type=accelerator_type,<br>accelerator_count=accelerator_count,<br>deploy_request_timeout=1800<br>)<br>return model, endpoint</pre><p>Após isso devemos definir o tipo e a versão do modelo que queremos utilizar:</p><pre>base_model_name = &quot;gs://vertex-model-garden-public-us-central1/llama2/llama2–7b-hf&quot;</pre><p>E então realizamos o deploy do modelo:</p><pre>modelo, endpoint = deploy_model(<br>model_name=&quot;minha-api-llama2–002&quot;,<br>task=&quot;causal-language-modeling-lora&quot;,<br>base_model_name=base_model_name,<br>precision_loading_mode=precision_loading_mode,<br>machine_type=machine_type,<br>accelerator_type=accelerator_type,<br>accelerator_count=accelerator_count)<br><br>print(&quot;endpoint_name:&quot;, endpoint.name)</pre><p>Ao final desse processo, você deve ver um resultado similar ao abaixo:</p><pre>Creating Endpoint<br>Create Endpoint backing LRO: projects/48397268769/locations/us-central1/endpoints/6097612211692240896/operations/559281639033667584<br>Endpoint created. Resource name: projects/48397268769/locations/us-central1/endpoints/6097612211692240896<br>To use this Endpoint in another session:<br>endpoint = aiplatform.Endpoint(&#39;projects/48397268769/locations/us-central1/endpoints/6097612211692240896&#39;)<br><br>Creating Model<br>Create Model backing LRO: projects/48397268769/locations/us-central1/models/6779137897099427840/operations/6850810318470250496<br>Model created. Resource name: projects/48397268769/locations/us-central1/models/6779137897099427840@1<br>To use this Model in another session:<br>model = aiplatform.Model(&#39;projects/48397268769/locations/us-central1/models/6779137897099427840@1&#39;)<br><br>Deploying model to Endpoint : projects/48397268769/locations/us-central1/endpoints/6097612211692240896<br>Deploy Endpoint model backing LRO: projects/48397268769/locations/us-central1/endpoints/6097612211692240896/operations/1658159948112068608<br>Endpoint model deployed. Resource name: projects/48397268769/locations/us-central1/endpoints/6097612211692240896<br><br>endpoint_name: 6097612211692240896</pre><p><strong>Parabéns!!</strong> Você finalizou o seu processo de implantação do Llama2–7B utilizando a SDK da Vertex AI!</p><h3>Realizando inferências com a API implantada com o Llama 2</h3><p>A última etapa desta nossa experimentação é, finalmente, realizar inferências com o Llama 2. Da mesma forma que realizamos a implantação via console e via SDK da Vertex AI, iremos realizar testes de inferência das duas formas também.</p><p>Para o teste via console, você deve ir até a <a href="https://console.cloud.google.com/vertex-ai/models">Model Registry</a> e clicar no seu modelo (aqui, tanto faz se você usar o modelo criado via console ou SDK). Na aba “deploy &amp; test” você encontrará uma caixa de texto com o nome “JSON request” como abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/891/0*voHmOZxIGacvpYxY" /><figcaption>Acessando a tela de teste de endpoints na console da Vertex AI</figcaption></figure><p>Para este teste enviaremos a pergunta “what is artificial intelligence?” (ou “o que é inteligência artificial” em português). Estamos enviando a requisição em inglês pois o modelo pré-treinado Llama 2 só suporta oficialmente o idioma Inglês. O JSON da requisição ficará como abaixo:</p><pre>{<br>  &quot;instances&quot;: [<br>  {<br>    &quot;prompt&quot;: &quot;what is artificial intelligence?&quot;<br>  }<br>  ],<br>  &quot;parameters&quot;: {<br>    &quot;max_length&quot;: 400,<br>    &quot;top_k&quot;: 10<br>  }<br>}</pre><p>A resposta será vista na caixa “response” semelhante a imagem abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ccsQVcyGvTebWCYp" /><figcaption>Resultado da inferência realizada via console da Vertex AI</figcaption></figure><p>Para realizar a inferência via SDK, só temos que saber o id do <em>endpoint</em> a ser utilizado e enviar a inferência. Algo como abaixo:</p><pre># variáveis importantes<br>PROJECT_ID=&quot;lucianomartins-demos-345000&quot;<br>REGION=&quot;us-central1&quot;<br>ENDPOINT_ID=&quot;6097612211692240896&quot;<br><br># endpoint do modelo<br>endpoint_name =f&quot;projects/{PROJECT_ID}/locations/{REGION}/endpoints/{ENDPOINT_ID}&quot;)<br>endpoint = aiplatform.Endpoint(aip_endpoint_name)<br><br># prompt que será enviado ao modelo<br>instances = [<br>{&quot;prompt&quot;: &quot;what is artificial intelligence?&quot;, &quot;max_length&quot;: 400, &quot;top_k&quot;: 10},<br>]<br><br># envio da solicitação à API do Llama2<br>response = endpoint.predict(instances=instances)<br><br># visualização da resposta<br>for prediction in response.predictions[0]:<br>print(prediction[&quot;generated_text&quot;])</pre><p>O resultado será similar ao abaixo:</p><pre>what is artificial intelligence? It&#39;s not just a computer that plays chess better than anyone. But it&#39;s more than that as well, because there are things that computers can&#39;t do.<br>There&#39;s a lot more involved and there&#39;s a lot of different things that we don&#39;t fully understand.<br>And the reason that we don&#39;t fully understand is that computers don&#39;t have a soul, they don&#39;t have emotions. It&#39;s really hard for people to understand that. I can&#39;t explain it.<br>I don&#39;t know how you feel when you look at a computer screen and you have this feeling, I don&#39;t know, this feeling of &quot;oh, that&#39;s not real&quot;, it&#39;s very hard for me to understand how somebody can say, &quot;Oh, that&#39;s not real&quot; when they have no emotions.<br>And that&#39;s the kind of thing that makes computers hard to get into computers.<br>So, it&#39;s like a lot of other things that make it harder, I think a lot of people who are trying to get into computers, they&#39;re looking at this and saying, &quot;Oh, that&#39;s not real, that&#39;s a computer&quot;, and they don&#39;t realize the difference.<br>I don&#39;t think it&#39;s a computer in the sense of a machine.<br>And then you have the whole other side of it, like a human being, and the computer can make you think that&#39;s a person.<br>It&#39;s like, &quot;Oh my God, I&#39;m just a human.<br>And then I can make you say that I&#39;m a computer&quot;.<br>You can have this whole thing, where you&#39;re a human being, and you&#39;re like, &quot;Wow, you&#39;re a machine&quot; and then the computer makes you a human and it makes you a computer.<br>So you can think you&#39;</pre><h3>Conclusão</h3><p>De uma forma bem simples, utilizamos a facilidade da Model Garden para implantar e realizar inferências utilizando o modelo Llama 2 desenvolvido pela Meta AI.</p><p>O mais interessante da Model Garden é que a interação e o uso são simples para todos os modelos disponíveis — Ou seja, sem muito esforço de infraestrutura e implantação para termos mais tempo para o que realmente importa: Desenvolver com um modelo de machine learning.</p><p>Em um próximo blog, vamos juntos na experimentação de <em>fine tuning</em> do Llama2 — ou o processo de incluir “conhecimento” adicional ao modelo via um <em>dataset</em> que contenha informações que o modelo não teve acesso no seu treinamento.</p><p>E vocês? Estão nessa jornada com modelos comerciais ou <em>open source</em>? Tem alguma dúvida com esse processo dentro da Google Cloud? Compartilha aí sua jornada e quem sabe não escrevemos o próximo blog sobre isso juntos? 🙂</p><p>Um abraço e até a próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e5b7b3d0ca14" width="1" height="1" alt=""><hr><p><a href="https://medium.com/google-cloud-brasil/desenvolvendo-com-llama2-na-google-cloud-e5b7b3d0ca14">Desenvolvendo com Llama2 na Google Cloud</a> was originally published in <a href="https://medium.com/google-cloud-brasil">google-cloud-brasil</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desenvolvendo soluções com IA Generativa na Google Cloud]]></title>
            <link>https://medium.com/google-cloud-brasil/desenvolvendo-solu%C3%A7%C3%B5es-com-ia-generativa-na-google-cloud-d22d148048a3?source=rss-925379214ac4------2</link>
            <guid isPermaLink="false">https://medium.com/p/d22d148048a3</guid>
            <category><![CDATA[vertex-ai]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[generative-ai]]></category>
            <category><![CDATA[large-language-models]]></category>
            <dc:creator><![CDATA[Luciano Martins]]></dc:creator>
            <pubDate>Tue, 16 May 2023 13:18:29 GMT</pubDate>
            <atom:updated>2023-05-16T13:18:29.546Z</atom:updated>
            <content:encoded><![CDATA[<p><strong><em>* TLDR: No Google I/O 2023, as API de Generative AI </em>de Google Cloud foram disponibilizadas (em preview) para os desenvolvedores<em>.</em> Vamos fazer uma “primeira jornada” no potencial desses serviços utilizando o Generative AI Studio da Vertex AI.</strong></p><h3>Como chegamos até aqui?</h3><p>No <a href="https://io.google/2023/">Google I/O 2023</a>, dentre diversos outros lançamentos relacionados a inteligência artificial, tivemos o lançamento das funcionalidades de <em>Generative AI </em>(IA Generativa em português), ou simplesmente GenAI, dentro do universo de produtos e tecnologias do Google — Cloud, Workspace, Pixel e etc.</p><p>Mas antes de ir para o serviço em si, meio que para traçar uma linha de base conceitual, para quem já conhece a área de GenAI revisar os conceitos e quem está começando agora, conhecê-los.</p><h3>E tudo começou com Transformers</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/495/0*nZk0860PX91fT-sM" /><figcaption>Estes <em>transformers</em> são importantes também, mas não estamos falando deles</figcaption></figure><p>A arquitetura <em>Transformers</em> é um tema que merece uma postagem dedicada (tá no backlog aqui). Mas tentando falar da forma mais sucinta possível: <em>Transformers</em> é uma arquitetura de modelos de aprendizado de máquina <a href="https://arxiv.org/abs/1706.03762">desenvolvida pelo Google e publicada em 2017</a>. Ela trabalha usando <a href="https://developers.google.com/machine-learning/glossary?hl=pt-br#attention">mecanismos de atenção</a> para aprender as relações entre diferentes partes de uma sequência de entrada, permitindo aprender padrões mais complexos do que os modelos tradicionais. A arquitetura <em>Transformers</em> serve como base para a maioria dos modelos atualmente considerados “estado da arte” (<em>State Of The Art</em>, ou SOTA, em inglês) — incluindo processamento de linguagem natural, tradução automática e reconhecimento de imagem (mas também usados em outras áreas).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xpdORDjq0ez_y_4h" /><figcaption>um exemplo de arquitetura transformer e de como funciona seu mecanismo de &quot;encoder&quot; e &quot;decoder&quot;</figcaption></figure><p>Uma maneira de pensar em <em>transformers</em> é imaginar que você está tentando traduzir uma frase do português para o francês. Um modelo tradicional de aprendizado de máquina primeiro aprenderia um vocabulário de palavras e depois tentaria encontrar as palavras no idioma francês que correspondem às palavras na frase em inglês. No entanto, isso não seria muito preciso, porque não levaria em conta o contexto das palavras. Por exemplo, a palavra “banco” pode significar uma instituição financeira ou o equipamento que sentamos. Um <em>transformer</em>, por outro lado, seria capaz de aprender o significado da palavra “banco” com base no contexto em que é usada. Por exemplo, se a palavra “banco” for seguida pela palavra “conta”, é mais provável que se refira a uma instituição financeira.</p><h3>Modelos Fundamentais ou Foundation Models</h3><p>Modelos Fundamentais, ou <em>foundation models</em> em inglês, são modelos gigantes que podem ser adaptados para uma variadade de cenários (ou <em>tasks</em> como se fala no mundo de IAs Generativas) que são treinados em volumes muito grandes de dados — Exemplos de modelos fundamentais podem ser o <a href="https://ai.googleblog.com/2018/11/open-sourcing-bert-state-of-art-pre.html">BERT</a> (Bidirectional Encoder Representations from Transformers) e o <a href="https://ai.googleblog.com/2022/04/pathways-language-model-palm-scaling-to.html">PaLM</a> ( Pathways Language Model), ambos desenvolvidos pelo Google Research.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KDtbmrxzbBmfBXQi" /><figcaption>Uma abstração da idéia de modelos fundamentais e suas várias utilidades</figcaption></figure><h3>Large Language Models</h3><p>Modelos de linguagem gigantes, numa tradução livre, ou <em>Large Language Models </em>do inglês (ou ainda LLM) são modelos treinados em grandes quantidades de dados de texto. Isso permite que eles gerem texto, façam traduções de alta qualidade entre idiomas, escrevam diferentes tipos de conteúdo criativo e respondam às suas perguntas de maneira informativa. Há muitos esforços — acadêmicos, de comunidades e de empresas — que estão acelerando a evolução desta área de pesquisa de inteligência artificial. Aqui deixo, como referência, o histórico recente do Google nesta área de pesquisa:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ciPPWlXGsWavLB-W" /><figcaption>linha do tempo de pesquisas Google relacionadas a modelos de processamento de linguagem</figcaption></figure><h3>Prompts — o que são, para que servem, porque se importar com eles?</h3><p>Dos conceitos principais, se este não for o mais importante deles, talvez seja o que tenhamos que refinar melhor em nossas mentes — pois é o que mais utilizaremos no dia a dia, como desenvolvedores ou pessoas interagindo com modelos generativos.</p><p><em>Prompts</em> (acho que essa é uma daquelas palavras que não foram traduzidas, foi adotada pelo processo que chamamos de <a href="https://pt.wikipedia.org/wiki/Anglicismo">anglicismo</a>) são a forma que provemos contexto, ou direcionamentos, para os LLM. Os <em>prompts</em> são utilizados em todos os contextos que utilizamos LLM — geração de texto, tradução de idiomas, criação de conteúdos, cenários de perguntas e respostas, etc.</p><p>Por exemplo, se queremos que o nosso modelo escreva um poema sobre a cidade de Belém do Pará, enviamos o seguinte prompt para o modelo:</p><blockquote>“Escreva um poema sobre a cidade de Belém do Pará”</blockquote><p>Ou para solicitar ao modelo uma tradução de inglês para português:</p><blockquote>“Traduza a sentença ‘I love you’ para português”</blockquote><p>Tarefas mais complexas e com detalhamentos mais específicos também podem ser realizadas utilizando <em>prompts</em> — por exemplo:</p><blockquote>&quot;escreva um texto, com dois parágrafos, sobre computação quântica”.</blockquote><p>Mas <em>prompts</em> podem ter diferente formatos — alguns possíveis são:</p><p><strong>Zero-shot: </strong>Em uma solicitação de tarefa, o modelo pode usar seu conhecimento aprendido durante o seu treinamento para gerar uma solução. Nenhuma informação adicional (como contexto, textos ou exemplos) é dada ao modelo durante a solicitação.</p><p><strong>One-shot: </strong>Em uma nova solicitação de tarefa, o modelo recebe um único exemplo de “pergunta e resposta”, ou de “texto e classificação” ou de qualquer que seja a tarefa a ser executada.</p><p><strong>Few-shot: </strong>Em uma nova solicitação de tarefa, o modelo recebe alguns exemplos da nova tarefa e é capaz de gerar uma solução. Os poucos exemplos funcionam como um “refinamento” do treinamento em tempo de inferência, dando direcionamentos mais detalhados ao modelo de como responder (em determinado formato, ou usando determinadas palavras).</p><p>Uma das principais diferenças entre as três abordagens é a quantidade de dados de treinamento necessários, uma vez que entregamos ao modelo exemplos validados e confiáveis do que o modelo deve fazer. Enquanto na abordagem <strong>one-shot</strong> não precisamos de dados adicionais, na abordagem <strong>few-shot </strong>precisamos de mais exemplos (além dos usados para treinar o modelo inicialmente).</p><p>Por outro lado, da perspectiva de eficiência do modelo, para tarefas mais específicas e mais complexas, a abordagem <strong>few-shot</strong> pode apresentar melhores resultados (esse cenário é válido também para aqueles cenários onde é trabalhoso ou muito caro gerar um dataset grande e dedicado para a tarefa em questão).</p><p>Bom, acho que com esse preâmbulo, podemos ir para a parte mais divertida — desenvolvendo com a Vertex AI.</p><h3>Generative AI na Vertex AI</h3><p>Dentro da Google Cloud, há para todos os usuários e desenvolvedores a <a href="http://cloud.google.com/vertex-ai/">Vertex AI</a> — uma plataforma de desenvolvimento de soluções com machine learning na Google Cloud.</p><p>No Google I/O 2023 foram lançados dois grandes serviços, em <em>public preview</em>, como parte como ecossistema da Vertex AI — O <a href="https://cloud.google.com/model-garden">Vertex AI Model Garden</a> e o <a href="https://cloud.google.com/generative-ai-studio">Vertex AI Generative AI Studio</a>. Para uma visão inicial, podemos imaginar a estrutura abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UqryYCwZbX1LjV-Y" /><figcaption>visão geral das funcionalidades da Vertex AI na Google Cloud</figcaption></figure><p>Navegando em sua <a href="https://console.cloud.google.com/vertex-ai">console da Vertex AI</a>, você verá alguns menus adicionais como abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/451/0*Kwxj4_poWZYQEHsq" /><figcaption>Novos serviços disponíveis na console da Vertex AI</figcaption></figure><p>Ou seja, Generative AI Studio, com opções de linguagem e sintetização/reconhecimento de fala e o Model Garden.</p><h3>Iniciando com a Vertex AI Model Garden</h3><p>A <a href="https://console.cloud.google.com/vertex-ai/model-garden">Vertex AI Model Garden</a> é a funcionalidade da Vertex AI que aceleram o seu processo de desenvolvimento fornecendo <em>foundation models</em>, modelos desenvolvidos pela Google Research e modelos open source:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*J_1mfK1J4pedd1X4" /><figcaption>visão geral do Model Garden na console da Vertex AI</figcaption></figure><p>O Model Garden serve como um local central para encontrar os modelos disponíveis dentro da Google Cloud — nele você encontrará os modelos e as tarefas (ou <em>tasks</em>) possíveis de serem realizadas com as API gerenciadas (como <a href="https://cloud.google.com/vision">Vision API</a>, <a href="https://cloud.google.com/natural-language">Natural Language API</a> e as API de Speech [<a href="https://cloud.google.com/speech-to-text">Speech-to-Text</a> e <a href="https://cloud.google.com/text-to-speech">Text-to-Speech</a>]).</p><p>Para alguns passo-a-passo de como navegar no Model Garden, visite a seção <a href="https://cloud.google.com/vertex-ai/docs/start/explore-models">Explorando Modelos</a> da documentação do Model Garden.</p><h3>Iniciando com a Vertex AI Generative AI Studio</h3><p>Agora a parte que, para mim, é a mais interessante e divertida 🙂</p><p>Também durante o Google I/O 2023, foi anunciada a mais nova versão do modelo PaLM — o <a href="https://ai.google/discover/palm2">PaLM 2</a>. E na Vertex AI você tem disponível o que chamamos de PaLM APIs via o <a href="https://cloud.google.com/generative-ai-studio">Generative AI Studio</a>.</p><p>O <a href="https://cloud.google.com/generative-ai-studio">Generative AI Studio</a>, em <em>private preview</em>, é um ambiente gerenciado (ou seja, onde você não se preocupa com a gestão de infraestrutura) que simplifica o seu processo de desenvolvimento na interação, refinamento e implantação de modelos generativos. O mais legal é que você consegue fazer isso tudo usando o SDK da Vertex AI (no que focaremos aqui).</p><p>Na console da Vertex AI você consegue acessar diretamente o <a href="https://console.cloud.google.com/vertex-ai/generative">Generative AI Studio</a>, onde você encontra uma interface simples — como abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*teRClnTm-37YaF26" /><figcaption>visão geral do Generative AI Studio na console da Vertex AI</figcaption></figure><p>Especialmente na parte de linguagem, há um mundo de coisas que podem ser feitas — vamos navegar em alguns exemplos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SIolAI9pIZnHZzef" /><figcaption>Algumas das tarefas que podem ser realizadas na Vertex AI Generative AI Studio</figcaption></figure><p>Vale ressaltar que, como um produto em <em>public preview</em>, há algumas características para serem consideradas:</p><ol><li>No momento há três modelos disponíveis publicamente: <strong>text-bison-001 </strong>(para geração de texto), <strong>chat-bison-001</strong> (para cenários conversacionais) e <strong>textembeddings-gecko-001</strong> (para a geração de <a href="https://developers.google.com/machine-learning/crash-course/embeddings/video-lecture?hl=pt-br">text embeddings</a> a partir de entradas de texto). Na documentação você encontrará uma lista sempre atualizada de <a href="https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models">modelos disponíveis</a>.</li><li>Neste momento de <em>public preview</em>, o único idioma oficialmente suportado é o <strong>Inglês</strong>. Mas mais adiante neste blog podemos ter uma idéia de como realizar alguns testes utilizando o português também, adicionando uma etapa intermediária de tradução.</li><li>Alguns parâmetros estão disponíveis para customizar (ou direcionar o modelo) para uma saída da forma que você espera. Um detalhamento maior desses parâmetros podem ser encontrados na documentação do <a href="https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models#parameter_definitions">Generative AI Studio</a>, mas um resumo seria:</li></ol><blockquote><strong>maxOutputTokens:</strong> que define o tamanho máximo da saída do modelo em número de tokens (que podemos imaginar como sendo palavras e caracteres de pontuação)</blockquote><blockquote><strong>temperature:</strong> que é a “permissão” que damos ao modelo para ser criativo em suas gerações — ou seja, na hora de escolher o próximo token na formação de uma frase. Valores maiores de <strong>temperature</strong> irão utilizar uma maior aleatoriedade na escolha do próximo token.</blockquote><blockquote><strong>topK:</strong> que define a quantidade de quantos “próximos tokens possíveis” serão considerados para decidir o próximo token da formação de uma frase. Por exemplo, topK=1 vai considerar somente o top-1 token e topK=20 vai selecionar o próximo token considerando os top-20 possíveis tokens</blockquote><blockquote><strong>topP:</strong> Na hora de selecionar o próximo token da formação de uma frase, considerando o universo de possíveis tokens definidos pelo parâmetro <strong>topK</strong>, o <strong>topP</strong> considerará a probabilidade que queremos considerar. Por exemplo, um topP=0.5, significa que serão selecionados quantos tokens forem possíveis até que a soma de suas probabilidades seja o mais próximo possível (sem ultrapassar) de 0.5.</blockquote><h3>Gerando informações usando a SDK da Vertex AI Generative AI Studio</h3><p>Legal, agora que vamos utilizar a SDK da Vertex AI, a primeira coisa que temos que fazer é instalar (ou atualizar) o pacote do SDK. Para isso, no seu ambiente com Python instalado, rode o comando abaixo:</p><pre>$ pip install google-cloud-aiplatform --upgrade</pre><p>Com o pacote devidamente instalado, o próximo passo é importar os métodos do módulo (aqui eu estou importando vários, apenas para dar uma idéia das possibilidades):</p><pre>from vertexai.preview.language_models import TextGenerationModel,\<br>                                             ChatModel,\<br>                                             InputOutputTextPair,\<br>                                             TextEmbeddingModel</pre><p>Pelos métodos importados já conseguimos ver os grandes grupos de atividades que podem ser feitas:</p><blockquote><strong>TextGenerationModel()</strong> vai ajudar com a geração de conteúdo (sejam perguntas e respostas, escrita de parágrafos, idéias de campanhas ou descrições de produtos, etc)</blockquote><blockquote><strong>ChatModel()</strong> vai ajudar a criar sessões de conversas com o modelo, enriquecendo chatbots e fornecendo experiências mais fluidas a clientes</blockquote><blockquote><strong>InputOutputTextPair()</strong> para criarmos cenários <strong><em>few-shot</em></strong> (para rever o conceito, basta ir na sessão “Prompts, o que são, para que servem, porque se importar com eles” mais ali acima) onde oferecemos exemplos de tarefas e suas respostas, para orientar as respostas do modelo</blockquote><blockquote><strong>TextEmbeddingModel()</strong> para cenários onde, ao invés de realizar tarefas diretas com o modelo, queremos criar <a href="https://developers.google.com/machine-learning/crash-course/embeddings/video-lecture?hl=pt-br"><em>text embeddings</em></a> de nossas informações para acelerar a criação de cenários mais avançados — como busca semântica, análise de similaridade de sentenças, etc. De forma ultra resumida, um <em>embeddings</em> é você pegar uma informação, como um texto ou uma imagem, e transformá-la numa representação numérica, ou em um vetor de números reais, para facilitar a manipulação matemática (aplicando conceitos como distância de vetores) Vou fazer um blog só sobre esse tema que acho que vale a pena <em>🙂</em></blockquote><p>Com os módulos devidamente carregados, a próxima etapa é instanciar um objeto que utilizará algum dos modelos disponíveis. Para isso, usamos algum dos método importados da SDK e apontamos para um dos modelos disponíveis — como abaixo, que estou utilizando o método TextGenerationModel() e o modelo text-bison-001:</p><pre>generation_model = TextGenerationModel.from_pretrained(&quot;text-bison@001&quot;)</pre><p>Após isso, o próximo passo já é interagir com o modelo:</p><pre># prompt é a informação que você quer que o modelo gere<br>prompt = &quot;What is a large language model?&quot;<br><br># generation_model.predict() é a chamada ao modelo<br>response = generation_model.predict(<br>prompt=prompt<br>)<br><br># aqui mostramos o resultado da chamada<br>print(response.text)</pre><p>E a resposta será similar ao texto abaixo:</p><pre>A large language model (LLM) is a type of artificial intelligence (AI) model <br>that can understand and generate human language. LLMs are trained on massive <br>datasets of text and code, and they can learn to perform a wide variety of <br>tasks, such as translating languages, writing different kinds of creative <br>content, and answering your questions in an informative way.<br><br>LLMs are still under development, but they have the potential to revolutionize<br> many industries. For example, LLMs could be used to create more accurate and<br> personalized customer service experiences, to help doctors diagnose and treat<br> diseases, and to even write entire books and movies.</pre><p>Mas temos vários parâmetros que podemos trabalhar, certo? Então abaixo iremos utilizá-los:</p><pre>prompt_top_k_example = &quot;Write a 2-day itinerary for France.&quot;<br>temperature = 0.9<br>top_k_val = 5<br>top_p_val = 0.7<br>response = generation_model.predict(<br>prompt=prompt_top_k_example,<br>max_output_tokens=300,<br>temperature=temperature,<br>top_k=top_k_val,<br>top_p=top_p_val<br>)<br>print(response.text)</pre><p>Aqui estamos utilizando algumas definições específicas de <strong>temperature</strong>, <strong>top-k</strong> e <strong>top-p</strong>. O resultado será semelhante ao abaixo:</p><pre>Day 1:<br>* Morning: Start your day in Paris with a visit to the Eiffel Tower. Take the <br>elevator to the top for stunning views of the city.<br>* Afternoon: After lunch, visit the Louvre Museum, one of the largest and most<br> famous art museums in the world. See works by Leonardo da Vinci, Michelangelo,<br> and Rembrandt.<br>* Evening: Enjoy a romantic dinner at a traditional French restaurant.<br><br>Day 2:<br>* Morning: Visit the Palace of Versailles, a UNESCO World Heritage Site. <br>Explore the opulent palace and gardens, once home to French royalty.<br>* Afternoon: Take a walk through the Tuileries Gardens, a beautiful park in <br>the heart of Paris.<br>* Evening: See a show at the Moulin Rouge, a world-famous cabaret.<br>This is just a suggested itinerary, of course, and you can customize it to <br>fit your interests and budget. There are many other things to see and do in <br>France, so be sure to do some research before you go to make the most of your<br>trip.</pre><p>Se modificarmos um pouco estes parâmetros podemos ver a diferença que isso gera no resultado:</p><pre>prompt_top_k_example = &quot;Write a 2-day itinerary for France.&quot;<br>temperature = 0.2<br>top_k_val = 20<br>top_p_val = 0.5<br>response = generation_model.predict(<br>prompt=prompt_top_k_example,<br>max_output_tokens=300,<br>temperature=temperature,<br>top_k=top_k_val,<br>top_p=top_p_val<br>)<br>print(response.text)</pre><p>E podemos ver que houve mudanças no resultado da geração de texto por conta da mudança dos parâmetros:</p><pre>Day 1:<br>* Morning: Start your day in Paris with a visit to the Eiffel Tower. Take the<br> elevator to the top for stunning views of the city.<br>* Afternoon: After lunch, visit the Louvre Museum, one of the largest and most<br> famous museums in the world. See works of art by Leonardo da Vinci, <br> Michelangelo, and Rembrandt.<br>* Evening: Enjoy a romantic dinner at a cozy bistro in Montmartre.<br><br>Day 2:<br>* Morning: Take a day trip to Versailles, the former home of French royalty. <br>Tour the opulent palace and gardens.<br>* Afternoon: Visit the Palace of Fontainebleau, another former royal residence.<br>Explore the palace&#39;s many rooms and admire its beautiful architecture.<br>* Evening: Enjoy a delicious meal at a traditional French restaurant in Paris.</pre><p>Mas para tarefas conversacionais, como funcionaria? Bom primeiros temos que instanciar um client da SDK utilizando o método para chat e o modelo adequado para isso:</p><pre>chat_model = ChatModel.from_pretrained(&quot;chat-bison@001&quot;)</pre><p>E depois iniciamos nossas interações:</p><pre>chat_model = ChatModel.from_pretrained(&quot;chat-bison@001&quot;)<br>chat = chat_model.start_chat()<br>print(chat.send_message(&quot;&quot;&quot;<br>What is the average weight of a mobile phone?<br>&quot;&quot;&quot;))</pre><p>A resposta desta primeira interação seria similar a abaixo:</p><pre>The average weight of a mobile phone is 200 grams. However, the weight of <br>mobile phones can vary depending on the size, type, and features of the phone. <br>For example, a large smartphone with a lot of features may weigh more than a <br>small, basic phone.</pre><p>Mas o mais legal dessa interação conversacional é o histórico da conversa. Se eu seguir fazendo mais perguntas usando o contexto que acabou de ser falado (sem você precisar, manualmente, armazenar as respostas passadas e reenviar ao modelo), o modelo consegue responder:</p><pre>print(chat.send_message(&quot;&quot;&quot;<br>Is it lighter or heavier than a regular pencil?<br>&quot;&quot;&quot;))</pre><p>E como podemos verificar, o modelo entendeu que o contexto ainda era relacionado a pergunta inicial (peso de um aparelho celular) e respondeu baseado nesse contexto:</p><pre>The average weight of a regular pencil is 2.5 grams. The average weight of a <br>mobile phone is 200 grams. Therefore, a mobile phone is heavier than a regular <br>pencil.</pre><h3>Mas como a gente pode interagir em português?</h3><p>Legal, vimos alguns exemplos de como é simples e rápido interagir com as API do Generative AI Studio, mas como foi dito antes, durante esse período de <em>public preview</em>, somente o idioma inglês é suportado. O que podemos fazer enquanto o suporte oficial a <strong>português brasileiro</strong> não está disponível é utilizarmos uma função <em>wrapper</em> que realize a tradução do português para o inglês antes de enviar as informações para a API, e de inglês para português para vermos os resultados.</p><p>Um exemplo de função <em>wrapper</em> de tradução seria como abaixo (utilizando a <a href="https://cloud.google.com/translation">Cloud Translation API</a>). Primeiro você precisa instalar a SDK do Translate:</p><pre>$ pip install google-cloud-translate</pre><p>Após, utilizaramos a SDK do Translate para criar a função <em>wrapper</em> como abaixo:</p><pre># definição do client da SDK da Cloud Translation API<br>from google.cloud import translate_v3 as translate<br>client = translate.TranslationServiceClient()<br><br><br># funçãp que interage com Cloud Translation API<br>def doTranslate(text, target_language):<br>  project_id = !gcloud config list | grep &#39;project =&#39;<br>  parent = f&#39;projects/&#39; + project_id[2].split(&#39;= &#39;)[1]<br>  translation = client.translate_text(<br>  request={<br>    &quot;parent&quot;: parent,<br>    &quot;contents&quot;: [text],<br>    &quot;mime_type&quot;: &quot;text/plain&quot;,<br>    &quot;target_language_code&quot;: target_language<br>    }).translations[0]<br>  return(translation.translated_text)</pre><p>Com isso, podemos repetir o último teste que fizemos, da tarefa conversacional e perguntando sobre o peso de celulares e de lápis, mas desta vez com conteúdo em português:</p><pre>chat_model = ChatModel.from_pretrained(&quot;chat-bison@001&quot;)<br>chat = chat_model.start_chat()<br><br># utilizando o prompt do modelo com a tradução de ptbr -&gt; en<br>prompt = doTranslate(&quot;&quot;&quot;<br>Qual é o peso médio de um aparelho celular?<br>&quot;&quot;&quot;, &#39;en&#39;)<br><br># avaliando o resultado com a tradução de en -&gt; ptbr<br>print(doTranslate(chat.send_message(prompt).text, &#39;pt&#39;))</pre><p>O resultado será como abaixo:</p><pre>O peso médio de um telefone celular é de 200 gramas. No entanto, o peso dos <br>telefones celulares pode variar dependendo do tamanho, tipo e recursos do <br>telefone. Por exemplo, um smartphone grande com muitos recursos pode pesar <br>mais do que um telefone pequeno e básico.</pre><p>E ainda conseguimos manter o contexto da conversa como fizemos com a interação puramente em inglês:</p><pre>prompt = doTranslate(&quot;&quot;&quot;<br>Isso é mais leve ou mais pesado que um lápis comum?<br>&quot;&quot;&quot;, &#39;en&#39;)<br>print(doTranslate(chat.send_message(prompt).text, &#39;pt&#39;))</pre><p>E a resposta:</p><pre>O peso médio de um lápis comum é de 2,5 gramas. O peso médio de um telefone <br>celular é de 200 gramas. Portanto, um telefone celular é mais pesado que um <br>lápis comum.</pre><p><strong>Pronto!!</strong> Chegando até aqui você:</p><ul><li>Conheceu os serviços de Generative AI disponibilizados na Google Cloud no Google I/O 2023</li><li>Revisou os conceitos básicos ao redor da área de Generative AI</li><li>Visualizou as diferences API do Generative AI Studio</li><li>Incluiu mecanismos de tradução para utilizar o português brasileiro durante o <em>public preview</em></li></ul><h3>Legal, como começo a experimentar?</h3><p>Todas as API que utilizamos aqui já estão disponíveis em todos os projetos de Google Cloud e, durante o período de <em>public preview</em>, sem custos para utilização (como pode ser verificado na <a href="https://cloud.google.com/vertex-ai/pricing#generative_ai_models">página de preços da Vertex AI</a>).</p><p>Para facilitar os experimentos, nós do time de Developer Relations criamos um repositório no GitHub chamado “/<a href="https://github.com/GoogleCloudPlatform/generative-ai/">generative-ai</a>”, onde há exemplos de vários cenários de linguagem natural (conversacionais, extração de informações de textos, sumarização de conteúdos, etc).</p><p><strong>Não possui ainda </strong>uma conta em Google Cloud? <a href="https://cloud.google.com/free?hl=pt-br">Crie sua conta gratuitamente</a> e tenha acesso ao crédito de “novo usuário”.</p><p><strong>Participa de comunidades?</strong> Melhor ainda!! Entre em contato com o <a href="https://gdg.community.dev/chapters/">Google Developer Group</a> mais próximo de você e quem sabe não conseguimos criar um workshop gratuito para as pessoas da sua região?</p><p>Obrigado por chegarem até aqui e um grande abraço! Qualquer dúvida, estou a uma mensagem de distância no <a href="http://www.twitter.com/lucianommartins">Twitter</a> ou no <a href="http://www.linkedin.com/in/lucianommartins">LinkedIn</a> 🙂</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d22d148048a3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/google-cloud-brasil/desenvolvendo-solu%C3%A7%C3%B5es-com-ia-generativa-na-google-cloud-d22d148048a3">Desenvolvendo soluções com IA Generativa na Google Cloud</a> was originally published in <a href="https://medium.com/google-cloud-brasil">google-cloud-brasil</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Criando um modelo de classificação de imagens com AutoML na Vertex AI]]></title>
            <link>https://medium.com/google-cloud-brasil/criando-um-modelo-de-classifica%C3%A7%C3%A3o-de-imagens-com-automl-na-vertex-ai-a19c89c02166?source=rss-925379214ac4------2</link>
            <guid isPermaLink="false">https://medium.com/p/a19c89c02166</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[vertex-ai]]></category>
            <category><![CDATA[computer-vision]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <dc:creator><![CDATA[Luciano Martins]]></dc:creator>
            <pubDate>Wed, 10 May 2023 01:39:01 GMT</pubDate>
            <atom:updated>2023-05-10T01:43:18.553Z</atom:updated>
            <content:encoded><![CDATA[<p><strong><em>* TLDR: Aqui vamos passar pelo processo de definição de um modelo de machine learning de classificação de imagens, com a facilidade que o Google AutoML oferece, utilizando a Vertex AI, plataforma de desenvolvimento de soluções de machine learning na Google Cloud.</em></strong></p><h3>Como chegamos até aqui?</h3><p>No mês de abril, o time de Google Cloud Brasil publicou, em 5 (cinco) episódios, uma série técnica chamada “Desvendando AI”, toda em português e voltada para audiência de praticantes de tecnologia (engenheiros, desenvolvedores, pesquisadores, etc):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/573/1*4jeg-AD71ldEv9uYcxVOag.png" /><figcaption>playlist da série &quot;Desvendando AI&quot; no YouTube de Google Cloud LATAM</figcaption></figure><p>Se você ainda não viu, confere na <a href="https://www.youtube.com/watch?v=gL96dHXQZ1k&amp;list=PLCOuhjvAlGW9q2Iz6OeJA6dtrg3IHj34R">playlist do canal Google Cloud LATAM</a>.</p><p>Em um dos vídeos, recebi o comentário abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/896/1*8YNi-eEiVBWLXEihzseKsQ.png" /><figcaption>comentário na série de vídeos &quot;Desvendando AI&quot;</figcaption></figure><p>E aqui estamos. Vamos no passo a passo de como utilizar a <a href="https://cloud.google.com/vertex-ai/">Vertex AI</a> para treinar um modelo de classificação de imagens em uma abordagem <em>low code</em> — Ou seja, utilizando o <a href="https://cloud.google.com/automl">Google AutoML</a> e sem necessitar criar cada etapa e cada detalhe do modelo de machine learning que será gerado.</p><h3>Mas o que faremos aqui?</h3><p>Para definirmos uma base do que faremos, vamos olhar o que envolve um processo de modelagem e treinamento de machine learning. O processo se inicia na análise de desafio de negócio, onde definimos qual problema precisa ser resolvido; passamos por uma análise de dados disponíveis, a modelagem em si (no framework que você escolher — TensorFlow, PyTorch, scikit-learn, etc), treinamento e otimização do modelo até chegar na avaliação e uso do modelo em si… E começamos tudo de novo, num ciclo iterativo e incremental. Algo como a figura abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DAQN-bY44td--D5ttuXq6Q.png" /><figcaption>processo de desenvolvimento de uma solução de machine learning</figcaption></figure><p>Como o Google AutoML ajuda nesse processo? O AutoML irá abstrair pra você (ou realizar por você) as etapas de engenharia de features, definição de modelos a serem treinados, treinamento e otimização desses modelos, seleção do melhor modelo e disponibilização do modelo para você. Ou seja, as ações da imagem abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sAsNfufqFJN_6gS7jjYRJQ.png" /><figcaption>etapas automatizadas pelo Google AutoML</figcaption></figure><p>Ou seja, você consegue salvar tempo de prototipação, focando mais no problema que você quer resolver e na qualidade dos seus dados e o AutoML será responsável por selecionar o melhor modelo possível em seu universo de modelos possíveis (que inclui modelos criados pela engenharia do Google e variações de modelos utilizando Neural Architecture Search, ou NAS — mas este tópico merece uma postagem inteira dedicada a isso. Mas vamos as estapas do laboratório de Vertex AI com Google AutoML.</p><h3>Definição dos dados a serem utilizados</h3><p>Para realizar este experimento, vamos usar o dataset gratuito <a href="http://vision.stanford.edu/aditya86/ImageNetDogs/">ImageNetDogs</a>, criado e gerido pela universidade de Stanford. O dataset é composto de mais de 20.000 (vinte mil) imagens de 120 (cento e vinte) raças de cachorros. São todas imagens reais, sem muita produção (não são imagens de estúdio, ou com cores e brilho otimizados), buscando montar algo que seja o mais próximo possível de fotos do nosso cotidiano (que fotografaríamos de nossos cachorros com nossos celulares). Um exemplo abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/705/1*x8DsR33x1JQPn9cZGT1HUA.png" /></figure><p>Como o dataset é bem grande, ele acaba aumentando a complexidade desse laboratório experimentativo; além disso, o AutoML realiza ações de aumento do dataset (<em>dataset augmentation</em>) o que nos permite criar datasets menores. Então, antes de começarmos, podemos criar um “sub-dataset” contendo menos raças de cachorros (apenas 15, das 120) e com menos exemplos de imagens de cada raça (100 imagens por raça). Para isso, usamos o <em>shell script</em> abaixo:</p><pre>$ mkdir dataset<br>$ cd dataset; axel -n 15<br>$ tar -xf images.tar<br>$ cd Images; for dir in `ls`; do new_name=`echo $dir | cut -d- -f2-`; mv $ dir $new_name; done;<br>$ for dir in `find . -type d | shuf -n 15`; do dirname=`echo $dir | cut -d/ -f2`; mkdir -p ../train/$dirname; for img in `find $dir -type f | shuf -n 100`; do mv $img ../train/$dirname; done; done</pre><p>Com isso, criamos uma estrutura de diretórios contendo 15 (quinze) pastas com nomes de raças de cachorro e 100 (cem) imagens de cada raça dentro dos diretórios correspondentes de cada raça. O próximo passo é de copiar as imagens para um Cloud Storage bucket. Neste cenário, criei um bucket chamado <em>gs://vertexai-labs</em>. É importante alterar o comando abaixo de acordo com as configurações de seu ambiente:</p><pre>$ gsutil -m cp -r dataset/train/* gs://vertexai-labs/cachorros-dataset</pre><p>Para que as imagens sejam incluídas na Vertex AI, precisamos criar um arquivo .csv que contenha a lista de todas as imagens que serão utilizadas para compor o dataset de treinamento. Maiores detalhes sobre este processo de definição do dataset podem ser encontrados <a href="https://cloud.google.com/vertex-ai/docs/image-data/classification/prepare-data">na documentação da Vertex AI</a>. Para criar o arquivo CSV com a lista de imagem, utilizamos o comando abaixo:</p><pre>$ for img in `cat dataset/list.out`; do classe=`echo $img | cut -d/ -f5`; echo &quot;${img},${classe}&quot; &gt;&gt; dataset/dataset.csv; done<br>$ gsutil -q cp dataset/dataset.csv gs://vertexai-labs/cachorros-dataset</pre><p>Com todos os dados necessários armazenados no bucket do Cloud Storage, agora faremos a criação do <a href="https://cloud.google.com/vertex-ai/docs/training/using-managed-datasets">dataset gerenciado na Vertex AI</a>. Utilizaremos a SDK de Python no processo.</p><p>Primeiro iremos importar o módulo Python de desenvolvimento com a Vertex AI, depois instanciar um cliente da Vertex AI e, finalmente, criar o dataset gerenciado e popular com os dados do bucket do Cloud Storage. Algo mais ou menos assim:</p><pre>import google.cloud.aiplatform as aiplatform<br>from google.cloud.aiplatform import ImageDataset, schema<br><br># definindo as variáveis necessáris<br>projeto=&#39;lucianomartins-demos-345000&#39;<br>regiao=&#39;us-central1&#39;<br>bucket=&#39;gs://vertexai-labs&#39;<br>schema_uri = schema.dataset.ioformat.image.single_label_classification<br><br># instanciando o cliente da Vertex AI<br>aiplatform.init(project=projeto,<br>location=regiao,<br>staging_bucket=bucket)<br><br># criando o dataset gerenciado<br>dataset = ImageDataset.create(display_name=&#39;cachorros-dataset&#39;,<br>                              sync=True)<br><br># populando o dataset com as imagens do bucket<br>dataset = dataset.import_data(gcs_source=bucket + \<br>&#39;/cachorros-dataset/dataset.csv&#39;,<br>import_schema_uri=schema_uri,<br>sync=True,<br>import_request_timeout=2700.0)</pre><p>O processo de importação das imagens pode demorar alguns minutos (cerca de quinze minutos). Ao final desta etapa, você terá o seu dataset gerenciado criado — e que pode ser visto na <a href="https://console.cloud.google.com/vertex-ai/locations/us-central1/datasets/">console da Vertex AI</a>):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XAKs9lnTZhDlN8_X6dXVag.png" /></figure><h3>Criando o job de treinamento da Vertex AI com Google AutoML</h3><p>Com o dataset preparado, a próxima etapa é realizar o treinamento de um modelo com AutoML. Por ser uma abordagem <em>low code</em>, ou seja, que não é necessário desenvolver, explicitamente, todas os detalhes do modelo de machine learning, teremos somente duas ações para tomar: a definição do job de treinamento e a execução do job de treinamento.</p><p>Para criar o job de treinamento, utilizaremos o cliente da Vertex AI, da SDK de Python, como fizemos para a criação do dataset gerenciado.</p><p>Vale uma explicação das informações que estamos informando:</p><blockquote>“display name” é como ficará a descrição do job na Vertex AI</blockquote><blockquote>“prediction type” é qual cenário de visão computacional estamos trabalhando (classificação de imagens, neste caso)</blockquote><blockquote>Se o cenário é uma classificação “multi_label”, ou seja, se em uma mesma imagem pode haver várias classes (ou raças) possíveis. No nosso caso, não</blockquote><blockquote>“model_type”, para definir se o modelo será utilizado na Google Cloud ou preparado para ser utilizado na “borda”, em um cenário de IoT. Aqui utilizamos a opção de para “cloud”</blockquote><blockquote>E finalmente, informamos que não estamos otimizando um modelo treinado previamente com “base_model=None”.</blockquote><pre>job = aiplatform.AutoMLImageTrainingJob(<br>display_name=&#39;treinamento de classificador de cachorros&#39;,<br>prediction_type=&#39;classification&#39;,<br>multi_label=False,<br>model_type=&#39;CLOUD&#39;,<br>base_model=None)</pre><p>Tendo a definição do job, podemos executá-lo (também utilizando a SDK da Vertex AI). Aqui informamos:</p><blockquote>qual dataset será utilizado; o “model_display_name”, que é a descrição do modelo na <a href="https://cloud.google.com/vertex-ai/docs/model-registry/introduction">Model Registry</a> (ou biblioteca de modelos treinados)</blockquote><blockquote>como o nosso dataset será utilizado (aqui teremos 80% das imagens para o treinamento do modelo, 10% para a avaliação do modelo durante o treinamento e 10% para testes após o treinamento)</blockquote><p>Além de outros detalhes de execução (para ver todas as possibilidades, verifique a <a href="https://cloud.google.com/python/docs/reference/aiplatform/latest/google.cloud.aiplatform.AutoMLImageTrainingJob#google_cloud_aiplatform_AutoMLImageTrainingJob_run">documentação da Vertex AI para execução de jobs de treinamento</a>):</p><pre>model = job.run(<br>dataset=dataset,<br>model_display_name=&#39;classificador-cachorros&#39;,<br>training_fraction_split=0.8,<br>validation_fraction_split=0.1,<br>test_fraction_split=0.1,<br>budget_milli_node_hours=10000,<br>disable_early_stopping=False)</pre><p>Esse processo pode demorar um tempo — No meu lab aqui, levou, mais ou menos, 2 horas e 30 minutos pra ser finalizado. Com o processo finalizado, podemos verificar as métricas do treinamento via a a console da Vertex AI e via a SDK da Vertex AI. Aqui como estamos fazendo tudo via SDK, vamos seguir nessa abordagem:</p><pre>model_evaluations = model.list_model_evaluations()<br>for model_evaluation in model_evaluations:<br>  print(model_evaluation.to_dict())</pre><p>O resultado é a lista de todas as informações referentes às métricas do treinamento — coisas como acurácia, precisão, recall, a matriz de confusão, etc (deixando aqui só um pedaço da saída do comando):</p><pre>{&#39;name&#39;: &#39;projects/48397268769/locations/us-central1/models/4167564684666339328@1/evaluations/5273414928256991232&#39;, &#39;metricsSchemaUri&#39;:<br>&lt;…&gt;<br>&#39;confidenceMetrics&#39;: [{&#39;confidenceThreshold&#39;: 0.8, &#39;recall&#39;: 0.94666666, &#39;precision&#39;: 0.9726027},<br>&lt;…&gt;</pre><p>Neste ponto, estamos prontos para o próximo passo — Implantar o modelo em uma API para usar o modelo de verdade.</p><h3>Implantando o modelo treinado em uma API na cloud</h3><p>Com as facilidades que a Vertex AI oferece, a implantação do modelo AutoML em uma API se baseia na execução de um único comando:</p><pre>endpoint = model.deploy()</pre><p>Após alguns minutos, a API estará disponível para receber chamadas REST e realizar inferências no seu modelo recém treinado.</p><h3>Realizando inferências com a API do modelo</h3><p>Para realizar a inferência, iremos utilizar uma imagem do dataset de Stanford que não foi utilizada no processo de treinamento. É importante que seja uma imagem não vista pelo modelo, para que o modelo não utilize o conhecimento que ele já possui sobre a imagem e acabe acertando a inferência porque “decorou” a informação.</p><p>Iremos utilizar a imagem deste basset como teste:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/570/1*3UM4K4F6J1MrUdcyb8fzmA.png" /></figure><p>Para realizar a inferência devemos:</p><blockquote>Transformar a imagem em formato `base64`</blockquote><blockquote>Realizar a chamada REST na API que implantamos</blockquote><blockquote>Tratar os resultados da inferência.</blockquote><p>Algo como abaixo — primeiro transformando a imagem em formato <em>base64</em>:</p><pre>with open(&#39;./imgs/testimg.jpg&#39;, &#39;rb&#39;) as image_file:<br>imagem = base64.b64encode(image_file.read())</pre><p>Após isso, vamos utilizar a SDK da Vertex AI e enviar a chamada REST de inferência:</p><pre>instances = [{&quot;content&quot;: imagem.decode(&quot;utf-8&quot;)}]<br>prediction = endpoint.predict(instances=instances)<br>E, finalmente, realizar o processamento da resposta da inferência (armazenada na variável &quot;prediction&quot;):<br>id_raca = prediction[0][0][&#39;confidences&#39;]<br>id_raca = id_raca.index(max(prediction[0][0][&#39;confidences&#39;]))<br>prediction[0][0][&#39;displayNames&#39;][id_raca]<br><br>&#39;basset&#39;</pre><p><strong>Parabéns</strong>!! chegando até aqui você:</p><blockquote>criou um dataset gerenciado na Vertex AI</blockquote><blockquote>treinou um modelo de machine learning, em uma abordagem low code, utilizando o AutoML</blockquote><blockquote>fez a implantação desse modelo em uma API</blockquote><blockquote>realizou inferências com esse modelo</blockquote><p>Você gostou do conteúdo e quer replicar o código em seu ambiente? Sem problemas!! Basta seguir as etapas presentes <a href="https://github.com/lucianommartins/vertexai-automl-cachorros">neste repositório no github</a>.</p><p>Um abraço e até a próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a19c89c02166" width="1" height="1" alt=""><hr><p><a href="https://medium.com/google-cloud-brasil/criando-um-modelo-de-classifica%C3%A7%C3%A3o-de-imagens-com-automl-na-vertex-ai-a19c89c02166">Criando um modelo de classificação de imagens com AutoML na Vertex AI</a> was originally published in <a href="https://medium.com/google-cloud-brasil">google-cloud-brasil</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Treinando Graph Neural Networks utilizando a Vertex AI]]></title>
            <link>https://medium.com/google-cloud-brasil/treinando-graph-neural-networks-utilizando-a-vertex-ai-3e0884ab4efb?source=rss-925379214ac4------2</link>
            <guid isPermaLink="false">https://medium.com/p/3e0884ab4efb</guid>
            <category><![CDATA[vertex-ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[graph-machine-learning]]></category>
            <dc:creator><![CDATA[Luciano Martins]]></dc:creator>
            <pubDate>Fri, 14 Apr 2023 15:03:11 GMT</pubDate>
            <atom:updated>2023-04-14T15:42:09.407Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introdução</h3><p>Sou um grande fã de estruturas de dados — em especial, de grafos e de todo o seu potencial de representação de dados do mundo real. Há algumas semanas, estava revisando conteúdo de grafos e postei a foto abaixo em uma rede social:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/357/1*JmQgPDuct34yAvatDp-inw.png" /><figcaption>livros sobre teoria de grafos e redes neurais de grafos</figcaption></figure><p>Curiosamente, descobri uma <em>guilda</em> de estudantes e pesquisadores de grafos, que ficaram bastante interessados sobre o conteúdo de se utilizar grafos junto com aprendizado de máquina. Isso me trouxe uma dúvida: Será que há mais pessoas interessadas em conteúdos de machine learning que não sejam aqueles tópicos que estão mais na moda?</p><p>Partindo dessa dúvida, fiz uma pesquisa em uma rede social: quais conteúdos seriam interessantes para ter mais conteúdo técnico em português? O resultado acabou em um empate — e eu segui pela área de conforto técnico pessoal para construir essa postagem 🙂</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/495/1*BeKnkAsLF5UGTp8IwNyQtw.png" /><figcaption>pesquisa sobre interesse de temas para conteúdos de <em>machine learning</em> em português</figcaption></figure><h3>Uma introdução a grafos</h3><p><strong>Importante: </strong><em>Se você já conhece ou utiliza grafos em seus estudos, pesquisas ou trabalho, essa sessão pode ser “mais do mesmo” para você. Também, esta postagem não é uma referência completa de grafos, então nem todas as propriedades de grafos estarão presentes aqui.</em></p><p>Mas o que são grafos? Numa conceituação livre, grafos são estruturas de dados onde representamos as informações e suas possíveis correlações através de um conjunto de de vértices (ou nós) e suas arestas (ou conexões). Podemos intuir como::</p><p><strong>G = (V, A)</strong>, onde:</p><p>G → o grafo em questão<br>V → o conjunto de vértices que compõe o grafo<br>A → o conjunto de arestas (ou conexões) — basicamente, pares ordenados <em>a = (v,w)</em>, onde <em>v</em> e <em>w</em> ∈ V</p><p>Na prática, se considerarmos o grafo (não direcionado) abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/301/1*9s9ydMz4l780Fu6N3usxOw.png" /><figcaption>grafo de exemplo, com três vértices e três arestas</figcaption></figure><p>Teremos:</p><p>V(G) = {A, B, C}<br>A(G) = {(A,B), (A,C), (C,B)</p><p>Se pensamos em uma representação em grafos, temos que considerar propriedades como:</p><p><strong>a) Grafo não direcionado:</strong> quando a conexão entre dois vértices não possui direção: (A,B) = (B,A)</p><p><strong>b) Grafo direcionado:</strong> quando há uma direção na conexão — ou seja, (A,B) ≠ (B,A)</p><p><strong>c) Grafo completo:</strong> quanto há conexões entre todos os nós que compõe o grafo</p><p><strong>d) Grafo valorado:</strong> quando há valores (ou pesos) em diferentes conexões</p><p><strong>e) Multigrafo:</strong> quando há mais de uma conexão direta e possível entre dois vértices</p><p>Ainda, dependendo do tipo de dado que estamos representando na forma de grafos, podemos ter estruturas menos triviais, como grafos heterogêneos (quando diferentes tipos de entidades são representadas nos vértices do grafo), grafos k-partidos (como bipartidos, tripartidos, etc), onde podemos representar o mesmo grafo G em k diferentes conjuntos de vértices (V1, V2, … , Vk) e que cada aresta do conjunto E possua uma ponta em um conjunto de vértices diferente.</p><p>Visualizando estes conceitos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/296/1*cYPlHMElalDlfk2391bSIw.png" /><figcaption>exemplo de um multigrafo heterogêneo, direcoinado e valorado</figcaption></figure><p>Este grafo é:</p><ul><li>Heterogêneo (há diferentes tipos de entidades nos vértices)</li><li>Multigrafo (há vértices com múltiplas conexões entre si)</li><li>Direcionado (há um sentido nas conexões entre os vértices</li><li>Valorado (há valores, ou pesos, em suas conexões)</li></ul><p>Com essas características, e utilizando técnicas de como “percorrer” o grafo (ou seja, como traçar caminhos entre as arestas para cumprir algum objetivo — o caminho mais curto, ou o caminho com menor custo de peso, ou o caminho que percorra mais nós, etc) e com a utilização de atributos adicionais (sejam atributos das arestas ou de suas conexões), conseguimos utilizar e gerar valor de cenários não triviais e mais complexos.</p><p>Assim, conseguimos representar, sem perda de informações ou contexto, cenários como o hipotético abaixo — onde temos um grafo direcionado que representa transações financeiras, onde há vértices que representam os clientes, vértices que representam as máquinas de cartão — assim como seus atributos: tanto das pessoas (como idade e gênero), das máquinas de cartão (latitude, longitude, % de taxa das transações) e das arestas entre eles (valor da transação e se é débito ou crédito):</p><p>Para uma introdução mais formal e completa da teoria dos grafos, recomendo a aula das professoras Maria Cristina, Roseane e Josiane Bueno, do <a href="https://www.icmc.usp.br/">Instituto de Ciências Matemáticas e da Computação (ICMC)</a> da <a href="http://www.saocarlos.usp.br/">USP São Carlos</a>, que está disponibilizada no <a href="http://wiki.icmc.usp.br/images/a/a2/SCC603-2013-01-IntroducaoGrafos.pdf">site do ICMC</a>. Uma outra excelente referência sobre a utilização de grafos para a análise de cenários complexos é o livro <a href="http://networksciencebook.com/">Network Science</a>, do professor <a href="https://en.wikipedia.org/wiki/Albert-L%C3%A1szl%C3%B3_Barab%C3%A1si">Albert-László Barabási</a> (disponível, gratuitamente, online).</p><h3>Dados estruturados em forma de grafos</h3><p>Com esse entendimento inicial sobre grafos, agora vamos imaginar como interpretar informações na forma de grafos. Mas para chegarmos nesta intuição, podemos nos perguntar: porquê utilizar grafos para representar dados? Bom, para isso, temos que pensar como os dados são organizados.</p><p>Aqui precisamos abraçar mais um fundamento matemático de um dos maiores matemáticos de todos os tempos — <a href="https://pt.wikipedia.org/wiki/Euclides">Euclides</a>. Euclides é considerado um dos pais da geometria e, com base em seus estudos, leis e postulados, grande parte da organização que fazemos de informações acontece no que chamamos de <a href="https://pt.wikipedia.org/wiki/Espa%C3%A7o_euclidiano">Espaços Euclidianos</a> (“espaços vetoriais reais e de dimensão finita”) onde podemos manipular vetores ou matrizes numéricas (reais) de múltiplas dimensões. Então, quando pegamos uma informação não estruturada e a representamos numericamente, em outras palavras, estamos tendo esta representação em um espaço euclidiano.</p><p>Exemplo, se considerarmos esta imagem (chamando localmente de “imagem.png”):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/63/1*AHRhTEe42k2Xly95SnhETA.png" /><figcaption>imagem de exemplo</figcaption></figure><p>E a lermos utilizando alguma biblioteca python, por exemplo — como abaixo:</p><pre>import imageio as iio<br>img = iio.imread(&#39;/home/lucianomartins/Downloads/imagem.png&#39;)<br>print(img.shape)<br>print(img)<br>Temos como saída:<br>(45, 43, 3)<br>[[[255 255 255]<br>[255 255 255]<br>[255 255 255]<br>…<br>// várias linhas removidas aqui, pra facilitar a visualização<br>…<br>[255 255 255]<br>[255 255 255]<br>[242 245 253]]]</pre><p>Ou seja, a imagem está representada como uma matriz de três dimensões (uma para cada camada de cor — pensando em <a href="https://pt.wikipedia.org/wiki/RGB">RGB</a>), com cada dimensão possuindo 45 linhas e 43 colunas. Com esta mesma lógica conseguimos representar dados estruturados (como leituras de sensores IoT, ou resultados de uma query SQL) e também outros dados não estruturados (além de imagens, áudio, textos, etc).</p><p>E onde esta estrutura, baseada nos conceitos de geometria euclidiana, nos deixa limitados? Em dados do mundo real, algumas complexidades de relacionamentos entre entidades não são facilmente — Por exemplo, representar a sua rede social de amigos, ou a malha rodoviária do Brasil, ou as ligações intermoleculares em um estudo de novos remédios.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/529/1*roD-ZAm0_0bDlZbnbWgCQQ.png" /><figcaption>Fonte: <a href="https://www.gov.br/infraestrutura/pt-br/assuntos/transporte-terrestre_antigo/rodovias-federais/rodovias-federais-mapas">Ministério da Infraestrutura do Brasil</a></figcaption></figure><p>E, como muitos de vocês sabem (ou, pelo menos, estudaram em graduação, ou em preparação para entrevistas de código em empresas), existem muitas formas de explorarmos relacionamentos e extrairmos insights de grafos. Alguns exemplos (como uma lista não exaustiva):</p><ul><li>Algoritmos de busca em grafo (como os famosos <a href="https://pt.wikipedia.org/wiki/Busca_em_largura">BFS</a> e <a href="https://pt.wikipedia.org/wiki/Busca_em_profundidade">DFS</a>)</li><li>Busca de caminhos mais curtos entre vértices (como o <a href="https://pt.wikipedia.org/wiki/Algoritmo_de_Dijkstra">Dijkstra</a>)</li><li>Cenários de <a href="https://pt.wikipedia.org/wiki/%C3%81rvore_de_extens%C3%A3o"><em>spanning tree</em></a> no grafo (como o algoritmo de <a href="https://pt.wikipedia.org/wiki/Algoritmo_de_Prim">Prim</a> ou de <a href="https://pt.wikipedia.org/wiki/Algoritmo_de_Kruskal">Kruskal</a>)</li></ul><p>E o universo de áreas de pesquisa que utilizam grafos para interpretar cenários complexos é imensa. Deixo aqui alguns exemplos de coisas do nosso cotidiano (próximas a nós ou não) que só são possíveis graças aos grafos e análises de redes:</p><p>- <a href="https://www.ncbi.nlm.nih.gov/pmc/articles/PMC8122399/">Spread of Epidemic Disease on Edge-Weighted Graphs from a Database: A Case Study of COVID-19</a><br>- <a href="https://www.nature.com/articles/s41587-021-00989-2">Integrating T cell receptor sequences and transcriptional profiles by clonotype neighbor graph analysis</a><br>- <a href="https://snap.stanford.edu/class/cs224w-readings/Brin98Anatomy.pdf">The anatomy of a large-scale hypertextual Web search engine</a></p><h3>O que são redes neurais de grafo?</h3><p>Com o entendimento de grafos, sua estrutura, características e aplicações práticas, seguimos para o próximo passo deste artigo: as redes neurais de grafo.</p><p>Começando com uma conceituação muito simples: uma rede neural de grafo é uma rede que recebe como dados de entrada informações organizadas numa estrutura de grafo. A grande vantagem desta abordagem é que, como revisamos anteriormente, muitas informações do “mundo real” possuem uma estrutura complexa e, para que não haja perda de detalhes destas informações, elas são melhor representadas por grafos — Assim, quando conseguimos ingerir os grafos de informações diretamente na rede neural, conseguimos manter o máximo possível dos detalhes e complexidade dos dados envolvidos.</p><p>A área de pesquisa de redes neurais de grafos é bem estabelecida e já existe há um certo tempo. Um dos primeiros estudos, <a href="https://ieeexplore.ieee.org/document/1555942">A new model for learning in graph domains</a>, foi publicado na IEEE em 2005.</p><p>Uma rede neural de grafo (ou <em>Graph Neural Network</em>, GNN) trabalha com vetores numéricos para cada vértice do grafo, chamado de estado do vértice (ou <em>node state</em>) — muito similar ao vetor de ativação de neurônios numa rede neural “clássica”. A transformação de dados de entrada dos vértices varia de acordo com a implementação da GNN — indo desde normalização e <em>encoding</em> (como em qualquer rede neural), até operações mais sofisticadas (como por exemplo a criação de embeddings de textos ou imagens).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/1*1SvQ8Jv5od7NMLiBsW9_nQ.png" /><figcaption>Uma visão de uma rede neural convolucional de grafo (<em>Graph Convolutional Network, </em>GCN)</figcaption></figure><p>A essência da implementação de GNN gira em torno da ideia de ter ciclos de atualização desses <em>node states,</em> através de uma função de treinamento aplicada aos <em>node states</em> de cada vertex e de seus vizinhos. Há diversas formas na literatura de redes neurais de grafo, que podemos realizar essa atividade: como <a href="https://arxiv.org/abs/1704.01212">passagem de mensagens</a> (<em>message passing)</em> entre as arestas existentes entre dois vértices; <a href="https://arxiv.org/abs/1609.02907">convoluções de grafo</a> (<em>graph convolutions</em>) que conseguem enfatizar o uso dos mesmos pesos de treinamento em diversos vértices do grafo; ou ainda <a href="https://arxiv.org/abs/1806.01261"><em>graph nets</em></a> (disponível no <a href="https://github.com/deepmind/graph_nets">github da DeepMind</a>) onde se busca generalizar a manipulação de estados não só para vértices, mas para arestas e para o gráfico como um todo.</p><h3>Mas que cenários lidamos com redes neurais de grafo?</h3><p>Deixando um pouco de lado a representação do dado em si — quais cenários de machine learning podem ser implementados utilizando redes neurais de grafo? Diversos. Mas em uma visão simplificada, podemos agrupar os cenários de soluções com redes neurais de grafo em três grandes categorias:</p><p><strong>1) classificação de vértices</strong> (ou <em>node classification</em>): Quando buscamos predizer a classe ou grupo que faz parte um determinado novo vértice. Um cenário do cotidiano que pode ser abordado desta forma é, por exemplo, dada uma rede de transações financeiras (lojas, ou máquinas de cartão, etc), identificar entidades potencialmente fraudulentas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/437/1*vHLm_MQEcfbm3oyccAix6A.png" /><figcaption>um exemplo visual de classificação de vértices</figcaption></figure><p><strong>2) predição de arestas </strong>(ou <em>link prediction</em>): Quando buscamos predizer qual a probabilidade de dois vértices se conectarem. Este é o cenário mais comum que vivemos como usuários de redes sociais: quando o “motor de recomendação” da rede sugere novas conexões com pessoas (que não, necessariamente, conhecemos).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/483/1*HGhI5gVeKzG4F6fVVynTNg.png" /><figcaption>um exemplo de um cenário de predição de arestas</figcaption></figure><p><strong>3)</strong> <strong>classificação do grafo</strong> (ou <em>graph classification</em>): Quando buscamos classificar um dado grafo em diferentes categorias pré-determinadas — de forma similar ao que fazemos, por exemplo, em classificação de imagens em visão computacional. Fazemos isso, por exemplo, quando queremos classificar uma molécula (representada em formato de grafo) como tóxica para humanos ou não.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/1*lLLq7Xn-LcJPlC8LPSpi3A.png" /><figcaption>um exemplo de classificação de grafos</figcaption></figure><p>A partir desta visão mais “generalista” das possibilidades, há diversas abordagens de implementação e não caberiam nesta postagem. Mas podemos ver um exemplo bem legal abaixo (parte <a href="https://arxiv.org/abs/1804.01622">deste artigo</a>), onde a partir de uma descrição de uma cena representada em um grafo, conseguimos gerar uma imagem contextualmente fiel à descrição inicial:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/628/1*XPhAviXYAD_TpAJ-X8SWDw.png" /><figcaption>Imagens geradas a partir de cenas em grafos — J. Johnson, A. Gupta, and L. Fei-Fei, “Image generation from scene graphs,” in Proc. of CVPR, 2018</figcaption></figure><h3>Desenvolvendo o seu modelo de Machine Learning com dados em grafo</h3><p>Agora vamos verificar isso tudo na prática. Como será que se desenvolve, treina e utiliza um modelo de redes neurais de grafo?</p><p>Para exercitar isso tudo, vamos criar um modelo de classificação de uma rede neural de grafo onde utilizaremos o dataset chamado <a href="https://www.openicpsr.org/openicpsr/project/100859/version/V1/view;jsessionid=EE14CC3F106F34B83472AD2C4E34459F">Cora</a> —é um dataset com dados de artigos científicos de computação incluindo suas referências cruzadas (ou qual artigo cita qual artigo). Ainda, para cada artigo há uma definição de qual &quot;classe&quot; (ou tópico de computação) esse artigo faz parte; podendo ser dos tipos: Neural_Networks, Probabilistic_Methods, Genetic_Algorithms, Theory, Case_Based, Reinforcement_Learning Rule_Learning.</p><p>O que buscamos é criar uma rede neural de classificação de arestas — ou seja, dado um deterNeste cenário, vamos:</p><ul><li>visualizar os dados deste dataset</li><li>preparar os dados para serem ingeridos em uma rede neural de grafo</li><li>dividir o dataset em dados de treinamento e dados de teste</li><li>treinar e avaliar o modelo</li><li>validar a qualidade do modelo</li><li>implementar o modelo em uma API REST para realizar inferências</li></ul><h4>Criando uma instância de desenvolvimento na Vertex AI</h4><p>Primeiramente vamos criar o nosso ambiente de desenvolvimento. Para isso, vamos usar a plataforma de desenvolvimento de machine learning na Google Cloud, chamada <a href="https://cloud.google.com/vertex-ai">Vertex AI</a>.</p><p>Para abrir a Vertex AI, acesse <a href="https://console.cloud.google.com/">https://console.cloud.google.com</a> e, na barra de busca, digite “Vertex AI”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/547/1*M-3sLN3z3n9Y8mPbk6Olqw.png" /><figcaption>acessando o serviço da Vertex AI na Google Cloud</figcaption></figure><p>Quando já estiver na console da Vertex AI, clica no serviço chamado <a href="https://cloud.google.com/vertex-ai-workbench">Workbench</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/327/1*j6JrdTsw_rCKnUo_fwpJgw.png" /><figcaption>acessando o &quot;Workbench&quot; dentro da Vertex AI</figcaption></figure><p>No Workbench, podemos criar as máquinas virtuais onde iremos criar todo o nosso código e onde iremos interagir com as API da Vertex AI para acessar dados para a criação de datasets, treinar modelos e, até mesmo, produtizar modelos, servidos em API, para utilização por outros desenvolvedores.</p><p>Neste cenário, para criar nossa máquina virtual de desenvolvimento, devemos clicar em “New Notebook”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/532/1*qO3O5u8O6OE8gvIZ0i4i0Q.png" /><figcaption>iniciando a criação de uma nova instância de notebook na Vertex AI Workbench</figcaption></figure><p>Aqui no meu ambiente optei por uma máquina virtual já pré-configurada com o TensorFlow versão 2.10 sem nenhuma GPU conectada:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/570/1*FcCjZ8Q2NQvITxeNaVHeQg.png" /><figcaption>selecionando a configuração da instância de Vertex AI Workbench</figcaption></figure><p>Na nova tela que aparece, apenas configurei o nome da minha máquina virtual (que aqui chamei de “lab-grafos”) e cliquei em “Create”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/368/1*wRncnBNdDYYvdqYvIm927A.png" /><figcaption>configurações da nova instância de Vertex AI Workbench</figcaption></figure><p>Depois de alguns segundos, sua instância de desenvolvimento estará pronta e iniciada. Basta clicar em “Open JupyterLab” e começar a desenvolver:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/610/1*CwztRu3ujG2cK9UCwxR-gA.png" /><figcaption>validando que a nossa instância de Vertex AI Workbench está em execução com sucesso</figcaption></figure><p>Considerando que você tem uma instância de Workbench com a mesma versão de TensorFlow que estou utilizando aqui (2.10), é importante validar que você tenha os seguintes módulos:</p><pre>## modulos necessários<br>!pip install pandas numpy networkx matplotlib</pre><p>Estou rodando com as seguintes versões:</p><pre>(base) jupyter@lab-grafos:~$ python3<br>Python 3.7.12 | packaged by conda-forge | (default, Oct 26 2021, 06:08:21)<br>[GCC 9.4.0] on linux<br>Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.<br>&gt;&gt;&gt; import tensorflow as tf<br>&gt;&gt;&gt; import pandas as pd<br>&gt;&gt;&gt; import numpy as np<br>&gt;&gt;&gt; import networkx as nx<br>im&gt;&gt;&gt; import matplotlib as mpl<br>&gt;&gt;&gt; print(tf.__version__)<br>2.10.1<br>&gt;&gt;&gt; print(pd.__version__)<br>1.3.5<br>&gt;&gt;&gt; print(np.__version__)<br>1.21.6<br>&gt;&gt;&gt; print(nx.__version__)<br>2.6.3<br>&gt;&gt;&gt; print(mpl.__version__)<br>3.5.3</pre><p>Nas próximas sessões aqui podem ser verificados alguns snippets de código que foram blocos importantes para a criação do modelo final desenvolvido nesse blog. Por questão de simplicidade de leitura, incluí somente trechos importantes do código e seus resultados. O notebook com o código completo pode ser encontrado no <a href="https://github.com/lucianommartins/vertexai-gnn-classification">github</a>.</p><h4>Importando datasets</h4><p>Vamos realizar o download do dataset:</p><pre>zip_file = keras.utils.get_file(<br>    fname=&#39;cora.tgz&#39;,<br>    origin=&#39;https://linqs-data.soe.ucsc.edu/public/lbc/cora.tgz&#39;,<br>    extract=True)<br><br>data_dir = os.path.join(os.path.dirname(zip_file), &#39;cora&#39;)</pre><p>E, depois disso, vamos importar as informações de artigos, citações e:</p><pre># artigos<br>column_names = [&#39;paper_id&#39;] + [f&#39;term_{idx}&#39; for idx in range(1433)] + [&#39;subject&#39;]<br>papers = pd.read_csv(<br>    os.path.join(data_dir, &#39;cora.content&#39;), sep=&#39;\t&#39;, header=None, names=column_names,<br>)<br>print(&#39;shape das informações dos papers:&#39;, papers.shape)<br><br># citações<br>citations = pd.read_csv(<br>    os.path.join(data_dir, &#39;cora.cites&#39;),<br>    sep=&#39;\t&#39;,<br>    header=None,<br>    names=[&#39;target&#39;, &#39;source&#39;],<br>)<br>print(&#39;shape da estrutura de citações:&#39;, citations.shape)</pre><p>Após isso, podemos estruturar os dados para visualizarmos em formato de grafo:</p><pre># organização dos dados do dataset<br>class_values = sorted(papers[&#39;subject&#39;].unique())<br>class_idx = {name: id for id, name in enumerate(class_values)}<br>paper_idx = {name: idx for idx, name in enumerate(sorted(papers[&#39;paper_id&#39;].unique()))}<br><br>papers[&#39;paper_id&#39;] = papers[&#39;paper_id&#39;].apply(lambda name: paper_idx[name])<br>citations[&#39;source&#39;] = citations[&#39;source&#39;].apply(lambda name: paper_idx[name])<br>citations[&#39;target&#39;] = citations[&#39;target&#39;].apply(lambda name: paper_idx[name])<br>papers[&#39;subject&#39;] = papers[&#39;subject&#39;].apply(lambda value: class_idx[value])</pre><p>Agora podemos, inclusive, verificar o dadaset em formato de grafo:</p><pre># visualizando o Cora dataset<br>plt.figure(figsize=(8, 8))<br>colors = papers[&#39;subject&#39;].tolist() # aqui definimos a quantidade de &quot;cores&quot; do grafo, baseado nos tipos de papers<br>cora_graph = nx.from_pandas_edgelist(citations.sample(n=1500)) # aqui criamos um grafo de exemplo, com uma amostra de 1500 citações<br>subjects = list(papers[papers[&#39;paper_id&#39;].isin(list(cora_graph.nodes))][&#39;subject&#39;])<br>nx.draw_spring(cora_graph, node_size=15, node_color=subjects)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*NhzJIyST6gvc5gKPBZ5-mQ.png" /><figcaption>visualização do Cora Dataset</figcaption></figure><h4>Preparando os dados para serem usados pelo seu modelo</h4><p>Com os dados importados, precisamos preparar esses dados para serem usados por um modelo de machine learning. Esta requisito não é diferente do que faríamos em dados que não estivessem em formato de grafo.</p><pre>train_data, test_data = [], []<br><br># realiza o split dos dados em treinamento e testes<br>for _, group_data in papers.groupby(&#39;subject&#39;):<br>    random_selection = np.random.rand(len(group_data.index)) &lt;= 0.75<br>    train_data.append(group_data[random_selection])<br>    test_data.append(group_data[~random_selection])<br><br>train_data = pd.concat(train_data).sample(frac=1)<br>test_data = pd.concat(test_data).sample(frac=1)<br><br>print(&#39;shape do dataset treinamento:&#39;, train_data.shape)<br>print(&#39;shape do dataset teste:&#39;, test_data.shape)<br>print()<br><br># informações sobre as features dos dataset<br>feature_names = set(papers.columns) - {&#39;paper_id&#39;, &#39;subject&#39;}<br>num_features = len(feature_names)<br>num_classes = len(class_idx)<br><br># converte os datasets em arrays numpy<br>x_train = train_data[feature_names].to_numpy()<br>x_test = test_data[feature_names].to_numpy()<br><br># converte os arrays das classes target em arrays numpy<br>y_train = train_data[&#39;subject&#39;]<br>y_test = test_data[&#39;subject&#39;]<br><br># define a matrix de adjacência de shape [2, num_edges]<br>edges = citations[[&#39;source&#39;, &#39;target&#39;]].to_numpy().T<br><br># define um array de 1&#39;s como um array de pesos<br>edge_weights = tf.ones(shape=edges.shape[1])<br><br># cria o array de features dos vértices de shape [num_nodes, num_features]<br>node_features = tf.cast(<br>    papers.sort_values(&#39;paper_id&#39;)[feature_names].to_numpy(), dtype=tf.dtypes.float32<br>)<br># cria a tupla de informaçoes do grafo do dataset<br>graph_info = (node_features, edges, edge_weights)</pre><h4>Treinando seu modelo</h4><p>Como estamos utilizando a Vertex AI, ela será responsável por simplificar toda a nossa infraestrutura — então, não é necessário nenhum trabalho manual de configuração de frameworks de machine learning, alocação de recursos (como CPU e memória), configuração de aceleradores, etc.</p><p>Para visualizar melhor o que acontece nesse treinamento, coloquei detalhes de como seria o treinamento manual do modelo no <a href="https://github.com/lucianommartins/vertexai-gnn-classification">jupyter notebook disponível no github</a>.</p><p>Para preparar o treinamento do modelo, precisamos preparar o ambiente de desenvolvimento — incluindo a definição de projeto da cloud, região e área de armazenamento (no serviço <a href="https://cloud.google.com/storage">Cloud Storage</a>).</p><pre># definição do projeto a ser utilizado<br>shell_output = ! gcloud config list --format &#39;value(core.project)&#39; 2&gt;/dev/null<br>PROJECT_ID = shell_output[0]<br>print(&quot;Project ID:&quot;, PROJECT_ID)<br><br># definição da região onde o código será executado<br>REGION = &quot;us-central1&quot;<br><br>if REGION == &quot;[your-region]&quot;:<br>    REGION = &quot;us-central1&quot;<br><br># configuração do Cloud Storage bucket que será utilizado<br>from google.cloud import storage<br>from google.cloud.storage import Bucket<br><br>BUCKET_NAME = &quot;vertex-gnn-lab&quot;<br>BUCKET_URI = f&quot;gs://{BUCKET_NAME}&quot;<br><br>client = storage.Client()<br>bucket = client.bucket(BUCKET_NAME)<br><br>if not bucket.exists():<br>    bucket.create(location=&#39;us-central1&#39;)<br>    del bucket, client<br>    print(&#39;Criação de bucket realizada com sucesso. Bucket %s criado com sucesso&#39; % BUCKET_NAME)<br>else:<br>    print(&#39;Criação de bucket cancelada. Bucket %s já existe&#39; % BUCKET_NAME)<br><br># instanciamento do cliente da Vertex AI SDK<br>aiplatform.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI)<br><br># preparando os diretórios locais que serão utilizados no processo<br>APPLICATION_DIR = &quot;classificadorgnn&quot;<br>TRAINER_DIR = f&quot;{APPLICATION_DIR}/trainer&quot;<br>PREDICTION_DIR = f&quot;{APPLICATION_DIR}/prediction&quot;<br>!mkdir -p $APPLICATION_DIR<br>!mkdir -p $TRAINER_DIR<br>!mkdir -p $PREDICTION_DIR</pre><p>Para realizar o treinamento do modelo, vamos criar um arquivo em Python com todo o código necessário para baixar e preparar o dataset que utilizaremos (o Cora Dataset):</p><pre>%%writefile {TRAINER_DIR}/dataset.py<br><br>import numpy as np<br>import pandas as pd<br>import tensorflow as tf<br>from tensorflow import keras<br>&lt;...&gt;</pre><p>Também criaremos um arquivo que faça a definição do modelo, em TensorFlow, para o nosso modelo:</p><pre>%%writefile {TRAINER_DIR}/model.py<br><br>import tensorflow as tf<br>from tensorflow import keras<br>from tensorflow.keras import layers<br>&lt;...&gt;</pre><p>E um arquivo que importe os dois primeiros (dataset.py e model.py) e realize as etapas de treinamento em si:</p><pre>%%writefile {TRAINER_DIR}/train.py<br><br>import pickle<br>from google.cloud import storage<br><br>from trainer.dataset import *<br>from trainer.model import *<br>&lt;...&gt;</pre><p>Com estes arquivos criados, o próximo passo é criar um Dockerfile que irá gerar a imagem de container que irá ser utilizada no treinamento do modelo:</p><pre>%%writefile {APPLICATION_DIR}/Dockerfile<br><br>FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-10<br><br>WORKDIR /<br><br># copia o código de treinamento para dentro da imagem<br>COPY trainer /trainer<br><br># configura o ENTRYPOINT do container<br>ENTRYPOINT [&quot;python&quot;, &quot;-m&quot;, &quot;trainer.train&quot;]</pre><p>E, utilizando o serviços serviços de Google Cloud (Cloud Build para realizar a build do container e Artifacts Registry para armazenar a imagem), vamos ter o container para treinamento criado:</p><pre>REPO_NAME_TRAINING=&#39;classificador-gnn-repo&#39;<br><br>## as duas linhas abaixo só precisam ser executadas uma vez para este cenário<br>!gcloud artifacts repositories create $REPO_NAME_TRAINING --repository-format=docker --location=$REGION --description=&quot;Repositorio de treinamento de GNN&quot;<br>!gcloud auth configure-docker {REGION}-docker.pkg.dev --quiet<br><br># build da imagem de container<br>IMAGE_URI = (f&quot;{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPO_NAME_TRAINING}/classificador-gnn:latest&quot;)<br>! cd $APPLICATION_DIR; docker build ./ -t $IMAGE_URI; docker push $IMAGE_URI</pre><p>Finalmente, utilizando a imagem de container criada, podemos iniciar o treinamento do modelo utilizando a Vertex AI. Primeiro criamos as instruções de treinamento, onde informaremos o tamanho da máquina de treinamento e qual imagem irá ser utilizada:</p><pre># instruções de infraestrutura para o treinamento<br>worker_pool_specs = [<br>    {<br>        &quot;machine_spec&quot;: {<br>            &quot;machine_type&quot;: &quot;n1-standard-8&quot;,<br>        },<br>        &quot;replica_count&quot;: 1,<br>        &quot;container_spec&quot;: {<br>            &quot;image_uri&quot;: f&quot;{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPO_NAME_TRAINING}/classificador-gnn:latest&quot;<br>        },<br>    }<br>]<br><br>my_custom_job = aiplatform.CustomJob(<br>    display_name=&quot;classificador-gnn-job&quot;,<br>    worker_pool_specs=worker_pool_specs,<br>    staging_bucket=BUCKET_URI<br>)<br><br># execução do treinamento<br>model = my_custom_job.run(sync=True)<br><br>&lt;...&gt;<br>&lt;...&gt;<br><br>CustomJob projects/48397268769/locations/us-central1/customJobs/9184012131920510976 current state:<br>JobState.JOB_STATE_RUNNING<br>CustomJob projects/48397268769/locations/us-central1/customJobs/9184012131920510976 current state:<br>JobState.JOB_STATE_SUCCEEDED<br>CustomJob run completed. Resource name: projects/48397268769/locations/us-central1/customJobs/9184012131920510976</pre><p>Com o treinamento finalizado, podemos ver nos logs do treinamento todos os detalhes do treinamento, inclusive a avaliação do modelo que foi incluída ao final do código de treinamento (os logs podem ser encontrados na console da <a href="https://console.cloud.google.com/vertex-ai/training/custom-jobs">Vertex AI</a>):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/881/1*S5yxiDl7H30ghJ0vXEtC3Q.png" /><figcaption>logs do treinamento de modelos na Vertex AI</figcaption></figure><h4>Produtizando o modelo e realizando inferências</h4><p>Que legal! Mas e agora? Bom, costuma-se dizer que &quot;não existe machine learning se não vai pra produção&quot;, né? Ou seja, de que adianta termos um modelo que ficou bom, mas que não se tornou, além de útil, utilizável.</p><p>Como se trata de um cenário mais específico, onde usamos informações representadas em forma de grafos, é importante criarmos um container que realize as etapas que inferência necessárias para um modelo de grafo.</p><p>Felizmente, a Vertex AI apresenta um facilitador para esse processo chamado <a href="https://cloud.google.com/vertex-ai/docs/predictions/custom-prediction-routines">Custom Prediction Routines</a> (CPR). Com as CPR você se preocupa só com o seu código de interação com o modelo e a Vertex AI ficará responsável por toda a parte de infraestrutura do container — imagem base, build do container, etc.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/855/1*K17Lu933h6obc6u3lZRM2w.png" /><figcaption>uma visão geral da arquitetura das Custom Prediction Routines da Vertex AI</figcaption></figure><p>Para utilizar as CPR, assim como fizemos para o treinamento, precisamos criar um arquivo Python que contenha todas as etapas da nossa predição — com alguns módulos requeridos e algumas funções que precisam existir. O início do nosso arquivo ficou assim:</p><pre>%%writefile {PREDICTION_DIR}/predictor.py<br><br>import pickle<br>import tensorflow as tf<br>from tensorflow import keras<br>from tensorflow.keras import layers<br>from google.cloud import storage<br><br># modulos requeridos pelas CPR<br>from google.cloud.aiplatform.utils import prediction_utils<br>from google.cloud.aiplatform.prediction.predictor import Predictor<br><br>&lt;...&gt;</pre><p>Dentro desse mesmo arquivo, criamos as funções que realizarão a importação do modelo que treinamos com a Vertex AI, o pré-processamento dos dados enviados para inferência, a inferência em si e o retorno dos resultados:</p><pre>class CprPredictor(Predictor):<br> <br><br># etapa de carregamento do modelo<br>def load(self, artifacts_uri):<br>        &quot;&quot;&quot;Loads the model artifacts.&quot;&quot;&quot;<br>        prediction_utils.download_model_artifacts(artifacts_uri)<br>        self._model = tf.keras.models.load_model(filepath=&#39;.&#39;, <br>                               custom_objects={<br>                                   &#39;GraphConvLayer&#39;: GraphConvLayer, <br>                                   &#39;GNNNodeClassifier&#39;: GNNNodeClassifier,<br>                                   &#39;graph_info&#39;: graph_info<br>                               })<br><br><br># etapa de pré-processamento dos dados de inferência        <br>def preprocess(self, prediction_input):<br>    &quot;&quot;&quot;Prepare data for prediction.&quot;&quot;&quot;<br>    # dados de inferência<br>    infer_data_path, new_edges, new_node_indices = prediction_input[&quot;instances&quot;]<br>    blob = bucket.blob(infer_data_path)<br>    blob.download_to_filename(&#39;new_node_features.pickle&#39;)<br>    localfile = open(&#39;new_node_features.pickle&#39;, &#39;rb&#39;)<br>    new_node_features = pickle.load(localfile)<br>    new_edges = np.asarray(new_edges)<br>    return(new_node_features, new_edges, new_node_indices)<br><br><br># etapa da predição em si<br>def predict(self, new_data):<br>    &quot;&quot;&quot;Performs prediction.&quot;&quot;&quot;<br>    new_node_features, new_edges, new_node_indices = new_data<br>    self._model.node_features = new_node_features<br>    self._model.edges = new_edges<br>    self._model.edge_weights = tf.ones(shape=new_edges.shape[1])<br>    logits = self._model.predict([new_node_indices])<br>    probabilities = keras.activations.softmax(tf.convert_to_tensor(logits)).numpy()<br>    return([new_node_indices, probabilities.tolist()[0]])<br><br><br># retorno dos resultados da predição<br>def postprocess(self, prediction_results):<br>    return {&quot;predictions&quot;: prediction_results}</pre><p>Diferente da etapa de treinamento, aqui não realizaremos a criação de uma Dockerfile nem precisaremos nos preocupar com a criação de uma API REST no container ou o build desse container. A SDK da Vertex AI fará todo esse processo para nós:</p><pre>import os<br>from google.cloud.aiplatform.prediction import LocalModel<br>from classificadorgnn.prediction.predictor import CprPredictor<br><br>REPO_NAME_SERVING=&#39;predictor-gnn-repo&#39;<br><br>local_model = LocalModel.build_cpr_model(<br>    src_dir=PREDICTION_DIR,<br>    output_image_uri=f&#39;{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPO_NAME_SERVING}/predictor-gnn:latest&#39;,<br>    predictor=CprPredictor,<br>    requirements_path=os.path.join(PREDICTION_DIR, &#39;requirements.txt&#39;)) </pre><p>Com a imagem de predição criada pelas CPR, agora podemos para a nossa registry de modelos (neste caso, a <a href="https://cloud.google.com/vertex-ai/docs/model-registry/introduction">Model Registry da Vertex AI</a>) e informando que a API com o modelo publicado será implantada utilizando a imagem que customizamos com as CPR:</p><pre>model = aiplatform.Model.upload(<br>    display_name=&#39;modelo-classificador-gnn&#39;,<br>    artifact_uri=model_artifact[0] + &#39;model&#39;,<br>    serving_container_image_uri=f&#39;{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPO_NAME_SERVING}/predictor-gnn:latest&#39;)</pre><p>Com isso, estamos prontos para publicar o nosso modelo em uma API. Para isso, utilizaremos outra funcionalidade da Vertex AI, os <a href="https://cloud.google.com/vertex-ai/docs/predictions/overview#online_predictions">Endpoints</a>, que servem para, além de publicar o seu modelo dentro do seu perímetro de segurança da nuvem, também possui mecanismos de autoscaling da API do modelo, diminuindo a chance de indisponibilidades em caso de aumento abrupto de requisições.</p><p>A criação de um endpoint é muito simples — neste exemplo, definimos que nosso endpoint irá ser executado em uma configuração de máquinas n1-standard-8 e a configuração de autoscaling leva em consideração que sempre haverá, ao menos, uma instância executando a API do model (min_replicas_count=1) e a escalará até cinco instâncias em execução em paralelo (max_replicas_count=5). Além disso, por motivos de segurança, foi realizada a criação de uma service account específica para inferência — para garantir que a API do modelo só tenha acesso a recursos da Google Cloud que sejam explicitamente atribuídos.</p><pre>endpoint = model.deploy(machine_type=&quot;n1-standard-8&quot;,<br>            min_replica_count=1,<br>            max_replica_count=5,<br>            service_account=&#39;custom-gnn-sa@[...].gserviceaccount.com&#39;<br>            )</pre><p>Após essa ação, poderemos ver na console da Vertex AI que o endpoint estará online e com um modelo implementado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/837/1*Zspu6q1_GLb0D50meWPwbg.png" /><figcaption>o endpoint implantado sendo verificado como online</figcaption></figure><p>Podemos ver também qual modelo está implantado no endpoint, clicando sobre o nome do endpoint:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/714/1*WJAUYq98N0ZQ8995Ybj0pA.png" /><figcaption>verificando o modelo implantado dentro do endpoint</figcaption></figure><p>Com isso, temos a rede neural de grafo disponível em uma API REST que agora é acessível por todas as pessoas com acesso — não ficando limitado a times ou pessoas que realizam pesquisa e desenvolvimento de machine learning.</p><h4>Utilizando a API com o modelo treinado implantado</h4><p>Finalmente, podemos interagir com a API do nosso modelo de grafo e realizar inferências — O que torna um modelo de machine learning realmente util no mundo real.</p><p>Para realizar inferências, vamos simular o que aconteceria no mundo produtivo. Primeiro vamos criar dados sintéticos que representem novos dados do cenário — Em outras palavras, vamos criar novas informações de artigos científicos, incluindo citações entre esses novos artigos e os anteriores. Após isso, vamos enviar essas novas informações à API do nosso modelo e pediremos para que o nosso modelo classifique esses novos artigos dentro das possíveis classes (lembram? Neural_Networks, Probabilistic_Methods, Genetic_Algorithms, Theory, Case_Based, Reinforcement_Learning Rule_Learning):</p><pre># primeiro criamos os novos artigos fictícios<br>new_instances = generate_random_instances(num_classes)<br>new_node_features = np.concatenate([node_features, new_instances])<br><br># depois criamos as novas citações entre os artigos<br>num_nodes = node_features.shape[0]<br>new_node_indices = [i + num_nodes for i in range(num_classes)]<br>new_citations = []<br>for subject_idx, group in papers.groupby(&quot;subject&quot;):<br>    subject_papers = list(group.paper_id)<br>    # Select random x papers specific subject.<br>    selected_paper_indices1 = np.random.choice(subject_papers, 5)<br>    # Select random y papers from any subject (where y &lt; x).<br>    selected_paper_indices2 = np.random.choice(list(papers.paper_id), 2)<br>    # Merge the selected paper indices.<br>    selected_paper_indices = np.concatenate(<br>        [selected_paper_indices1, selected_paper_indices2], axis=0<br>    )<br>    # Create edges between a citing paper idx and the selected cited papers.<br>    citing_paper_indx = new_node_indices[subject_idx]<br>    for cited_paper_idx in selected_paper_indices:<br>        new_citations.append([citing_paper_indx, cited_paper_idx])<br><br># preparamos essas novas informações<br># como novas citações e novas arestas para o grafo<br>new_citations = np.array(new_citations).T<br>new_edges = np.concatenate([edges, new_citations], axis=1)</pre><p>E, com estas novas informações, podemos fazer uma solicitação de inferência ao nosso modelo:</p><pre>results = endpoint.predict(instances=[infer_data_path, <br>                            new_edges.tolist(), <br>                            new_node_indices])</pre><p>Para simplificar a interpretação desses resultados, podemos criar uma função que irá processar as respostas:</p><pre>def display_class_probabilities(probabilities):<br>    for instance_idx, probs in enumerate(probabilities):<br>        print(f&quot;Instance {instance_idx + 1}:&quot;)<br>        for class_idx, prob in enumerate(probs):<br>            print(f&quot;- {class_values[class_idx]}: {round(prob * 100, 2)}%&quot;)<br><br>display_class_probabilities(results[0][1])</pre><p>E podemos ver como o nosso modelo classificou cada um dos novos artigos:</p><pre>Instance 1:<br>- Case_Based: 0.26%<br>- Genetic_Algorithms: 0.31%<br>- Neural_Networks: 80.14%<br>- Probabilistic_Methods: 1.17%<br>- Reinforcement_Learning: 0.99%<br>- Rule_Learning: 0.07%<br>- Theory: 17.06%<br><br>Instance 2:<br>- Case_Based: 0.2%<br>- Genetic_Algorithms: 0.11%<br>- Neural_Networks: 98.67%<br>- Probabilistic_Methods: 0.23%<br>- Reinforcement_Learning: 0.3%<br>- Rule_Learning: 0.01%<br>- Theory: 0.48%<br><br>Instance 3:<br>- Case_Based: 0.32%<br>- Genetic_Algorithms: 0.34%<br>- Neural_Networks: 97.2%<br>- Probabilistic_Methods: 0.28%<br>- Reinforcement_Learning: 0.99%<br>- Rule_Learning: 0.02%<br>- Theory: 0.86%<br><br>Instance 4:<br>- Case_Based: 0.15%<br>- Genetic_Algorithms: 94.22%<br>- Neural_Networks: 0.47%<br>- Probabilistic_Methods: 0.01%<br>- Reinforcement_Learning: 5.09%<br>- Rule_Learning: 0.01%<br>- Theory: 0.05%<br><br>Instance 5:<br>- Case_Based: 0.05%<br>- Genetic_Algorithms: 0.12%<br>- Neural_Networks: 96.56%<br>- Probabilistic_Methods: 0.86%<br>- Reinforcement_Learning: 0.65%<br>- Rule_Learning: 0.01%<br>- Theory: 1.74%<br><br>Instance 6:<br>- Case_Based: 0.01%<br>- Genetic_Algorithms: 0.02%<br>- Neural_Networks: 99.47%<br>- Probabilistic_Methods: 0.06%<br>- Reinforcement_Learning: 0.09%<br>- Rule_Learning: 0.0%<br>- Theory: 0.36%<br><br>Instance 7:<br>- Case_Based: 0.9%<br>- Genetic_Algorithms: 0.16%<br>- Neural_Networks: 28.22%<br>- Probabilistic_Methods: 61.46%<br>- Reinforcement_Learning: 3.04%<br>- Rule_Learning: 0.41%<br>- Theory: 5.8%</pre><h4>Conclusão e Próximos Passos</h4><p><strong>Parabéns!!</strong> Você percorreu toda essa longa jornada. Não se preocupe — este não é um cenário trivial mas, ao mesmo tempo, é bom começar a conhecê-lo pois traz muito poder de entedimento do relacionamento de dados mais complexos e não representáveis de uma forma simples.</p><p>Como já dito antes, todo o código e o detalhamento das etapas técnicas de treinamento e predição podem ser encontradas no notebook <a href="https://github.com/lucianommartins/vertexai-gnn-classification/blob/main/GNN_com_VertexAI.ipynb">Redes Neurais de Grafo na Vertex AI de Google Cloud</a>.</p><p>Você possui um cenário onde grafos podem enriquecer a qualidade de seus dados ou de suas predições? Executou o código deste blog, mas não entendeu bem algo? Sintam-se, também, super bem vindos caso queiram falar mais sobre essa abordagem, entrando em contato comigo nas redes sociais :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3e0884ab4efb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/google-cloud-brasil/treinando-graph-neural-networks-utilizando-a-vertex-ai-3e0884ab4efb">Treinando Graph Neural Networks utilizando a Vertex AI</a> was originally published in <a href="https://medium.com/google-cloud-brasil">google-cloud-brasil</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ Aplicando Machine Learning em seus vídeos com a Vertex AI Vision ]]></title>
            <link>https://medium.com/google-cloud-brasil/aplicando-machine-learning-em-seus-v%C3%ADdeos-com-a-vertex-ai-vision-8656fd1204e6?source=rss-925379214ac4------2</link>
            <guid isPermaLink="false">https://medium.com/p/8656fd1204e6</guid>
            <category><![CDATA[computer-vision]]></category>
            <category><![CDATA[vertex-ai-vision]]></category>
            <category><![CDATA[visão-computacional]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[vertex-ai]]></category>
            <dc:creator><![CDATA[Luciano Martins]]></dc:creator>
            <pubDate>Tue, 22 Nov 2022 16:51:43 GMT</pubDate>
            <atom:updated>2022-11-22T17:46:51.059Z</atom:updated>
            <content:encoded><![CDATA[<p><strong><em>* TLDR: Aqui vamos criar uma aplicação que irá (1) Ingerir vídeos pré-gravados (arquivos MP4 em formato H.264); (2) Salvar e buscar informações no Warehouse, (3) Armazenar metadados em uma tabela no BigQuery e, numa experiência low code, gerar analytics a partir de uma câmera de monitoramento de tráfego.</em></strong></p><p>Os sistemas fechados de televisão (ou cctv, do inglês <em>closed circuit television</em>) são uma tecnologia que já existe há mais de 20 anos e que é aplicada em diversas indústrias — financeira, transporte, entretenimento, logística e a lista segue longa.</p><p>Com o aumento do acesso à câmeras com maior qualidade e links de maior velocidade, aumentou, também, a sua adoção — em diferentes casos de usos, pra diferentes indústrias:</p><figure><img alt="Diferentes desafios em diferentes indústrias" src="https://cdn-images-1.medium.com/max/1024/0*xAfeH0ypvEi9aCZJ" /><figcaption>Diferentes desafios em diferentes indústrias</figcaption></figure><p>o que nos traz um desafio: como podemos processar os dados de todos esses dispositivos, o mais próximo possível do “tempo real” e retirar informações dessas imagens?</p><p>Para simplificar esse processo, lançamos no Google Next 2022 a <a href="https://cloud.google.com/vertex-ai-vision">Vertex AI Vision</a>, onde você consegue consolidar as atividades de ingestão, processamento dos dados com modelos de machine learning e armazenamento dos vídeos e dos metadados.</p><p>Para começar a implementar soluções usando a Vertex Vision, é importante entender e revisar alguns conceitos e componentes:</p><p><strong>Streams:</strong> representam a camada de streaming de vídeo da sua solução. A origem do vídeo pode ser um vídeo ao vivo (ou seja, uma câmera IP), ou um arquivo de vídeo (ou seja, um arquivo MP4).</p><p><strong>Application:</strong> É a entidade na Vertex Vision que conecta seu stream de vídeo a um processador de IA para realizar uma operação de aprendizado de máquina no vídeo (ou seja, conectar um fluxo de câmera CCTV a um modelo de IA para extração de insights).</p><p><strong>Media Warehouse:</strong> É onde serão armazenados os vídeos ingeridos por stream, e também os metadados dos processadores de IA aplicados nos streams ingeridos.</p><p>Com estes conceitos em mente, você consegue construir soluções que seguirão um fluxo de processamento similar ao abaixo:</p><figure><img alt="pipeline de funcionamento da Vertex AI Vision" src="https://cdn-images-1.medium.com/max/1024/0*meCzjfaP48QhNk52" /><figcaption>pipeline de funcionamento da Vertex AI Vision</figcaption></figure><p>Onde você irá:</p><p>- Numa primeira etapa, conectar suas câmeras, ou arquivos de gravação das câmeras, em um stream da Vertex Vision, para realizar a ingestão das informações</p><p>- Depois decidir que ação tomar com esses vídeos — como utilizar modelos pré-treinados pelo Google, ou utilizar um modelo de detecção de objetos treinado por você</p><p>- E, finalmente, utilizar a Vision Warehouse para fazer análise ou busca de vídeos, ou ainda conectar os metadados no BigQuery e gerar mais informações analíticas com estes dados.</p><p>Mas como funcionaria esse processo todo? Bom vamos ver isso passo a passo.</p><h3>Pré-requisitos para criar sua solução com a Vertex AI Vision</h3><p>Algumas ações são necessárias antes de irmos para a criação da solução em si — Isso inclui ativar o serviço da Vertex AI Vision na console, algumas configurações de acesso no IAM e também a instalação do SDK.</p><h3>Ativação do serviço da Vertex AI Vision</h3><p>Primeiro você precisa fazer a ativação do serviço da Vertex AI Vision. Você pode clicar no botão “enable Vertex AI Vision API” que aparece na tela, quando você acessa o serviço <a href="https://console.cloud.google.com/ai/vision-ai">na console</a>:</p><figure><img alt="Habilitando o serviço da Vertex AI Vision" src="https://cdn-images-1.medium.com/max/758/0*2jePpP6xkCinwpQ_" /><figcaption>Habilitando o serviço da Vertex AI Vision</figcaption></figure><p>Ou você pode fazer a ativação do serviço via linha de comando:</p><pre>$ gcloud services enable visionai.googleapis.com<br>Operation &quot;operations/acat.p2–674219556369–7e9d3d6c-9f49–452e-a184-af2ea9b61681&quot; finished successfully.<br><br>$ gcloud services list --enabled | grep -i visionai<br>visionai.googleapis.com Vision AI API</pre><h3>Configuração de IAM para acesso à Vertex AI Vision</h3><p>Para montar a jornada apresentada aqui nesta postagem, vamos conceder ao usuário que realizará as etapas a permissão de Editor na Vertex AI Vision — Para isso, vamos utilizar o comando <a href="https://cloud.google.com/sdk/docs/install">glcoud</a> abaixo:</p><pre>$ gcloud projects add-iam-policy-binding &lt;PROJECT_ID&gt; \<br>--member &#39;SECURITY_PRINCIPAL&#39; --role=&#39;roles/visionai.editor&#39;</pre><p>Então, por exemplo, se o seu project id é ‘meu-projeto-ai’ e você quer dar acesso ao usuário usuario01@dominio.com.br, você deve executar o comando como:</p><pre>$ gcloud projects add-iam-policy-binding meu-projeto-ai \<br>--member user:usuario01@dominio.com.br --role=&#39;roles/visionai.editor&#39;</pre><p>Para garantir que você não tenha problemas de autenticação, antes de seguir com as configurações de serviços, é interessante você executar os dois comandos abaixo:</p><pre>$ gcloud auth login<br>$ gcloud auth application-default login</pre><h3>Instalação da SDK da Vertex AI Vision</h3><p>De último, mas não menos importante, você precisa do utilitário de linha de comando da SDK da Vertex AI Vision — o vaictl — para realizar algumas atividades descritas aqui. Abaixo como fiz para instalar utilizando um servidor Linux, baseado em Debian x86_64:</p><pre>$ gsutil cp gs://visionai-artifacts/visionai_0.0–3_amd64.deb .<br>$ sudo apt install ./visionai_0.0–3_amd64.deb</pre><p>Se a instalação ocorreu sem problemas, você deve conseguir executar o comando “vaictl” direto no seu shell:</p><pre>$ vaictl --help<br>This command line tool enables the user to<br>manage and interact with resources in Vision AI.<br>Usage:<br>vaictl [command]<br>Available Commands:<br>completion Generate the autocompletion script for the specified shell<br>create Create API resources in Vision AI.<br>delete Delete API resources in Vision AI.<br>disable Disable features for specific resources in Vision AI.<br>enable Enable features for specific resources in Vision AI.<br>help Help about any command<br>list List API resources in Vision AI.<br>receive Receive data from Vision AI.<br>send Send data to Vision AI.<br>Flags:<br>-c, --cluster-id string The cluster id.<br>-h, --help help for vaictl<br>-l, --location-id string The GCP location id.<br>-p, --project-id string The GCP project id.<br>    --service-endpoint string The service endpoint for Vision AI. (default &quot;visionai.googleapis.com&quot;)<br>    --timeout int The default timeout (in seconds) for operations. (default 10)<br>-v, --verbose Verbose output.<br>Use &quot;vaictl [command] - help&quot; for more information about a command.</pre><p>Neste ponto, o seu ambiente está pronto para seguir em frente com esta experimentação.</p><p>Caso você queira mais alternativas de instalação, consulte a <a href="https://cloud.google.com/vision-ai/docs/cloud-environment#install-client-libraries">documentação da Vertex AI Vision</a>.</p><h3>Criação de tabela de metadados no BigQuery</h3><p>Como uma das atividades que faremos aqui é o armazenamento de metadados dos vídeos no BigQuery, precisamos criar a tabela que utilizaremos. Para isso, executei a query abaixo (para o seu cenário, altere o nome do dataset de “vision_ai_analytics” para o nome de seu dataset e de “metadata_table” para o nome da tabela que você quer criar:</p><pre>CREATE TABLE `vision_ai_analytics.metadata_table` (<br>ingestion_time TIMESTAMP NOT NULL,<br>application STRING NOT NULL,<br>instance STRING NOT NULL,<br>node STRING NOT NULL,<br>annotation STRING)</pre><h3>Criação da sua Vertex AI Vision Application</h3><p>Para começar a utilizar seus vídeos na Vertex AI Vision, você precisa trazê-los para a plataforma. Para isso, criaremos um “stream” — que será responsável pela ingestão dos dados, seja o conteúdo de uma câmera IP, em tempo real, ou dados históricos/gravados anteriormente.</p><p><strong>Para começar a criar nossa aplicação de contagem de carros</strong>, primeiro vamos abrir a dashboard da Vertex AI Vision, você deve acessar sua <a href="https://console.cloud.google.com/">console</a> da Google Cloud, ir na seção “Inteligência Artificial” e clicar na opção da Vertex AI Vision. Após isso, clique na opção “Studio”, escolha a opção “Create a new application” e escolha o nome da sua aplicação (no meu caso, “contador-carros”):</p><figure><img alt="Criando sua aplicação na Vertex AI Vision" src="https://cdn-images-1.medium.com/max/1024/0*YztydCiQF5TIiAZM" /><figcaption>Criando sua aplicação na Vertex AI Vision</figcaption></figure><p>O Studio lhe dará uma interface de construção em blocos, onde você clica nos itens que você quer incluir em sua aplicação e ele será introduzido no grafo de execução de sua aplicação.</p><p>O primeiro bloco que você vai incluir é o de ingestão do vídeo. Em “Connectors”, clique em “Streams”. No lado direito, aparecerá um menu — clique em “+ Add Streams”:</p><figure><img alt="Adicionando um stream à sua application" src="https://cdn-images-1.medium.com/max/390/0*VMU6ckdtR_1HaAw1" /><figcaption>Adicionando um stream à sua application</figcaption></figure><p>Na próxima tela, selecione “Register new streams”, informe o nome do stream (no meu caso, “camera-carros”) e clique em “Add Streams”:</p><figure><img alt="Configuração do novo stream" src="https://cdn-images-1.medium.com/max/697/0*cI_ZCMMmqqO7jl6x" /><figcaption>Configuração do novo stream</figcaption></figure><p>O próximo passo é incluir um bloco de “Vision Warehouse”. No menu do lado esquerdo, em “Connectors”, selecione “Vision AI Warehouse”. No menu que aparecerá no lado direito, clique em “Connect Warehouse”:</p><figure><img alt="Conectando uma Vision Warehouse" src="https://cdn-images-1.medium.com/max/385/0*RDFFLq4v7A81-z0S" /><figcaption>Conectando uma Vision Warehouse</figcaption></figure><p>Na próxima tela, selecione a opção “Create new warehouse” e informe o nome do warehouse (no meu caso, “carros-warehouse”):</p><figure><img alt="Criação de novo Vision Warehouse" src="https://cdn-images-1.medium.com/max/657/0*c0dOvujtSboFlIGB" /><figcaption>Criação de novo Vision Warehouse</figcaption></figure><p>O próximo passo é incluir o bloco que processará o vídeo, aplicando um modelo de Machine Learning. Aqui usaremos um modelo pré-treinado pelo Google que irá realizar contagem de objetos — no nosso cenário, contagem de carros em uma cena. Para isso, em “Specialized models”, selecione “Occupancy analytics:</p><figure><img alt="Adicionando um modelo especializado na application" src="https://cdn-images-1.medium.com/max/560/0*SS2H9-bv0jw25ZuA" /><figcaption>Adicionando um modelo especializado na application</figcaption></figure><p>De último, mas não menos importante, precisamos criar o conector para o BigQuery — onde os metadados de nossa aplicação irão ser armazenados. Para isso, no menu do lado esquerdo, selecione “BigQuery” em “Connectors”. No menu do lado direito, em “Settings”, clique em “Browser” para escolher a tabela que receberá os metadados; e, em “Store metadata from” selecione “Streams” e “Occupancy analytics”. Você deve ver um resultado como este:</p><figure><img alt="Conectando uma tabela do BigQuery para armazenar metadados" src="https://cdn-images-1.medium.com/max/444/0*MwOdIhrwCb1rbLyq" /><figcaption>Conectando uma tabela do BigQuery para armazenar metadados</figcaption></figure><p>Ao final destas atividades, você deve ter uma visualização do fluxo de funcionamento de sua aplicação, em similar a um grafo, semelhante ao abaixo:</p><figure><img alt="Visualização do grafo da sua application" src="https://cdn-images-1.medium.com/max/1024/0*qjnu5t7Udpc3gCJh" /><figcaption>Visualização do grafo da sua application</figcaption></figure><p>E então, clique em “Deploy”, no topo da janela e confirme clicando em “Deploy”, novamente, na nova janela que aparecer:</p><figure><img alt="Fazendo o deploy da sua application" src="https://cdn-images-1.medium.com/max/711/0*IuF1k6WG-IbpRHEm" /><figcaption>Fazendo o deploy da sua application</figcaption></figure><p>Ao final do deployment, você deve ter a mensagem de sucesso abaixo:</p><figure><img alt="Confirmando que seu deploy foi bem sucedido" src="https://cdn-images-1.medium.com/max/505/0*739rZS4TzfxEmPX3" /><figcaption>Confirmando que seu deploy foi bem sucedido</figcaption></figure><p>E você deve encontrar sua aplicação como “Deployed”, também, no menu “Applications” da Vertex AI Vision:</p><figure><img alt="Validando que sua aplicação está implantada" src="https://cdn-images-1.medium.com/max/1008/0*aQeyYgippo92vhwf" /><figcaption>Validando que sua aplicação está implantada</figcaption></figure><h3>Ingerindo vídeos com a Vertex AI Vision SDK</h3><p>Com sua aplicação configurada e implantada na Vertex AI, agora você consegue usar a SDK para ingerir seus vídeos e processá-los. Com a Vertex AI Vision você consegue ingerir vídeos em tempo real (usando o protocolo RTSP) ou arquivos de vídeos armazenados localmente. Aqui iremos utilizar vídeos pré-gravados. O vídeo que utilizaremos é a gravação de uma câmera de tráfego:</p><figure><img alt="Visualização do vídeo de exemplo utilizado" src="https://cdn-images-1.medium.com/max/583/0*HhvEMr2CA5Ac__fP" /><figcaption>Visualização do vídeo de exemplo utilizado</figcaption></figure><p>Utilizaremos o utilitário de linha de comando “vaictl” para realizar a ingestão via SDK:</p><pre>$ vaictl -p lucianomartins-demos-345000 -l us-central1 \<br>-c application-cluster-0 --service-endpoint visionai.googleapis.com \<br>send video-file to streams camera-carros \<br>--file-path=/home/lucianomartins/Documents/prototypes/ai-apis/data/carros02.mp4 \<br>--loop</pre><p>Após a execução, você deve receber a mensagem abaixo — que irá confirmar que sua ingestão foi iniciada:</p><pre>Sending data into event &quot;jseawg51&quot; through stream &quot;camera-carros&quot;.</pre><p>Você consegue confirmar que sua ingestão está funcionando clicando em “Streams” e no seu stream (“camera-carros”, no meu caso aqui) na console da Vertex AI Vision:</p><figure><img alt="Visualizando o seu vídeo após a ingestão na Vertex AI Vision" src="https://cdn-images-1.medium.com/max/1024/0*3GiXF9AFgJUZ-tAH" /><figcaption>Visualizando o seu vídeo após a ingestão na Vertex AI Vision</figcaption></figure><h3>Analisando vídeos utilizando a Vision Warehouse</h3><p>Com a aplicação em execução, podemos começar a conferir seu funcionamento. Primeiro podemos buscar informações na Vision Warehouse. Para isso, na console da Vertex AI Vision, clique em “Warehouses” e, para a warehouse que foi criada para este exemplo, clique em “view assets”. Na nova tela que aparecer, podemos fazer, por exemplo, uma busca por vídeos — aqui, estou selecionando o stream “camera-carros” e somente vídeos de hoje no “data range”:</p><figure><img alt="Fazendo busca de vídeos da Vision Warehouse" src="https://cdn-images-1.medium.com/max/1024/0*Xq6WQSZqHMX0cQBq" /><figcaption>Fazendo busca de vídeos da Vision Warehouse</figcaption></figure><p>Desta forma, agora conseguimos navegar em nosso histórico de vídeos — seja por intervalo de datas, ou buscar informações de metadados.</p><h3>Acessando metadados do Vertex AI Vision no BigQuery</h3><p>Como última etapa de nossa jornada aqui, iremos utilizar as informações capturadas no stream de vídeo e processadas pelo modelo de machine learning de contagem de objetos. Assim, conseguimos conectar o desafio de processamento de imagens de câmeras CCTV com informações analytics úteis para tomadas de decisão.</p><p>Primeiro vamos verificar o conteúdo de nossa tabela de metadados. Para isso, na console do BigQuery você pode utilizar a query abaixo (adequando a query para o seu nome de projeto, dataset e tabela):</p><pre>WITH<br>raw_counts AS (<br>SELECT<br>*<br>FROM (<br>SELECT<br>TIMESTAMP_TRUNC(<br>PARSE_TIMESTAMP(&#39;&quot;%Y-%m-%dT%H:%M:%E*SZ&quot;&#39;,<br>JSON_QUERY(annotation,<br>&quot;$.currentTime&quot;)),<br>MINUTE) AS currentTime,<br>CAST(JSON_QUERY(annotation,<br>&#39;$.stats.fullFrameCount[1].count&#39;) AS INT64) AS count,<br>JSON_QUERY(annotation,<br>&#39;$.stats.fullFrameCount[1].entity.labelString&#39;) AS type<br>FROM<br>`lucianomartins-demos-345000.vision_ai_analytics.metadata_table` )<br>WHERE<br>count IS NOT NULL )<br>SELECT<br>currentTime,<br>SUM(count) AS total_count,<br>type<br>FROM<br>raw_counts<br>GROUP BY<br>currentTime, type</pre><p>Você deve ter algo parecido com este output como resultado:</p><figure><img alt="Resultado da query na tabela de metadados no BigQuery" src="https://cdn-images-1.medium.com/max/564/0*vbnugXJhoFI626gy" /><figcaption>Resultado da query na tabela de metadados no BigQuery</figcaption></figure><p>Ou seja, você já consegue verificar a contagem de veículos em seus vídeos, em recortes por minuto. E a partir daqui, podemos realizar mais atividades para enriquecer decisões — como criar um modelo para prever o tráfego nos próximos dias/semanas para planejar uma manutenção, por exemplo.</p><p>Para conhecer mais características, funcionalidades e casos de uso possíveis, consulte a <a href="https://cloud.google.com/vertex-ai-vision">documentação oficial</a> da Vertex AI Vision.</p><p>Espero que você tenha se divertido nessa jornada. Caso você tenha um cenário interessante em implementação na Vertex AI Vision e queira compartilhar, mande uma mensagem para criarmos um blog com a sua experimentação 🙂</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8656fd1204e6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/google-cloud-brasil/aplicando-machine-learning-em-seus-v%C3%ADdeos-com-a-vertex-ai-vision-8656fd1204e6">🎥 Aplicando Machine Learning em seus vídeos com a Vertex AI Vision 🎥</a> was originally published in <a href="https://medium.com/google-cloud-brasil">google-cloud-brasil</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O Início da Jornada em Google Cloud AI — Parte I]]></title>
            <link>https://medium.com/google-cloud-brasil/o-in%C3%ADcio-da-jornada-em-google-cloud-ai-parte-i-ea6c8927f0e6?source=rss-925379214ac4------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea6c8927f0e6</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <dc:creator><![CDATA[Luciano Martins]]></dc:creator>
            <pubDate>Mon, 01 Aug 2022 14:10:37 GMT</pubDate>
            <atom:updated>2022-12-05T02:30:07.352Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>O Início da Jornada em Google Cloud AI</strong></h3><p>O objetivo deste texto é servir como um <em>baseline</em> conceitual de Google Cloud AI — ou uma visão geral das API, serviços, plataformas e soluções disponíveis. Servirá, também, como uma revisão de alguns desafios relacionados à projetos de Machine Learning (ML), assim como as diferentes formas de desenvolver soluções de ML utilizando Google Cloud.</p><h3>Inteligência Artificial? Machine Learning? Deep Learning?</h3><p>Especialmente para desenvolvedores iniciando a jornada de adoção de recursos de Inteligência Artificial (IA) em suas aplicações, acaba ocorrendo certa confusão entre estes termos. Chega-se a pensar que eles sejam intercambiáveis. Então, antes de começarmos, é interessante traçar um conceito básico de cada termo.</p><p><strong>Inteligência Artificial (IA): </strong>De forma geral, podemos pensar em IA como qualquer solução computacional capaz de realizar tarefas que requerem “inteligência humana”. Por exemplo, um jogo de xadrez de computador, baseado em regras de movimentação de uma peça, condições programáticas e análise de jogadas futuras.</p><p><strong>Machine Learning (ML): </strong>É uma sub-área da IA onde a abordagem de resolução de problemas muda: Ao invés de se pensar somente em regras e condições, começa-se a “ensinar” o programa detalhes do cenário em questão utilizando amostras de dados. Nesta abordagem se utiliza diversas técnicas matemáticas e estatísticas.</p><p><strong>Deep Learning (DL): </strong>É uma sub-área de ML onde, para se abordar problemas mais complexos, se utiliza redes neurais profundas (ou <em>deep</em> neural networks). É a abordagem utilizada para algumas soluções como detectar objetos em uma imagem; classificar o conteúdo de uma imagem; fazer a geração de novas imagens; realizar a tradução de um texto de um idioma para outro; etc. Podemos pensar na inter relação entre estes termos por este modelo de cebola:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1004/1*qVYayPLHUSikcDQ2S5yHfQ.png" /></figure><p>Para uma imersão maior e mais aprofundada nos conceitos e técnicas de ML, recomendo você dar uma olhada no <a href="https://developers.google.com/machine-learning/crash-course">Machine Learning Crash Course</a> disponível no portal de <a href="https://developers.google.com/">Google Developers</a>.</p><p>Com esta visão de diferentes abordagens em mente, podemos pensar que, nos dias de hoje, na maioria dos cenários que trabalhamos, há desafios que podem ser atendidos utilizando técnicas de IA. Confira abaixo alguns exemplos de desafios em diferentes indústrias:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Bbm0vyWZQI0BczIG203C6A.png" /></figure><p>Mas e da perspectiva do desenvolvedor? Como iniciar esta jornada? Esta decisão é importante e é guiada por alguns fatores — em qual estágio você, ou seu time de desenvolvimento, se encontra em relação ao desenvolvimento. Isso inclui o entendimento de qual profundidade será utilizada para se criar um modelo — podendo ser:</p><p><strong>a)</strong> Adotar soluções prontas para solucionar problemas específicos (como os exemplos do gráfico acima) de indústrias específicas</p><p><strong>b)</strong> Utilizar modelos pré-treinados, servidos e utilizados via chamadas à APIs REST</p><p><strong>c)</strong> Treinar modelos customizados de forma automática, gerenciando seus dados, sem se preocupar com a parte de modelagem de Machine Learning</p><p><strong>d)</strong> Treinar modelos customizados, controlando todas as etapas do processo: gerenciamento dos dados, modelagem de Machine Learning e otimização do modelo ao fim do treinamento.</p><p><strong>e)</strong> Uma visão geral destas abordagens e dos serviços disponíveis na Google Cloud podem ser vistas abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2gfCROAQ4QwT8g2vhe4xgA.png" /></figure><p>Nas próximas postagens de AI &amp; Machine Learning neste blog, você poderá acompanhar, de uma forma mais prática e técnica, como adotar e como utilizar os serviços, APIs e modelos de cada nível de adoção desta imagem.</p><p>Um grande abraço a todos e até a próxima!</p><p><strong>Referências:</strong><br><a href="https://cloud.google.com/products/ai">https://cloud.google.com/products/ai</a><br><a href="https://cloud.google.com/solutions">https://cloud.google.com/solutions</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea6c8927f0e6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/google-cloud-brasil/o-in%C3%ADcio-da-jornada-em-google-cloud-ai-parte-i-ea6c8927f0e6">O Início da Jornada em Google Cloud AI — Parte I</a> was originally published in <a href="https://medium.com/google-cloud-brasil">google-cloud-brasil</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>